Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Emisores y procesadores de emisores Los casos de uso de los emisores suelen constar de varias partes. Esta sección está organizada por función (por ejemplo, trabajar con pines). En un sistema de producción, las llaves suelen centrarse en una bandeja de tarjetas determinada y se crean durante la configuración de la papelera y no en línea, como se muestra aquí. **Topics** + [Funciones generales](use-cases-issuers.generalfunctions.md) + [Funciones específicas de la red](use-cases-issuers.networkfunctions.md) # Funciones generales **Topics** + [Genera un pin aleatorio y el PVV asociado y, a continuación, verifica el valor](use-cases-issuers.generalfunctions.pvv.md) + [Genera o verifica un CVV para una tarjeta determinada](use-cases-issuers.generalfunctions.cvv.md) + [Genera o verifica una CVV2 para una tarjeta específica](use-cases-issuers.generalfunctions.cvv2.md) + [Genera o verifica un iCVV para una tarjeta específica](use-cases-issuers.generalfunctions.icvv.md) + [Verifique un ARQC de EMV y genere un ARPC](use-cases-issuers.generalfunctions.arqc.md) + [Genere y verifique un MAC EMV](use-cases-issuers.generalfunctions.emvmac.md) + [Genera un EMV MAC para el cambio de PIN](use-cases-issuers.generalfunctions.emvpinchange.md) # Genera un pin aleatorio y el PVV asociado y, a continuación, verifica el valor **Topics** + [Crea la (s) clave (s)](#use-cases-issuers.generalfunctions.pvv.setup) + [Genera un pin aleatorio, genera el PVV y devuelve el PIN y el PVV cifrados](#use-cases-issuers.generalfunctions.pvv.generate) + [Valide el PIN cifrado mediante el método PVV](#use-cases-issuers.generalfunctions.pvv.verify) ## Crea la (s) clave (s) Para generar un pin aleatorio y el [PVV](terminology.md#terms.pvv), necesitarás dos claves: una [clave de verificación del PIN (PVK) para generar el PVV](terminology.md#terms.pvk) y una [clave de cifrado del PIN](terminology.md#terms.pek) para cifrar el pin. El pin en sí se genera aleatoriamente de forma segura dentro del servicio y no está relacionado criptográficamente con ninguna de las claves. El PGK debe ser una clave del algoritmo TDES\$12KEY basado en el propio algoritmo PVV. Un PEK puede ser TDES\$12KEY, TDES\$13KEY o AES\$1128. En este caso, dado que el PEK está diseñado para uso interno en el sistema, el AES\$1128 sería una buena opción. Si un PEK se utiliza para intercambiarlo con otros sistemas (p. ej., redes de tarjetas, compradores ATMs) o se va a trasladar como parte de una migración, TDES\$12KEY puede ser la opción más adecuada por motivos de compatibilidad. ### Cree el PEK ``` $ aws payment-cryptography create-key \ --exportable --key-attributes KeyAlgorithm=AES_128,KeyUsage=TR31_P0_PIN_ENCRYPTION_KEY,\ KeyClass=SYMMETRIC_KEY,\ KeyModesOfUse='{Encrypt=true,Decrypt=true,Wrap=true,Unwrap=true}' --tags='[{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt", "KeyAttributes": { "KeyUsage": "TR31_P0_PIN_ENCRYPTION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "AES_128", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "7CC9E2", "KeyCheckValueAlgorithm": "CMAC", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/ivi5ksfsuplneuyt*. Lo necesitará en el siguiente paso. ### Crea el PVK ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_V2_VISA_PIN_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ov6icy4ryas4zcza", "KeyAttributes": { "KeyUsage": "TR31_V2_VISA_PIN_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "51A200", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/ov6icy4ryas4zcza*. Lo necesitará en el siguiente paso. ## Genera un pin aleatorio, genera el PVV y devuelve el PIN y el PVV cifrados **Example** En este ejemplo, generaremos un nuevo pin (aleatorio) de 4 dígitos donde las salidas serán cifradas `PIN block` (. PinData PinBlock) y un `PVV` (PinData). VerificationValue). Las entradas clave son `PAN` el formato `Pin Verification Key` (también conocido como clave de generación de pines) `Pin Encryption Key` y el formato [PIN Block](terminology.md#terms.pinblock). Este comando requiere que la clave sea de tipo`TR31_V2_VISA_PIN_VERIFICATION_KEY`. ``` $ aws payment-cryptography-data generate-pin-data --generation-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --generation-attributes VisaPin={PinVerificationKeyIndex=1} ``` ``` { "GenerationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2", "GenerationKeyCheckValue": "7F2363", "EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt", "EncryptionKeyCheckValue": "7CC9E2", "EncryptedPinBlock": "AC17DC148BDA645E", "PinData": { "VerificationValue": "5507" } } ``` ## Valide el PIN cifrado mediante el método PVV **Example** En este ejemplo, validaremos un PIN para un PAN determinado. Por lo general, el titular de la tarjeta o el usuario proporcionan el PIN durante el momento de la transacción para su validación y se compara con el valor registrado (la entrada del titular de la tarjeta se proporciona como un valor cifrado del terminal u otro proveedor principal). Para validar esta entrada, también se proporcionarán los siguientes valores en tiempo de ejecución: el pin cifrado, la clave utilizada para cifrar el pin de entrada (a menudo denominado [IWK](terminology.md#terms.iwk)) `PAN` y el valor con el que realizar la verificación (a `PVV` o`PIN offset`). Si la criptografía de AWS pago puede validar el PIN, se devuelve un http/200. Si el pin no está validado, devolverá un http/400. ``` $ aws payment-cryptography-data verify-pin-data --verification-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --verification-attributes VisaPin="{PinVerificationKeyIndex=1,VerificationValue=5507}" --encrypted-pin-block AC17DC148BDA645E ``` ``` { "VerificationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2", "VerificationKeyCheckValue": "7F2363", "EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt", "EncryptionKeyCheckValue": "7CC9E2", } ``` # Genera o verifica un CVV para una tarjeta determinada [CVV](terminology.md#terms.cvv) o CVV1 es un valor que tradicionalmente está incrustado en la banda magnética de una tarjeta. No es lo mismo que CVV2 (visible para el titular de la tarjeta y para su uso en compras en línea). El primer paso es crear una clave. Para este tutorial, debe crear una clave [CVK](terminology.md#terms.cvk) 3DES (2KEY TDES) de doble longitud. **nota** Tanto el CVV CVV2 como el iCVV utilizan algoritmos similares, si no idénticos, pero varían los datos de entrada. Todos utilizan el mismo tipo de clave TR31 \$1C0\$1CARD\$1VERIFICATION\$1KEY, pero se recomienda utilizar claves distintas para cada propósito. Se pueden distinguir mediante etiquetas de alias, como en el ejemplo siguiente. and/or ## Crea la clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVV"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "DE89F9", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/r52o3wbqxyf6qlqr*. Lo necesitará en el siguiente paso. ## Genera un CVV **Example** En este ejemplo, generaremos un [CVV](terminology.md#terms.cvv) para un PAN determinado con entradas de 121`PAN`, un código de servicio (tal como se define en ISO/IEC 7813) y una fecha de caducidad de la tarjeta. Para ver todos los parámetros disponibles, consulta el apartado [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) de la guía de referencia de la API. ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=121}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr", "KeyCheckValue": "DE89F9", "ValidationData": "801" } ``` ## Valide el CVV **Example** En este ejemplo, verificaremos el [CVV](terminology.md#terms.cvv) de un PAN determinado introduciendo un CVK, un código de servicio 121`PAN`, la fecha de caducidad de la tarjeta y el CVV proporcionado durante la transacción para la validación. Para ver todos los parámetros disponibles, consulte el apartado [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) de la guía de referencia de la API. El CVV no es un valor introducido por el usuario (por ejemplo CVV2), sino que suele estar incrustado en una banda magnética. Se debe tener en cuenta si siempre debe validarse cuando se proporciona. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=121} --validation-data 801 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr", "KeyCheckValue": "DE89F9", "ValidationData": "801" } ``` # Genera o verifica una CVV2 para una tarjeta específica [CVV2](terminology.md#terms.cvv2)es un valor que tradicionalmente se indica en el reverso de una tarjeta y se utiliza para compras en línea. En el caso de las tarjetas virtuales, también puede mostrarse en una aplicación o en una pantalla. Criptográficamente, es igual CVV1 pero con un valor de código de servicio diferente. ## Crea la clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVV2"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "AEA5CD", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/7f7g4spf3xcklhzu*. Lo necesitará en el siguiente paso. ## Genera un CVV2 **Example** En este ejemplo, generaremos un [CVV2](terminology.md#terms.cvv2)para un PAN determinado con entradas `PAN` y la fecha de caducidad de la tarjeta. Para ver todos los parámetros disponibles, consulta el [CardVerificationValueapartado 2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) de la guía de referencia de la API. ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu --primary-account-number=171234567890123 --generation-attributes CardVerificationValue2='{CardExpiryDate=1127}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu", "KeyCheckValue": "AEA5CD", "ValidationData": "321" } ``` ## Valide un CVV2 **Example** En este ejemplo, verificaremos a [CVV2](terminology.md#terms.cvv2)para un PAN determinado introduciendo un CVK, la fecha de caducidad de la tarjeta `PAN` y el CVV proporcionados durante la transacción para la validación. Para ver todos los parámetros disponibles, consulte el apartado [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) de la guía de referencia de la API. CVV2 y las demás entradas son valores introducidos por el usuario. Por lo tanto, no es necesariamente una señal de un problema que esto no se valide periódicamente. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu --primary-account-number=171234567890123 --verification-attributes CardVerificationValue2='{CardExpiryDate=1127} --validation-data 321 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu", "KeyCheckValue": "AEA5CD", "ValidationData": "801" } ``` # Genera o verifica un iCVV para una tarjeta específica [iCVV](terminology.md#terms.icvv) usa el mismo algoritmo que CVV/ CVV2 pero iCVV está integrado en una tarjeta con chip. Su código de servicio es 999. ## Crea la clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"ICVV"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "1201FB", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/c7dsi763r6s7lfp3*. Lo necesitará en el siguiente paso. ## Genera un iCVV **Example** En este ejemplo, generaremos un [iCVV](terminology.md#terms.icvv) para un PAN determinado con entradas de`PAN`, un código de servicio (tal como se define en ISO/IEC 7813) de 999 y una fecha de caducidad de la tarjeta. Para ver todos los parámetros disponibles, consulta el apartado [CardVerificationValue1 de la guía](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) de referencia de la API. ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3 --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3", "KeyCheckValue": "1201FB", "ValidationData": "532" } ``` ## Valide iCVV **Example** Para la validación, las entradas son el CVK, un código de servicio 999`PAN`, la fecha de caducidad de la tarjeta y el iCVV proporcionado durante la transacción para la validación. Para ver todos los parámetros disponibles, consulte el apartado [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) de la guía de referencia de la API. El iCVV no es un valor introducido por el usuario (por ejemplo CVV2), sino que suele estar incrustado en una EMV/chip tarjeta. Se debe tener en cuenta si siempre se debe validar cuando se proporciona. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3 --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999} --validation-data 532 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3", "KeyCheckValue": "1201FB", "ValidationData": "532" } ``` # Verifique un ARQC de EMV y genere un ARPC [El ARQC](terminology.md#terms.arqc) (criptograma de solicitud de autorización) es un criptograma generado por una tarjeta EMV (chip) y utilizado para validar los detalles de la transacción, así como el uso de una tarjeta autorizada. Incorpora datos de la tarjeta, el terminal y la propia transacción. En el momento de la validación en el backend, se proporcionan las mismas entradas a AWS Payment Cryptography, el criptograma se recrea internamente y se compara con el valor proporcionado con la transacción. En este sentido, es similar a un MAC. [El libro 2 de EMV 4.4](https://www.emvco.com/specifications/?post_id=80377) define tres aspectos de esta función: los métodos de derivación de claves (conocidos como clave de sesión común (CSK) para generar claves de transacción únicas, una carga útil mínima y los métodos para generar una respuesta (ARPC). Los esquemas de tarjetas individuales pueden especificar campos transaccionales adicionales para incorporarlos o el orden en que aparecen esos campos. También existen otros esquemas de derivación específicos de esquemas (generalmente obsoletos) que se tratan en otra parte de esta documentación. Para obtener más información, consulte la guía [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)de la API. ## Crea la clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN18"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyAttributes": { "KeyUsage": "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": false, "Sign": false, "Verify": false, "DeriveKey": true, "NoRestrictions": false } }, "KeyCheckValue": "08D7B4", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Lo necesitará en el siguiente paso. ## Genera un ARQC El ARQC se genera exclusivamente mediante una tarjeta EMV. Por lo tanto, la criptografía AWS de pagos no tiene ninguna posibilidad de generar dicha carga útil. Con fines de prueba, hay varias bibliotecas disponibles en línea que pueden generar una carga útil adecuada, así como valores conocidos que generalmente proporcionan los distintos esquemas. ## Valide un ARQC **Example** Si la criptografía de AWS pagos puede validar el ARQC, se devuelve un http/200. Opcionalmente, se puede proporcionar un ARPC (respuesta) e incluirlo en la respuesta una vez validado el ARQC. ``` $ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram 61EDCC708B4C97B4 --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --major-key-derivation-mode EMV_OPTION_A --transaction-data 00000000170000000000000008400080008000084016051700000000093800000B1F2201030000000000000000000000000000000000000000000000000000008000000000000000 --session-key-derivation-attributes='{"EmvCommon":{"ApplicationTransactionCounter":"000B", "PanSequenceNumber":"01","PrimaryAccountNumber":"9137631040001422"}}' --auth-response-attributes='{"ArpcMethod2":{"CardStatusUpdate":"12345678"}}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4", "AuthResponseValue":"2263AC85" } ``` # Genere y verifique un MAC EMV EMV MAC es un MAC que utiliza la entrada de una clave derivada de EMV y, a continuación, realiza un MAC ISO9797 -3 (minorista) sobre los datos resultantes. El EMV MAC se utiliza normalmente para enviar comandos a una tarjeta EMV, por ejemplo, para desbloquear scripts. **nota** AWS La criptografía de pagos no valida el contenido del script. Consulte el manual de su esquema o tarjeta para obtener detalles sobre los comandos específicos que debe incluir. Para obtener más información, consulta [MacAlgorithmEmv](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_MacAlgorithmEmv.html)la guía de la API. **Topics** + [Crea la clave](#use-cases-issuers.generalfunctions.emvmac.setup) + [Genere un EMV MAC](#use-cases-issuers.generalfunctions.emvmac.generate) ## Crea la clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E2_EMV_MKEY_INTEGRITY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN18"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyAttributes": { "KeyUsage": "TR31_E2_EMV_MKEY_INTEGRITY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": false, "Sign": false, "Verify": false, "DeriveKey": true, "NoRestrictions": false } }, "KeyCheckValue": "08D7B4", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Lo necesitará en el siguiente paso. ## Genere un EMV MAC Lo habitual es que un proceso interno genere un script EMV (por ejemplo, para desbloquear una tarjeta), lo firme con este comando (que obtiene una clave de un solo uso específica para una tarjeta en particular) y, a continuación, devuelva el MAC. A continuación, se envía el comando \$1 MAC a la tarjeta que se va a aplicar. Enviar el comando a la tarjeta está fuera del ámbito de la criptografía de AWS pagos. **nota** Este comando está diseñado para comandos en los que no se envían datos cifrados (como el PIN). EMV Encrypt se puede combinar con este comando para añadir datos cifrados al script del emisor antes de ejecutar este comando Datos del mensaje Los datos del mensaje incluyen el encabezado y el comando de la APDU. Si bien esto puede variar según la implementación, en este ejemplo se utiliza el encabezado APDU para desbloquear (84 24 00 00 08), seguido del ATC (0007) y, por último, del ARQC de la transacción anterior (999E57 F47CACE). FD0 El servicio no valida el contenido de este campo. Modo de derivación de claves de sesión Este campo define cómo se genera la clave de sesión. Por lo general, EMV\$1COMMON\$1SESSION\$1KEY se usa para las nuevas implementaciones, mientras que EMV2000 \$1 AMEX \$1 MASTERCARD\$1SESSION\$1KEY \$1 VISA también se puede usar. MajorKeyDerivationMode EMV define el modo A, B o C. El modo A es el más común y la criptografía de pagos actualmente admite el modo A o el modo B. AWS PAN El número de cuenta, normalmente disponible en el campo de chip 5A o en ISO8583 el campo 2, pero también se puede recuperar del sistema de tarjetas. PSN El número de secuencia de la tarjeta. Si no se utiliza, introduzca 00. SessionKeyDerivationValue Estos son los datos de derivación por sesión. Puede ser el último ARQC (ApplicationCryptogram) del campo 9F26 o el último ATC del 9F36, según el esquema de derivación. Rellenado El relleno se aplica automáticamente y utiliza el método 2 de relleno 9797-1. ISO/IEC **Example** ``` $ aws payment-cryptography-data generate-mac --message-data 84240000080007999E57FD0F47CACE --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --message-data 8424000008999E57FD0F47CACE0007 --generation-attributes EmvMac="{MajorKeyDerivationMode=EMV_OPTION_A,PanSequenceNumber='00',PrimaryAccountNumber='2235521304123282',SessionKeyDerivationMode=EMV_COMMON_SESSION_KEY,SessionKeyDerivationValue={ApplicationCryptogram='999E57FD0F47CACE'}}" ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4", "Mac":"5652EEDF83EA0D84" } ``` # Genera un EMV MAC para el cambio de PIN El cambio de PIN EMV combina dos operaciones: generar un MAC para un script del emisor y cifrar un nuevo PIN para cambiarlo sin conexión a Internet en una tarjeta con chip EMV. Este comando solo es necesario en algunos países en los que el PIN está almacenado en la tarjeta con chip (esto es habitual en los países europeos). Suele utilizarse cuando el titular de la tarjeta necesita cambiar su PIN y el nuevo PIN debe transmitirse de forma segura a la tarjeta junto con un MAC para comprobar la autenticidad del comando. **nota** Si solo necesitas enviar comandos a la tarjeta pero no cambiar el PIN, considera usar los comandos [ARPC CSU](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyAuthRequestCryptogram.html) o [Generate EMV](use-cases-issuers.generalfunctions.emvmac.md) MAC en su lugar. Para obtener más información, consulte la guía de [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange.html)la API. ## Genera un EMV (MAC) y un PIN cifrado para cambiarlo. Esta operación requiere dos claves: una clave de integridad EMV (: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) para la generación del MAC y una clave de confidencialidad EMV (KeyUsage: \$1E4\$1EMV\$1MKEY\$1CONFIDENCIALITY) para el cifrado del PIN. KeyUsage TR31 Lo habitual es que un proceso interno genere un script de cambio de PIN EMV, que incluye tanto el MAC del script del emisor como el PIN nuevo cifrado. A continuación, el comando y el PIN cifrado se envían a la tarjeta para actualizar el PIN sin conexión. Enviar el comando a la tarjeta está fuera del ámbito de la criptografía de AWS pagos. Datos del mensaje Los datos del mensaje incluyen el comando APDU para el script del emisor. El servicio no valida el contenido de este campo. Nuevo bloque de PIN cifrado El nuevo bloque de PIN cifrado que se enviará a la tarjeta. Debe proporcionarse como un valor cifrado mediante una clave de cifrado PIN. Nuevo identificador PIN PEK La clave utilizada para cifrar el nuevo PIN antes de pasarlo a esta API. Clave de integridad de mensajería segura La clave de integridad EMV (KeyUsage: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) utilizada para la generación de MAC. Clave de confidencialidad de mensajería segura La clave de confidencialidad EMV (KeyUsage: TR31 \$1E4\$1EMV\$1MKEY\$1CONFIDENCIALITY) utilizada para el cifrado con PIN. MajorKeyDerivationMode EMV define el modo A, B o C. El modo A es el más común y la criptografía de pagos actualmente admite el modo A o el modo B. AWS Mode El modo de cifrado, normalmente CBC para las operaciones de cambio de PIN. PAN El número de cuenta, normalmente disponible en el campo 5A o ISO8583 2 con chip, pero también se puede recuperar del sistema de tarjetas. PanSequenceNumber El número de secuencia de la tarjeta. Si no se utiliza, introduzca 00. ApplicationCryptogram Estos son los datos de derivación por sesión, normalmente el último ARQC del campo 9F26. PinBlockLengthPosition Especifica dónde está codificada la longitud del bloque de PIN. Normalmente se establece en NINGUNO. Comprueba las especificaciones de tu esquema de tarjetas si no estás seguro. PinBlockPaddingType Especifica el tipo de relleno del bloque de PIN. Normalmente se establece en NO\$1PADDING. Comprueba las especificaciones del esquema de tu tarjeta si no estás seguro. **Example** ``` $ aws payment-cryptography-data generate-mac-emv-pin-change \ --message-data 00A4040008A000000004101080D80500000001010A04000000000000 \ --new-encrypted-pin-block 67FB27C75580EFE7 \ --new-pin-pek-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt \ --pin-block-format ISO_FORMAT_0 \ --secure-messaging-confidentiality-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi \ --secure-messaging-integrity-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \ --derivation-method-attributes 'EmvCommon={ApplicationCryptogram=1234567890123457,MajorKeyDerivationMode=EMV_OPTION_A,Mode=CBC,PanSequenceNumber=00,PinBlockLengthPosition=NONE,PinBlockPaddingType=NO_PADDING,PrimaryAccountNumber=171234567890123}' ``` ``` { "SecureMessagingIntegrityKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "SecureMessagingIntegrityKeyCheckValue": "08D7B4", "SecureMessagingConfidentialityKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi", "SecureMessagingConfidentialityKeyCheckValue": "C1EB8F", "Mac": "5652EEDF83EA0D84", "EncryptedPinBlock": "F1A2B3C4D5E6F7A8" } ``` # Funciones específicas de la red **Topics** + [Funciones específicas de visa](use-cases-issuers.networkfunctions.visa.md) + [Funciones específicas de Mastercard](use-cases-issuers.networkfunctions.mastercard.md) + [Funciones específicas de American Express](use-cases-issuers.networkfunctions.amex.md) + [Funciones específicas de JCB](use-cases-issuers.networkfunctions.jcb.md) # Funciones específicas de visa **Topics** + [ARQC -/ CVN18CVN22](#use-cases-issuers.networkfunctions.visa.cvn18) + [ARQC - CVN10](#use-cases-issuers.networkfunctions.visa.cvn10) + [3D CAVV V7](#use-cases-issuers.networkfunctions.visa.cavv-v7) + [dCVV (valor de verificación dinámica de la tarjeta) - CVN17](#use-cases-issuers.networkfunctions.visa.dcvv) ## ARQC -/ CVN18CVN22 CVN18 y CVN22 utilice el [método CSK de derivación de claves](use-cases-issuers.generalfunctions.arqc.md). Los datos exactos de las transacciones varían entre estos dos métodos. Consulte la documentación del esquema para obtener más información sobre cómo crear el campo de datos de transacciones. ## ARQC - CVN10 CVN10 es un método más antiguo de Visa para las transacciones EMV que utiliza la obtención de la clave por tarjeta en lugar de la derivación de la sesión (por transacción) y también utiliza una carga útil diferente. Para obtener información sobre el contenido de la carga útil, ponte en contacto con el programa para obtener más información. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN10"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyAttributes": { "KeyUsage": "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": false, "Sign": false, "Verify": false, "DeriveKey": true, "NoRestrictions": false } }, "KeyCheckValue": "08D7B4", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Lo necesitará en el siguiente paso. ### Valide el ARQC **Example** En este ejemplo, validaremos un ARQC generado con Visa. CVN10 Si la criptografía de AWS pagos puede validar el ARQC, se devuelve un http/200. Si el arqc no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram D791093C8A921769 \ --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \ --major-key-derivation-mode EMV_OPTION_A \ --transaction-data 00000000170000000000000008400080008000084016051700000000093800000B03011203000000 \ --session-key-derivation-attributes='{"Visa":{"PanSequenceNumber":"01" \ ,"PrimaryAccountNumber":"9137631040001422"}}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4" } ``` ## 3D CAVV V7 En el caso de las transacciones con Visa Secure (3DS), el servidor de control de acceso (ACS) del emisor genera un CAVV (valor de verificación de autenticación del titular de la tarjeta). El CAVV es una prueba de que se ha realizado la autenticación del titular de la tarjeta, es único para cada transacción de autenticación y lo proporciona el adquirente en el mensaje de autorización. La versión 7 del CAVV vincula a la aprobación los datos adicionales sobre la transacción, incluidos elementos como el nombre del vendedor, el importe de la compra y la fecha de compra. De esta forma, se trata, en efecto, de un hash criptográfico de la carga útil de la transacción. Criptográficamente, el CAVV V7 utiliza el algoritmo CVV, pero todas las entradas han sido changed/repurposed. Please consult appropriate third party/Visa documentación sobre cómo producir las entradas para generar una carga útil del CAVV V7. ### Crea la clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CAVV-V7"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "F3FB13", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/dnaeyrjgdjjtw6dk*. Lo necesitará en el siguiente paso. ### Genera un CAVV V7 **Example** En este ejemplo, generaremos un CAVV V7 para una transacción determinada con las entradas especificadas en las especificaciones. Tenga en cuenta que, en el caso de este algoritmo, los campos se pueden reutilizar o reutilizar, por lo que no se debe suponer que las etiquetas de los campos coinciden con las entradas. Para ver todos los parámetros disponibles, consulte el apartado [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) de la guía de referencia de la API. ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=9431,ServiceCode=431}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk", "KeyCheckValue": "F3FB13", "ValidationData": "491" } ``` ### Valide el CAVV V7 **Example** Para la validación, las entradas son el CVK, los valores de entrada calculados y el CAVV proporcionados durante la transacción para la validación. Para ver todos los parámetros disponibles, consulte el apartado [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) de la guía de referencia de la API. El CAVV no es un valor introducido por el usuario (por ejemplo CVV2), sino que lo calcula el emisor ACS. Se debe tener en cuenta si siempre debe validarse cuando se proporciona. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=9431,ServiceCode=431} --validation-data 491 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk", "KeyCheckValue": "F3FB13", "ValidationData": "491" } ``` ## dCVV (valor de verificación dinámica de la tarjeta) - CVN17 El dCVV (valor dinámico de verificación de la tarjeta) es un criptograma dinámico específico para visados que se utiliza para las transacciones EMV sin contacto. Se lo conoce como EMV primitivo y proporciona una mayor seguridad al generar un valor de verificación único para cada transacción. El dCVV utiliza entradas como el número de cuenta principal (PAN), el número de secuencia PAN (PSN), el contador de transacciones de aplicaciones (ATC), el número impredecible y los datos de seguimiento. Todavía se usa en algunos lugares, pero ha sido reemplazado en su mayoría por otros algoritmos similares. CVN18 Para ver todos los parámetros disponibles, consulta [DynamicCardVerificationValue](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DynamicCardVerificationValue.html)la guía de referencia de la API. ### Crea una clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"DCVV"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc", "KeyAttributes": { "KeyUsage": "TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "A8E4D2", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2025-02-02T11:45:30.648000-08:00", "UsageStartTimestamp": "2025-02-02T11:45:30.626000-08:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/mw7dn3qxvkfh8ztc*. Lo necesitará en el siguiente paso. ### Genera un dCVv **Example** En este ejemplo, generaremos un dCVV para una transacción EMV sin contacto. Las entradas incluyen el PAN, el número de secuencia PAN, el contador de transacciones de la aplicación, el número impredecible y los datos de seguimiento. ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc \ --primary-account-number=5111112627662122 \ --generation-attributes DynamicCardVerificationValue='{ApplicationTransactionCounter=01,PanSequenceNumber=00,TrackData=12345,UnpredictableNumber=123}' \ --validation-data-length 5 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc", "KeyCheckValue": "A8E4D2", "ValidationData": "36667" } ``` ### Valide el dCVV **Example** En este ejemplo, validaremos un dCVV proporcionado durante una transacción. Para la validación, se deben proporcionar las mismas entradas utilizadas para la generación. Si la criptografía de AWS pagos puede validarse, se devuelve un http/200. Si el valor no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc \ --primary-account-number=5111112627662122 \ --validation-data=36667 \ --verification-attributes DynamicCardVerificationValue='{ApplicationTransactionCounter=01,PanSequenceNumber=00,TrackData=12345,UnpredictableNumber=123}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc", "KeyCheckValue": "A8E4D2" } ``` # Funciones específicas de Mastercard **Topics** + [DCVC3](#use-cases-issuers.networkfunctions.mastercard.dcvc) + [ARQC -/ CVN14CVN15](#use-cases-issuers.networkfunctions.mastercard.cvn14) + [ARQC -/ CVN12CVN13](#use-cases-issuers.networkfunctions.mastercard.cvn12) + [SPA2 3DS AAV](#use-cases-issuers.networkfunctions.mastercard.spa2aav) ## DCVC3 DCVC3 es anterior a los CVN12 esquemas EMV, CSK y Mastercard y representa otro enfoque para utilizar claves dinámicas. A veces también se reutiliza para otros casos de uso. En este esquema, las entradas son datos PAN, PSN, Track1/Track2, un contador impredecible de números y transacciones (ATC). ### Crea una clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"DCVC3"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/hrh6qgbi3sk4y3wq", "KeyAttributes": { "KeyUsage": "TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": false, "Sign": false, "Verify": false, "DeriveKey": true, "NoRestrictions": false } }, "KeyCheckValue": "08D7B4", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/hrh6qgbi3sk4y3wq*. Lo necesitará en el siguiente paso. ### Genera un DCVC3 **Example** Aunque normalmente DCVC3 se genera mediante una tarjeta con chip, también se puede generar manualmente, como en este ejemplo ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --primary-account-number=5413123456784808 --generation-attributes DynamicCardVerificationCode='{ApplicationTransactionCounter=0000,TrackData=5241060000000069D13052020000000000003F,PanSequenceNumber=00,UnpredictableNumber=00000000}'' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4", "ValidationData": "865" } ``` ### Valide el DCVC3 **Example** En este ejemplo, validaremos un DCVC3. Tenga en cuenta que el ATC debe proporcionarse como un número hexadecimal, por ejemplo, un contador de 11 debe representarse como 000B. El servicio espera un valor de 3 dígitos DCVC3, por lo que si ha almacenado un valor de 4 (o 5) dígitos, simplemente trunque los caracteres de la izquierda hasta que tenga 3 dígitos (por ejemplo, 15321 debería dar como resultado un valor de 321 para los datos de validación). Si la criptografía AWS de pagos puede validarse, se devolverá un http/200. Si el valor no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --primary-account-number=5413123456784808 --verification-attributes DynamicCardVerificationCode='{ApplicationTransactionCounter=000B,TrackData=5241060000000069D13052020000000000003F,PanSequenceNumber=00,UnpredictableNumber=00000001}' --validation-data 398 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4" } ``` ## ARQC -/ CVN14CVN15 CVN14 y CVN15 utilice el [método EMV CSK](use-cases-issuers.generalfunctions.arqc.md) de derivación de claves. Los datos exactos de las transacciones varían entre estos dos métodos; consulte la documentación del esquema para obtener más información sobre cómo crear el campo de datos de transacciones. ## ARQC -/ CVN12CVN13 CVN12 y CVN13 son un método antiguo específico de MasterCard para transacciones EMV que incorpora un número impredecible en la derivación por transacción y también utiliza una carga útil diferente. Para obtener información sobre el contenido de la carga útil, póngase en contacto con el programa. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN12"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyAttributes": { "KeyUsage": "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": false, "Sign": false, "Verify": false, "DeriveKey": true, "NoRestrictions": false } }, "KeyCheckValue": "08D7B4", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Lo necesitará en el siguiente paso. ### Valide el ARQC **Example** En este ejemplo, validaremos un ARQC generado con Mastercard. CVN12 Si la criptografía de AWS pagos puede validar el ARQC, se devuelve un http/200. Si el arqc no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram 31BE5D49F14A5F01 \ --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \ --major-key-derivation-mode EMV_OPTION_A \ --transaction-data 00000000170000000000000008400080008000084016051700000000093800000B1F2201030000000000000000000000000000000000000000000000000000008000000000000000 \ --session-key-derivation-attributes='{"MastercardSessionKey":{"ApplicationTransactionCounter":"000B","PanSequenceNumber":"01","PrimaryAccountNumber":"5413123456784808","UnpredictableNumber":"00000001"}}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4" } ``` ## SPA2 3DS AAV SPA2 El AAV (valor de autenticación de la cuenta) se utiliza para las transacciones con Mastercard 3DS (también conocidas como Mastercard Idenity Check). Proporciona autenticación criptográfica para las transacciones de comercio electrónico mediante la generación de MAC basada en HMAC. El AAV se genera utilizando datos específicos de la transacción y una clave secreta compartida. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=HMAC_SHA256,KeyUsage=TR31_M7_HMAC_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"SPA2_AAV"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn", "KeyAttributes": { "KeyUsage": "TR31_M7_HMAC_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "HMAC_SHA256", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "C661F9", "KeyCheckValueAlgorithm": "HMAC", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-west- 2:111122223333:key/q5vjtshsg67cz5gn*. Lo necesitará en el siguiente paso. ### Genera AAV SPA2 **Example** En este ejemplo, generaremos el componente del valor de autenticación del emisor (IAV) del AAV mediante la generación de SPA2 HMAC MAC. Los datos del mensaje contienen la información específica de la transacción que se autenticará. El formato de los datos del mensaje debe seguir las SPA2 especificaciones de Mastercard y no se describe en este ejemplo. Revise las especificaciones de formato de su tarjeta Mastercard para insertar el IAV en el valor del AAV. ``` $ aws payment-cryptography-data generate-mac --key-identifier arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn --message-data "2226400099919520FFFFd8b448be65694fe7b42f836bad396e9d" --generation-attributes Algorithm=HMAC --region us-west-2 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn", "KeyCheckValue": "C661F9", "Mac": "6FB2405E9D8A4C1F7B173F73ADD1A6DC358531CAB0E9994FC5B62012ADDE91FC" } ``` ### Verifica el AAV SPA2 **Example** En este ejemplo, verificaremos un SPA2 AAV. Para la verificación, se proporcionan los mismos datos del mensaje y el mismo valor MAC. Si la criptografía de AWS pago puede validar el MAC, se devuelve un http/200. Si el MAC no está validado, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-mac --key-identifier arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn --message-data "2226400099919520FFFFd8b448be65694fe7b42f836bad396e9d" --mac "6FB2405E9D8A4C1F7B173F73ADD1A6DC358531CAB0E9994FC5B62012ADDE91FC" --verification-attributes Algorithm=HMAC --region us-west-2 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn", "KeyCheckValue": "C661F9" } ``` # Funciones específicas de American Express **Topics** + [CSC1](#use-cases-issuers.networkfunctions.amex.csc) + [CSC2](#use-cases-issuers.networkfunctions.amex.csc2) + [iCSC](#use-cases-issuers.networkfunctions.amex.csc3) + [3D AEVV](#use-cases-issuers.networkfunctions.amex.3dsaevv) ## CSC1 La versión 1 de CSC también se conoce como algoritmo CSC clásico. El servicio puede proporcionarlo como un número de 3,4 o 5 dígitos. Para ver todos los parámetros disponibles, consulte el [AmexCardSecurityCodeVersionpunto 1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion1.html) en la guía de referencia de la API. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CSC1"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "8B5077", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/esh6hn7pxdtttzgq*. Lo necesitará en el siguiente paso. ### Genera un CSC1 **Example** ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion1='{CardExpiryDate=1224}' --validation-data-length 4 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq", "KeyCheckValue": "8B5077", "ValidationData": "3938" } ``` ### Valide el CSC1 **Example** En este ejemplo, validaremos un CSC1. Si la criptografía de AWS pago puede validarse, se devuelve un http/200. Si el valor no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion1='{CardExpiryDate=1224}'' --validation-data 3938 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq", "KeyCheckValue": "8B5077" } ``` ## CSC2 La versión 2 del CSC también se conoce como algoritmo CSC mejorado. El servicio puede proporcionarlo como un número de 3,4 o 5 dígitos. El código de servicio CSC2 suele ser 000. Para ver todos los parámetros disponibles, consulte el [AmexCardSecurityCodeVersionapartado 2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) en la guía de referencia de la API. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CSC2"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": true, "Sign": false, "Verify": true, "DeriveKey": false, "NoRestrictions": false } }, "KeyCheckValue": "BF1077", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2023-06-05T06:41:46.648000-07:00", "UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/erlm445qvunmvoda*. Lo necesitará en el siguiente paso. ### Genera un CSC2 En este ejemplo, generaremos a CSC2 con una longitud de 4. El CSC se puede generar con una longitud de 3,4 o 5. Para American Express, PANs debe tener 15 dígitos y empezar por 34 o 37. La fecha de caducidad suele tener el formato YYMM. El código de servicio puede variar; consulte el manual, pero los valores típicos son 000, 201 o 702 **Example** ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=2412,ServiceCode=000}' --validation-data-length 4 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda", "KeyCheckValue": "BF1077", "ValidationData": "3982" } ``` ### Valide el CSC2 **Example** En este ejemplo, validaremos un CSC2. Si la criptografía de AWS pago puede validarse, se devuelve un http/200. Si el valor no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=2412,ServiceCode=000}' --validation-data 3982 ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda", "KeyCheckValue": "BF1077" } ``` ## iCSC El iCSC también se conoce como algoritmo CSC estático y se calcula con la versión 2 del CSC. El servicio puede proporcionarlo como un número de 3,4 o 5 dígitos. Use el código de servicio 999 para calcular el iCSC de una tarjeta de contacto. Utilice el código de servicio 702 para calcular el iCSC de una tarjeta sin contacto. Para ver todos los parámetros disponibles, consulte el apartado [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) de la guía de referencia de la API. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CSC1"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY" "KeyAlgorithm": "TDES_2KEY", "KeyClass": "SYMMETRIC_KEY", "KeyModesOfUse": { "Decrypt": false, "DeriveKey": false, "Encrypt": false, "Generate": true, "NoRestrictions": false, "Sign": false, "Unwrap": false, "Verify": true, "Wrap": false }, }, "KeyCheckValue": "7121C7", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "KeyState": "CREATE_COMPLETE", "CreateTimestamp": "2025-01-29T09:19:21.209000-05:00", "UsageStartTimestamp": "2025-01-29T09:19:21.192000-05:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 1:111122223333:key/7vrybrbvjcvwtunv*. Lo necesitará en el siguiente paso. ### Genera un iCSC En este ejemplo, generaremos un iCSC con una longitud de 4 para una tarjeta sin contacto utilizando el código de servicio 702. El CSC se puede generar con una longitud de 3,4 o 5. Para American Express, PANs debe tener 15 dígitos y empezar por 34 o 37. **Example** ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1224,ServiceCode=702}' --validation-data-length 4 ``` ``` { "KeyArn": arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv, "KeyCheckValue": 7121C7, "ValidationData": "2365" } ``` ### Valide el iCSC **Example** En este ejemplo, validaremos un iCSC. Si la criptografía de AWS pago puede validarse, se devuelve un http/200. Si el valor no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1224,ServiceCode=702}' --validation-data 2365 ``` ``` { "KeyArn": arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv, "KeyCheckValue": 7121C7 } ``` ## 3D AEVV El AEVV (valor de verificación de la cuenta 3-D Secure) de 3DS se utiliza para la autenticación 3-D Secure de American Express. Utiliza el mismo algoritmo CSC2 pero con parámetros de entrada diferentes. El campo de fecha de caducidad debe rellenarse con un número impredecible (aleatorio) y el código de servicio consta del código de resultados de la autenticación AEVV (1 dígito) más el código de autenticación de segundo factor (2 dígitos). La longitud de salida debe ser de 3 dígitos. Para ver todos los parámetros disponibles, consulte el [AmexCardSecurityCodeVersionapartado 2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) de la guía de referencia de la API. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"3DS_AEVV"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm", "KeyAttributes": { "KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY" "KeyAlgorithm": "TDES_2KEY", "KeyClass": "SYMMETRIC_KEY", "KeyModesOfUse": { "Decrypt": false, "DeriveKey": false, "Encrypt": false, "Generate": true, "NoRestrictions": false, "Sign": false, "Unwrap": false, "Verify": true, "Wrap": false }, }, "KeyCheckValue": "8F3A21", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "KeyState": "CREATE_COMPLETE", "CreateTimestamp": "2025-02-02T10:30:15.209000-05:00", "UsageStartTimestamp": "2025-02-02T10:30:15.192000-05:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/kw8djn5qxvfh3ztm*. Lo necesitará en el siguiente paso. ### Genera un AEVV para 3DS En este ejemplo, generaremos un AEVV de 3DS con una longitud de 3. El campo de fecha de caducidad contiene un número impredecible (aleatorio) (por ejemplo, 1234) y el código de servicio consta del código de resultados de autenticación AEVV (1 dígito) más el código de autenticación de segundo factor (2 dígitos), por ejemplo, 543, donde 5 es el código de resultados de autenticación y 43 es el código de autenticación de segundo factor. En el caso de American Express, PANs debe tener 15 dígitos y empezar por 34 o 37. **Example** ``` $ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1234,ServiceCode=543}' --validation-data-length 3 ``` ``` { "KeyArn": arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm, "KeyCheckValue": 8F3A21, "ValidationData": "921" } ``` ### Valide el AEVV de la 3DS **Example** En este ejemplo, validaremos un AEVV de la 3DS. Si la criptografía de AWS pago puede validarse, se devuelve un http/200. Si el valor no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1234,ServiceCode=543}' --validation-data 921 ``` ``` { "KeyArn": arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm, "KeyCheckValue": 8F3A21 } ``` # Funciones específicas de JCB **Topics** + [ARQC - CVN04](#use-cases-issuers.networkfunctions.jcb.cvn04) + [ARQC - CVN01](#use-cases-issuers.networkfunctions.jcb.cvn01) ## ARQC - CVN04 JCB CVN04 utiliza el método [CSK](use-cases-issuers.generalfunctions.arqc.md) de derivación de claves. Consulte la documentación del esquema para obtener detalles sobre cómo crear el campo de datos de transacciones. ## ARQC - CVN01 CVN01 es un método más antiguo de JCB para transacciones EMV que utiliza la derivación por clave de tarjeta en lugar de la derivación por sesión (por transacción) y también utiliza una carga útil diferente. Visa también usa este mensaje, por lo que el nombre del elemento lleva ese nombre, aunque también se usa para JCB. Para obtener información sobre el contenido de la carga útil, póngase en contacto con la documentación del programa. ### Crear clave ``` $ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN10"},{"Key":"CARD_BIN","Value":"12345678"}]' ``` La respuesta refleja los parámetros de la solicitud, incluyendo un ARN para las llamadas posteriores y un valor de verificación clave (KCV). ``` { "Key": { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyAttributes": { "KeyUsage": "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS", "KeyClass": "SYMMETRIC_KEY", "KeyAlgorithm": "TDES_2KEY", "KeyModesOfUse": { "Encrypt": false, "Decrypt": false, "Wrap": false, "Unwrap": false, "Generate": false, "Sign": false, "Verify": false, "DeriveKey": true, "NoRestrictions": false } }, "KeyCheckValue": "08D7B4", "KeyCheckValueAlgorithm": "ANSI_X9_24", "Enabled": true, "Exportable": true, "KeyState": "CREATE_COMPLETE", "KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY", "CreateTimestamp": "2024-03-07T06:41:46.648000-07:00", "UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00" } } ``` Tome nota de lo `KeyArn` que representa la clave, por ejemplo *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Lo necesitará en el siguiente paso. ### Valide el ARQC **Example** En este ejemplo, validaremos un ARQC generado con JCB. CVN01 Utiliza las mismas opciones que el método Visa, de ahí el nombre del parámetro. Si la criptografía de AWS pagos es capaz de validar el ARQC, se devuelve un http/200. Si el arqc no se valida, devolverá una respuesta http/400. ``` $ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram D791093C8A921769 \ --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \ --major-key-derivation-mode EMV_OPTION_A \ --transaction-data 00000000170000000000000008400080008000084016051700000000093800000B03011203000000 \ --session-key-derivation-attributes='{"Visa":{"PanSequenceNumber":"01" \ ,"PrimaryAccountNumber":"9137631040001422"}}' ``` ``` { "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk", "KeyCheckValue": "08D7B4" } ```