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á.
# 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"
}
```