As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Emissores e processadores de emissores
Os casos de uso do emissor geralmente consistem em algumas partes. Essa seção é organizada por função (como trabalhar com pinos). Em um sistema de produção, as chaves normalmente têm como escopo um determinado compartimento de cartão e são criadas durante a configuração do compartimento, em vez de embutidas, conforme mostrado aqui.
**Topics**
+ [Funções gerais](use-cases-issuers.generalfunctions.md)
+ [Funções específicas da rede](use-cases-issuers.networkfunctions.md)
# Funções gerais
**Topics**
+ [Gere um pino aleatório e o PVV associado e, em seguida, verifique o valor](use-cases-issuers.generalfunctions.pvv.md)
+ [Gere ou verifique um CVV para um determinado cartão](use-cases-issuers.generalfunctions.cvv.md)
+ [Gere ou verifique um CVV2 para um cartão específico](use-cases-issuers.generalfunctions.cvv2.md)
+ [Gere ou verifique um iCVV para um cartão específico](use-cases-issuers.generalfunctions.icvv.md)
+ [Verifique um EMV ARQC e gere um ARPC](use-cases-issuers.generalfunctions.arqc.md)
+ [Gere e verifique um MAC EMV](use-cases-issuers.generalfunctions.emvmac.md)
+ [Gere EMV MAC para alteração de PIN](use-cases-issuers.generalfunctions.emvpinchange.md)
# Gere um pino aleatório e o PVV associado e, em seguida, verifique o valor
**Topics**
+ [Crie a (s) chave (s)](#use-cases-issuers.generalfunctions.pvv.setup)
+ [Gere um pino aleatório, gere PVV e retorne o PIN e o PVV criptografados](#use-cases-issuers.generalfunctions.pvv.generate)
+ [Valide o PIN criptografado usando o método PVV](#use-cases-issuers.generalfunctions.pvv.verify)
## Crie a (s) chave (s)
Para gerar um pino aleatório e o [PVV](terminology.md#terms.pvv), você precisará de duas chaves, uma [chave de verificação de pinos (PVK) para gerar o PVV](terminology.md#terms.pvk) e uma [chave de criptografia de pinos](terminology.md#terms.pek) para criptografar o pino. O pino em si é gerado aleatoriamente de forma segura dentro do serviço e não está relacionado criptograficamente a nenhuma das chaves.
O PGK deve ser uma chave do algoritmo TDES\$12KEY com base no próprio algoritmo PVV. Um PEK pode ser TDES\$12KEY, TDES\$13KEY ou AES\$1128. Nesse caso, como o PEK é destinado ao uso interno em seu sistema, o AES\$1128 seria uma boa escolha. Se um PEK for usado para intercâmbio com outros sistemas (por exemplo, redes de cartões, adquirentes ATMs) ou estiver sendo movido como parte de uma migração, o TDES\$12KEY pode ser a escolha mais apropriada por motivos de compatibilidade.
### Crie o 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/ivi5ksfsuplneuyt. Isso será necessário na próxima etapa.
### Crie o 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/ov6icy4ryas4zcza. Isso será necessário na próxima etapa.
## Gere um pino aleatório, gere PVV e retorne o PIN e o PVV criptografados
**Example**
Neste exemplo, geraremos um novo pino (aleatório) de 4 dígitos em que as saídas serão criptografadas `PIN block` (. PinData PinBlock) e um `PVV` (pinData. VerificationValue). As entradas principais são `PAN` o `Pin Verification Key` (também conhecido como chave de geração de pinos) `Pin Encryption Key` e o formato [PIN Block](terminology.md#terms.pinblock).
Esse comando exige que a chave seja do 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 o PIN criptografado usando o método PVV
**Example**
Neste exemplo, validaremos um PIN para um PAN específico. O PIN normalmente é fornecido pelo titular do cartão ou pelo usuário durante o período da transação para validação e é comparado com o valor registrado (a entrada do titular do cartão é fornecida como um valor criptografado do terminal ou de outro provedor upstream). Para validar essa entrada, os seguintes valores também serão fornecidos em tempo de execução: o pino criptografado, a chave usada para criptografar o pino de entrada (geralmente chamado de [IWK](terminology.md#terms.iwk)) `PAN` e o valor a ser verificado (a ou). `PVV` `PIN offset`
Se a criptografia AWS de pagamento conseguir validar o PIN, um http/200 será retornado. Se o PIN não for validado, ela retornará um 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",
}
```
# Gere ou verifique um CVV para um determinado cartão
[CVV](terminology.md#terms.cvv) ou CVV1 é um valor tradicionalmente incorporado na tarja magnética de um cartão. Não é o mesmo que CVV2 (visível para o titular do cartão e para uso em compras on-line).
A primeira etapa é criar uma chave. Para este tutorial, você cria uma chave [CVK](terminology.md#terms.cvk) 3DES de comprimento duplo (2KEY TDES).
**nota**
CVV CVV2 e iCVV usam algoritmos semelhantes, se não idênticos, mas variam os dados de entrada. Todos usam o mesmo tipo de chave TR31 \$1C0\$1CARD\$1VERIFICATION\$1KEY, mas é recomendável usar chaves separadas para cada finalidade. Eles podem ser diferenciados usando and/or tags de aliases, como no exemplo abaixo.
## Crie a chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/r52o3wbqxyf6qlqr*. Isso será necessário na próxima etapa.
## Gere um CVV
**Example**
Neste exemplo, geraremos um [CVV](terminology.md#terms.cvv) para um determinado PAN com entradas de`PAN`, um código de serviço (conforme definido pelo ISO/IEC 7813) de 121 e a data de validade do cartão.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da 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"
}
```
## Validar CVV
**Example**
Neste exemplo, verificaremos um [CVV](terminology.md#terms.cvv) para um determinado PAN com entradas de um CVK, um código de serviço de 121`PAN`, a data de validade do cartão e o CVV fornecido durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
O CVV não é um valor inserido pelo usuário (como CVV2), mas normalmente está incorporado em uma tarja magnética. Deve-se considerar se ele deve sempre ser validado quando fornecido.
```
$ 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"
}
```
# Gere ou verifique um CVV2 para um cartão específico
[CVV2](terminology.md#terms.cvv2)é um valor tradicionalmente fornecido no verso de um cartão e usado para compras on-line. Para cartões virtuais, ele também pode ser exibido em um aplicativo ou tela. Criptograficamente, é o mesmo, CVV1 mas com um valor de código de serviço diferente.
## Crie a chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/7f7g4spf3xcklhzu*. Isso será necessário na próxima etapa.
## Gere um CVV2
**Example**
Neste exemplo, geraremos um [CVV2](terminology.md#terms.cvv2)para um determinado PAN com entradas `PAN` e data de validade do cartão.
Para todos os parâmetros disponíveis, consulte [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) no guia de referência da 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"
}
```
## Validar um CVV2
**Example**
Neste exemplo, verificaremos um [CVV2](terminology.md#terms.cvv2)determinado PAN com entradas de um CVK, a data de validade do cartão `PAN` e o CVV fornecido durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) no guia de referência da API.
CVV2 e as outras entradas são valores inseridos pelo usuário. Dessa forma, não é necessariamente um sinal de um problema que isso falhe periodicamente em validar.
```
$ 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"
}
```
# Gere ou verifique um iCVV para um cartão específico
O [iCVV](terminology.md#terms.icvv) usa o mesmo algoritmo que o CVV/, CVV2 mas o iCVV é incorporado dentro de um cartão com chip. Seu código de serviço é 999.
## Crie a chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/c7dsi763r6s7lfp3. Isso será necessário na próxima etapa.
## Gere um iCVV
**Example**
Neste exemplo, geraremos um [iCVV](terminology.md#terms.icvv) para um determinado PAN com entradas de`PAN`, um código de serviço (conforme definido pelo ISO/IEC 7813) de 999 e a data de validade do cartão.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da 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"
}
```
## Validar o iCVV
**Example**
Para validação, as entradas são CVK`PAN`, um código de serviço de 999, data de validade do cartão e o iCVV fornecido durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
O iCVV não é um valor inserido pelo usuário (como CVV2), mas normalmente está incorporado em um EMV/chip cartão. Deve-se considerar se ele deve sempre ser validado quando fornecido.
```
$ 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 um EMV ARQC e gere um ARPC
[O ARQC](terminology.md#terms.arqc) (Criptograma de Solicitação de Autorização) é um criptograma gerado por um cartão EMV (chip) e usado para validar os detalhes da transação, bem como o uso de um cartão autorizado. Ele incorpora dados do cartão, do terminal e da própria transação.
No momento da validação no back-end, as mesmas entradas são fornecidas para a criptografia de AWS pagamento, o criptograma é recriado internamente e comparado com o valor fornecido com a transação. Nesse sentido, é semelhante a um MAC. O [EMV 4.4 Livro 2](https://www.emvco.com/specifications/?post_id=80377) define três aspectos dessa função: métodos de derivação de chave (conhecidos como chave de sessão comum - CSK) para gerar chaves de transação únicas, uma carga útil mínima e métodos para gerar uma resposta (ARPC).
Esquemas de cartões individuais podem especificar campos transacionais adicionais a serem incorporados ou a ordem em que esses campos aparecem. Outros esquemas de derivação específicos do esquema (geralmente obsoletos) também existem e são abordados em outra parte desta documentação.
Para obter mais informações, consulte [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)o guia da API.
## Crie a chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
## Gere um ARQC
O ARQC é gerado exclusivamente por um cartão EMV. Dessa AWS forma, a criptografia de pagamento não tem facilidade para gerar essa carga útil. Para fins de teste, várias bibliotecas estão disponíveis on-line que podem gerar uma carga útil apropriada, bem como valores conhecidos que geralmente são fornecidos pelos vários esquemas.
## Validar um ARQC
**Example**
Se a criptografia AWS de pagamento for capaz de validar o ARQC, um http/200 será retornado. Opcionalmente, um ARPC (resposta) pode ser fornecido e incluído na resposta após a validação do 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"
}
```
# Gere e verifique um MAC EMV
EMV MAC é MAC usando uma entrada de uma chave derivada de EMV e, em seguida, executando um MAC ISO9797 -3 (varejo) sobre os dados resultantes. O EMV MAC é normalmente usado para enviar comandos para uma placa EMV, como scripts de desbloqueio.
**nota**
AWS A criptografia de pagamento não valida o conteúdo do script. Consulte o manual do esquema ou da placa para obter detalhes sobre os comandos específicos a serem incluídos.
Para obter mais informações, consulte [MacAlgorithmEmv](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_MacAlgorithmEmv.html)o guia da API.
**Topics**
+ [Crie a chave](#use-cases-issuers.generalfunctions.emvmac.setup)
+ [Gere um MAC EMV](#use-cases-issuers.generalfunctions.emvmac.generate)
## Crie a chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
## Gere um MAC EMV
O fluxo típico é que um processo de back-end gera um script EMV (como desbloqueio de cartão), assina-o usando esse comando (que deriva uma chave única específica para uma placa específica) e, em seguida, retornará o MAC. Em seguida, o comando \$1 MAC é enviado para o cartão a ser aplicado. Enviar o comando para o cartão está fora do escopo da criptografia de AWS pagamento.
**nota**
Esse comando é destinado a comandos quando nenhum dado criptografado (como PIN) é enviado. O EMV Encrypt pode ser combinado com esse comando para anexar dados criptografados ao script do emissor antes de chamar esse comando.
Dados da mensagem
Os dados da mensagem incluem o cabeçalho e o comando APDU. Embora isso possa variar de acordo com a implementação, este exemplo é o cabeçalho APDU para desbloqueio (84 24 00 00 08), seguido pelo ATC (0007) e depois pelo ARQC da transação anterior (999E57 F47CACE). FD0 O serviço não valida o conteúdo desse campo.
Modo de derivação da chave de sessão
Esse campo define como a chave de sessão é gerada. O EMV\$1COMMON\$1SESSION\$1KEY geralmente é usado para as novas implementações, enquanto EMV2000 \$1 AMEX \$1 MASTERCARD\$1SESSION\$1KEY \$1 VISA também pode ser usado.
MajorKeyDerivationMode
O EMV define o modo A, B ou C. O modo A é o mais comum e a criptografia AWS de pagamento atualmente suporta o modo A ou o modo B.
PAN
O número da conta, normalmente disponível no campo de chip 5A ou ISO8583 campo 2, mas também pode ser recuperado do sistema de cartão.
PSN
O número de sequência do cartão. Se não for usado, insira 00.
SessionKeyDerivationValue
Esses são os dados de derivação por sessão. Pode ser o último ARQC (ApplicationCryptogram) do campo 9F26 ou o último ATC do 9F36, dependendo do esquema de derivação.
Padding
O preenchimento é aplicado automaticamente e usa o método de preenchimento ISO/IEC 9797-1 2.
**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"
}
```
# Gere EMV MAC para alteração de PIN
A alteração do PIN EMV combina duas operações: gerar um MAC para um script do emissor e criptografar um novo PIN para alteração offline do PIN em um cartão com chip EMV. Esse comando só é necessário em alguns países onde o PIN está armazenado no cartão com chip (isso é comum em países europeus). Isso é comumente usado quando o titular do cartão precisa alterar seu PIN e o novo PIN deve ser transmitido com segurança ao cartão junto com um MAC para verificar a autenticidade do comando.
**nota**
Se você precisar apenas enviar comandos para a placa, mas não alterar o PIN, considere usar os comandos [ARPC CSU](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyAuthRequestCryptogram.html) ou [Generate EMV MAC](use-cases-issuers.generalfunctions.emvmac.md).
Para obter mais informações, consulte [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange.html)o guia da API.
## Gere EMV MAC e PIN criptografado para alteração de PIN
Essa operação requer duas chaves: uma chave de integridade EMV (: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) para geração de MAC e uma chave de confidencialidade EMV (KeyUsage: \$1E4\$1EMV\$1MKEY\$1CONFIDENTIALITY) para criptografia de PIN. KeyUsage TR31 O fluxo típico é que um processo de back-end gera um script de alteração de PIN EMV, que inclui tanto o MAC do script do emissor quanto o novo PIN criptografado. O comando e o PIN criptografado são então enviados ao cartão para atualizar o PIN offline. Enviar o comando para o cartão está fora do escopo da criptografia de AWS pagamento.
Dados da mensagem
Os dados da mensagem incluem o comando APDU para o script do emissor. O serviço não valida o conteúdo desse campo.
Novo bloco de PIN criptografado
O novo bloco de PIN criptografado que será enviado para o cartão. Isso deve ser fornecido como um valor criptografado usando uma chave de criptografia PIN.
Novo identificador PIN PEK
A chave usada para criptografar o novo PIN antes de ser passado para essa API.
Chave de integridade de mensagens seguras
A chave de integridade EMV (KeyUsage: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) usada para geração de MAC.
Chave de confidencialidade de mensagens seguras
A chave de confidencialidade EMV (KeyUsage: TR31 \$1E4\$1EMV\$1MKEY\$1CONFIDENTIALITY) usada para criptografia de PIN.
MajorKeyDerivationMode
O EMV define o Modo A, B ou C. O Modo A é o mais comum e a Criptografia de AWS Pagamento atualmente suporta o modo A ou o modo B.
Modo
O modo de criptografia, normalmente CBC para operações de alteração de PIN.
PAN
O número da conta, normalmente disponível no campo de chip 5A ou ISO8583 campo 2, mas também pode ser recuperado do sistema de cartão.
PanSequenceNumber
O número de sequência do cartão. Se não for usado, insira 00.
ApplicationCryptogram
Esses são os dados de derivação por sessão, normalmente o último ARQC do campo 9F26.
PinBlockLengthPosition
Especifica onde o comprimento do bloco PIN é codificado. Normalmente definido como NENHUM. Verifique as especificações do esquema do cartão se não tiver certeza.
PinBlockPaddingType
Especifica o tipo de preenchimento para o bloco de PIN. Normalmente definido como NO\$1PADDING. Verifique as especificações do esquema do cartão se não tiver certeza.
**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"
}
```
# Funções específicas da rede
**Topics**
+ [Funções específicas do visto](use-cases-issuers.networkfunctions.visa.md)
+ [Funções específicas da Mastercard](use-cases-issuers.networkfunctions.mastercard.md)
+ [Funções específicas do American Express](use-cases-issuers.networkfunctions.amex.md)
+ [Funções específicas do JCB](use-cases-issuers.networkfunctions.jcb.md)
# Funções específicas do visto
**Topics**
+ [ARAC -/ CVN18CVN22](#use-cases-issuers.networkfunctions.visa.cvn18)
+ [ARQC - CVN10](#use-cases-issuers.networkfunctions.visa.cvn10)
+ [3DS CAV V7](#use-cases-issuers.networkfunctions.visa.cavv-v7)
+ [DCvv (valor de verificação dinâmica do cartão) - CVN17](#use-cases-issuers.networkfunctions.visa.dcvv)
## ARAC -/ CVN18CVN22
CVN18 e CVN22 utilize o [método CSK](use-cases-issuers.generalfunctions.arqc.md) de derivação de chaves. Os dados exatos da transação variam entre esses dois métodos. Consulte a documentação do esquema para obter detalhes sobre a construção do campo de dados da transação.
## ARQC - CVN10
CVN10 é um método Visa mais antigo para transações EMV que usa derivação por chave de cartão em vez de derivação de sessão (por transação) e também usa uma carga útil diferente. Para obter informações sobre o conteúdo da carga útil, entre em contato com o esquema para obter detalhes.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
### Valide o ARQC
**Example**
Neste exemplo, validaremos um ARQC gerado usando Visa. CVN10
Se a criptografia AWS de pagamento for capaz de validar o ARQC, um http/200 será retornado. Se o ARQC não for validado, ele retornará uma resposta 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"
}
```
## 3DS CAV V7
Para transações com Visa Secure (3DS), um CAVV (Valor de Verificação de Autenticação do Titular do Cartão) é gerado pelo Servidor de Controle de Acesso (ACS) do emissor. O CAVV é uma evidência de que a autenticação do titular do cartão ocorreu, é exclusivo para cada transação de autenticação e é fornecido pelo adquirente na mensagem de autorização. O CAVV v7 vincula dados adicionais sobre a transação à aprovação, incluindo elementos como nome do comerciante, valor da compra e data da compra. Dessa forma, é efetivamente um hash criptográfico da carga útil da transação.
Criptograficamente, o CAVV V7 utiliza o algoritmo CVV, mas todas as entradas foram changed/repurposed. Please consult appropriate third party/Visa documentadas sobre como produzir as entradas para gerar uma carga útil do CAVV V7.
### Crie a chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/dnaeyrjgdjjtw6dk*. Isso será necessário na próxima etapa.
### Gere um CAVV V7
**Example**
Neste exemplo, geraremos um CAVV V7 para uma determinada transação com entradas conforme especificado nas especificações. Observe que, para esse algoritmo, os campos podem ser reutilizados/reutilizados, portanto, não se deve presumir que os rótulos dos campos correspondam às entradas.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da 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"
}
```
### Validar CAVV V7
**Example**
Para validação, as entradas são CVK, os valores de entrada computados e o CAVV fornecidos durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
CAVV não é um valor inserido pelo usuário (como CVV2), mas é calculado pelo emissor ACS. Deve-se considerar se ele deve sempre ser validado quando fornecido.
```
$ 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 verificação dinâmica do cartão) - CVN17
DCvv (valor dinâmico de verificação de cartão) é um criptograma dinâmico específico da Visa usado para transações EMV sem contato. É conhecido como EMV inicial e fornece segurança aprimorada ao gerar um valor de verificação exclusivo para cada transação. O DCvv usa entradas que incluem o Número da Conta Primária (PAN), o Número de Sequência PAN (PSN), o Contador de Transações do Aplicativo (ATC), o número imprevisível e os dados de rastreamento. Ele ainda é usado em alguns lugares, mas foi substituído principalmente por outros algoritmos, como CVN18.
Para ver todos os parâmetros disponíveis, consulte [DynamicCardVerificationValue](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DynamicCardVerificationValue.html)o guia de referência da API.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/mw7dn3qxvkfh8ztc. Isso será necessário na próxima etapa.
### Gerar um DCvv
**Example**
Neste exemplo, geraremos um DCvv para uma transação EMV sem contato. As entradas incluem o PAN, o número de sequência do PAN, o contador de transações do aplicativo, o número imprevisível e os dados de rastreamento.
```
$ 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"
}
```
### Validar DCvV
**Example**
Neste exemplo, validaremos um DCvv fornecido durante uma transação. As mesmas entradas usadas para geração devem ser fornecidas para validação.
Se a criptografia AWS de pagamento puder ser validada, um http/200 será retornado. Se o valor não for validado, ele retornará uma resposta 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"
}
```
# Funções específicas da Mastercard
**Topics**
+ [DCVC3](#use-cases-issuers.networkfunctions.mastercard.dcvc)
+ [ARAC -/ CVN14CVN15](#use-cases-issuers.networkfunctions.mastercard.cvn14)
+ [ARAC -/ CVN12CVN13](#use-cases-issuers.networkfunctions.mastercard.cvn12)
+ [3DS SPA2 AAV](#use-cases-issuers.networkfunctions.mastercard.spa2aav)
## DCVC3
DCVC3 antecede os CVN12 esquemas EMV CSK e Mastercard e representa outra abordagem para a utilização de chaves dinâmicas. Às vezes, também é reutilizado para outros casos de uso. Nesse esquema, as entradas são dados PAN, PSN, Track1/Track2, um número imprevisível e um contador de transações (ATC).
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/hrh6qgbi3sk4y3wq*. Isso será necessário na próxima etapa.
### Gere um DCVC3
**Example**
Embora normalmente DCVC3 seja gerado por um cartão com chip, ele também pode ser gerado manualmente, como neste exemplo
```
$ 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 o DCVC3
**Example**
Neste exemplo, vamos validar um DCVC3. Observe que o ATC deve ser fornecido como um número hexadecimal, por exemplo, um contador de 11 deve ser representado como 000B. O serviço espera um valor de 3 dígitos; portanto DCVC3, se você armazenou um valor de 4 (ou 5) dígitos, basta truncar os caracteres à esquerda até ter 3 dígitos (por exemplo, 15321 deve resultar em um valor de dados de validação de 321).
Se a criptografia AWS de pagamento puder ser validada, um http/200 será retornado. Se o valor não for validado, ele retornará uma resposta 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"
}
```
## ARAC -/ CVN14CVN15
CVN14 e CVN15 utilize o [método EMV CSK](use-cases-issuers.generalfunctions.arqc.md) de derivação de chaves. Os dados exatos da transação variam entre esses dois métodos. Consulte a documentação do esquema para obter detalhes sobre a construção do campo de dados da transação.
## ARAC -/ CVN12CVN13
CVN12 e CVN13 são métodos mais antigos específicos da Mastercard para transações EMV que incorporam um número imprevisível na derivação por transação e também usam uma carga útil diferente. Para obter informações sobre o conteúdo da carga útil, entre em contato com o esquema.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
### Valide o ARQC
**Example**
Neste exemplo, validaremos um ARQC gerado usando o Mastercard. CVN12
Se a criptografia AWS de pagamento for capaz de validar o ARQC, um http/200 será retornado. Se o ARQC não for validado, ele retornará uma resposta 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"
}
```
## 3DS SPA2 AAV
SPA2 O AAV (Account Authentication Value) é usado para transações Mastercard 3DS (também conhecidas como Mastercard Idenity Check). Ele fornece autenticação criptográfica para transações de comércio eletrônico usando a geração MAC baseada em HMAC. O AAV é gerado usando dados específicos da transação e uma chave secreta compartilhada.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-west* - 2:111122223333:key/q5vjtshsg67cz5gn. Isso será necessário na próxima etapa.
### Gerar SPA2 AAV
**Example**
Neste exemplo, geraremos o componente Issuer Authentication Value (IAV) do SPA2 AAV usando a geração HMAC MAC. Os dados da mensagem contêm as informações específicas da transação que serão autenticadas. O formato dos dados da mensagem deve seguir as SPA2 especificações da Mastercard e não é abordado neste exemplo.
Verifique as especificações da Mastercard quanto à formatação para inserir o IAV no valor do 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"
}
```
### Verifique o SPA2 AAV
**Example**
Neste exemplo, verificaremos um SPA2 AAV. Os mesmos dados da mensagem e o mesmo valor MAC são fornecidos para verificação.
Se a criptografia AWS de pagamento conseguir validar o MAC, um http/200 será retornado. Se o MAC não for validado, ele retornará uma resposta 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"
}
```
# Funções específicas do American Express
**Topics**
+ [CSC1](#use-cases-issuers.networkfunctions.amex.csc)
+ [CSC2](#use-cases-issuers.networkfunctions.amex.csc2)
+ [iCSC](#use-cases-issuers.networkfunctions.amex.csc3)
+ [AV 3DS](#use-cases-issuers.networkfunctions.amex.3dsaevv)
## CSC1
A versão 1 do CSC também é conhecida como o algoritmo clássico do CSC. O serviço pode fornecê-lo como um número de 3,4 ou 5 dígitos.
Para ver todos os parâmetros disponíveis, consulte [AmexCardSecurityCodeVersion1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion1.html) no guia de referência da API.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/esh6hn7pxdtttzgq*. Isso será necessário na próxima etapa.
### Gere um 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 o CSC1
**Example**
Neste exemplo, vamos validar um CSC1.
Se a criptografia AWS de pagamento puder ser validada, um http/200 será retornado. Se o valor não for validado, ele retornará uma resposta 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
A versão 2 do CSC também é conhecida como algoritmo CSC aprimorado. O serviço pode fornecê-lo como um número de 3,4 ou 5 dígitos. O código de serviço para normalmente CSC2 é 000.
Para todos os parâmetros disponíveis, consulte [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) no guia de referência da API.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/erlm445qvunmvoda. Isso será necessário na próxima etapa.
### Gere um CSC2
Neste exemplo, geraremos um CSC2 com um comprimento de 4. O CSC pode ser gerado com um comprimento de 3,4 ou 5. Para American Express, PANs deve ter 15 dígitos e começar com 34 ou 37. A data de expiração geralmente é formatada como YYMM. O código de serviço pode variar - revise seu manual, mas os valores típicos são 000, 201 ou 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 o CSC2
**Example**
Neste exemplo, vamos validar um CSC2.
Se a criptografia AWS de pagamento puder ser validada, um http/200 será retornado. Se o valor não for validado, ele retornará uma resposta 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
O iCSC também é conhecido como algoritmo CSC estático e é calculado usando o CSC versão 2. O serviço pode fornecê-lo como um número de 3,4 ou 5 dígitos.
Use o código de serviço 999 para calcular o iCSC para um cartão de contato. Use o código de serviço 702 para calcular o iCSC para um cartão sem contato.
Para todos os parâmetros disponíveis, consulte [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) no guia de referência da API.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 1:111122223333:key/7vrybrbvjcvwtunv*. Isso será necessário na próxima etapa.
### Gere um iCSC
Neste exemplo, geraremos um iCSC com um comprimento de 4, para um cartão sem contato usando o código de serviço 702. O CSC pode ser gerado com um comprimento de 3,4 ou 5. Para American Express, PANs deve ter 15 dígitos e começar com 34 ou 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"
}
```
### Validar o iCSC
**Example**
Neste exemplo, validaremos um iCSC.
Se a criptografia AWS de pagamento puder ser validada, um http/200 será retornado. Se o valor não for validado, ele retornará uma resposta 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
}
```
## AV 3DS
O 3DS AEVV (3-D Secure Account Verification Value) é usado para a autenticação American Express 3-D Secure. Ele usa o mesmo algoritmo, CSC2 mas com parâmetros de entrada diferentes. O campo da data de expiração deve ser preenchido com um número imprevisível (aleatório), e o código do serviço consiste no Código de Resultados da Autenticação AEVV (1 dígito) mais o Código de Autenticação de Segundo Fator (2 dígitos). O comprimento da saída deve ser de 3 dígitos.
Para todos os parâmetros disponíveis, consulte [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) no guia de referência da API.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/kw8djn5qxvfh3ztm. Isso será necessário na próxima etapa.
### Gere um 3DS AEVV
Neste exemplo, geraremos um 3DS AEVV com um comprimento de 3. O campo da data de expiração contém um número imprevisível (aleatório) (por exemplo, 1234), e o código do serviço consiste no Código de Resultados de Autenticação AEVV (1 dígito) mais o Código de Autenticação de Segundo Fator (2 dígitos), por exemplo, 543, onde 5 é o Código de Resultados de Autenticação e 43 é o Código de Autenticação de Segundo Fator. Para American Express, PANs deve ter 15 dígitos e começar com 34 ou 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 o 3DS AEVV
**Example**
Neste exemplo, validaremos um 3DS AEVV.
Se a criptografia AWS de pagamento puder ser validada, um http/200 será retornado. Se o valor não for validado, ele retornará uma resposta 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
}
```
# Funções específicas do JCB
**Topics**
+ [ARQC - CVN04](#use-cases-issuers.networkfunctions.jcb.cvn04)
+ [ARQC - CVN01](#use-cases-issuers.networkfunctions.jcb.cvn01)
## ARQC - CVN04
A JCB CVN04 utiliza o [método CSK de derivação](use-cases-issuers.generalfunctions.arqc.md) de chaves. Consulte a documentação do esquema para obter detalhes sobre a construção do campo de dados da transação.
## ARQC - CVN01
CVN01 é um método JCB mais antigo para transações EMV que usa derivação por chave de cartão em vez de derivação de sessão (por transação) e também usa uma carga útil diferente. Essa mensagem também é usada pela Visa, portanto, o nome do elemento tem esse nome, embora também seja usado para JCB. Para obter informações sobre o conteúdo da carga útil, entre em contato com a documentação do esquema.
### Criar chave
```
$ 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"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (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"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
### Valide o ARQC
**Example**
Neste exemplo, validaremos um ARQC gerado usando o JCB. CVN01 Isso usa as mesmas opções do método Visa, daí o nome do parâmetro.
Se a criptografia AWS de pagamento for capaz de validar o ARQC, um http/200 será retornado. Se o ARQC não for validado, ele retornará uma resposta 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"
}
```