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á.
# Operações de dados
Depois de estabelecer uma chave AWS de criptografia de pagamento, ela pode ser usada para realizar operações criptográficas. Operações diferentes realizam diferentes tipos de atividade, desde criptografia, hashing até algoritmos específicos de domínio, como CVV2 geração.
Os dados criptografados não podem ser descriptografados sem a chave de decodificação correspondente (a chave simétrica ou a chave privada, dependendo do tipo de criptografia). Da mesma forma, os algoritmos de hash e específicos de domínio não podem ser verificados sem a chave simétrica ou a chave pública.
Para obter informações sobre tipos de chaves válidas para operações específicas, consulte [Chaves válidas para operações criptográficas](crypto-ops-validkeys-ops.md)
**nota**
Recomendamos o uso de dados de teste em um ambiente que não seja de produção. O uso de chaves e dados de produção (PAN, BDK ID etc.) em um ambiente que não seja de produção pode afetar seu escopo de conformidade, como PCI DSS e PCI P2PE.
**Topics**
+ [Criptografe, descriptografe e recriptografe dados](crypto-ops.encryptdecrypt.md)
+ [Gerar e verificar dados do cartão](crypto-ops-carddata.md)
+ [Gerar, traduzir e verificar dados de PIN](data-operations.pindata.md)
+ [Verificar o criptograma de solicitação de autenticação (ARQC)](data-operations.verifyauthrequestcryptogram.md)
+ [Gerar e verificar MAC](crypto-ops-mac.md)
+ [Chaves válidas para operações criptográficas](crypto-ops-validkeys-ops.md)
# Criptografe, descriptografe e recriptografe dados
Métodos de criptografia e descriptografia podem ser usados para criptografar ou descriptografar dados usando uma variedade de técnicas simétricas e assimétricas, incluindo TDES, AES e RSA. Esses métodos também oferecem suporte a chaves derivadas usando as técnicas [DUKPT](terminology.md#terms.dukpt) e [EMV](terminology.md#terms.emv). Para casos de uso em que você deseja proteger dados com uma nova chave sem expor os dados subjacentes, o ReEncrypt comando também pode ser usado.
**nota**
Ao usar as encrypt/decrypt funções, presume-se que todas as entradas estejam em hexBinary - por exemplo, um valor de 1 será inserido como 31 (hexadecimal) e um t minúsculo será representado como 74 (hexadecimal). Todas as saídas também serão geradas em hexBinary.
[Para obter detalhes sobre todas as opções disponíveis, consulte o Guia de API para [criptografar, descriptografar](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_EncryptData.html)[e recriptografar.](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DecryptData.html)](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_ReEncryptData.html)
**Topics**
+ [Criptografar dados](encrypt-data.md)
+ [Descriptografar dados](decrypt-data.md)
# Criptografar dados
[A `Encrypt Data` API é usada para criptografar dados usando chaves de criptografia de dados simétricas e assimétricas, bem como chaves derivadas de [DUKPT](terminology.md#terms.dukpt) e EMV.](terminology.md#terms.emv) Vários algoritmos e variações são compatíveis, incluindo `TDES`, `RSA` e `AES`.
As entradas primárias são a chave de criptografia usada para criptografar os dados, os dados de texto simples no formato HexBinary a serem criptografados e os atributos de criptografia, como vetor e modo de inicialização, para cifras de bloco, como TDES. Os dados em texto simples precisam estar em múltiplos de 8 bytes para`TDES`, 16 bytes para `AES` e o tamanho da chave no caso de. `RSA` As entradas de chave simétricas (TDES, AES, DUKPT, EMV) devem ser preenchidas nos casos em que os dados de entrada não atendam a esses requisitos. A tabela a seguir mostra o tamanho máximo do texto sem formatação para cada tipo de chave e o tipo de preenchimento que você define `EncryptionAttributes` para as chaves RSA.
| Tipo de preenchimento | RSA\$12048 | RSA\$13072 | RSA\$14096 |
| --- | --- | --- | --- |
| OAEP SHA1 | 428 | 684 | 940 |
| OAEP SHA256 | 380 | 636 | 892 |
| OAEP SHA512 | 252 | 508 | 764 |
| PKCS1 | 488 | 744 | 1000 |
| None | 488 | 744 | 1000 |
As saídas primárias incluem os dados criptografados como texto cifrado no formato hexBinary e o valor da soma de verificação da chave de criptografia. Para obter detalhes sobre todas as opções disponíveis, consulte o Guia de API do [Encrypt.](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_EncryptData.html)
**Topics**
+ [Criptografe dados usando a chave simétrica AES](#w2aac15c16c11c13)
+ [Criptografe dados usando a chave DUKPT](#w2aac15c16c11c15)
+ [Criptografe dados usando a chave simétrica derivada do EMV](#w2aac15c16c11c17)
+ [Criptografe dados usando uma chave RSA](#crypto-ops.encrypt-rsa)
## Criptografe dados usando a chave simétrica AES
**nota**
Todos os exemplos presumem que a chave relevante já existe. As chaves podem ser criadas usando a [CreateKey](create-keys.md)operação ou importadas usando a [ImportKey](keys-import.md)operação.
**Example**
Neste exemplo, criptografaremos dados em texto simples usando uma chave simétrica que foi criada usando a [CreateKey](create-keys.md)Operação ou importada usando a Operação. [ImportKey](keys-import.md) Para essa operação, a chave deve ter sido KeyModesOfUse definida como `Encrypt` e KeyUsage definida como`TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais opções.
```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --plain-text 31323334313233343132333431323334 --encryption-attributes 'Symmetric={Mode=CBC}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"CipherText": "33612AB9D6929C3A828EB6030082B2BD"
}
```
## Criptografe dados usando a chave DUKPT
**Example**
[Neste exemplo, criptografaremos dados em texto simples usando uma chave DUKPT.](terminology.md#terms.dukpt) AWS Suportes de criptografia de pagamento `TDES` e chaves `AES` DUKPT. Para essa operação, a chave deve ter sido KeyModesOfUse definida como `DeriveKey` e KeyUsage definida como`TR31_B0_BASE_DERIVATION_KEY`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais opções.
```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --plain-text 31323334313233343132333431323334 --encryption-attributes 'Dukpt={KeySerialNumber=FFFF9876543210E00001}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"CipherText": "33612AB9D6929C3A828EB6030082B2BD"
}
```
## Criptografe dados usando a chave simétrica derivada do EMV
**Example**
Neste exemplo, criptografaremos dados de texto não criptografado usando uma chave simétrica derivada do EMV que já foi criada. Você pode usar um comando como esse para enviar dados para um cartão EMV. Para essa operação, a chave deve ter sido KeyModesOfUse definida como `Derive` e KeyUsage definida como `TR31_E1_EMV_MKEY_CONFIDENTIALITY` ou`TR31_E6_EMV_MKEY_OTHER`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais detalhes.
```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --plain-text 33612AB9D6929C3A828EB6030082B2BD --encryption-attributes 'Emv={MajorKeyDerivationMode=EMV_OPTION_A,PanSequenceNumber=27,PrimaryAccountNumber=1000000000000432,SessionDerivationData=02BB000000000000, InitializationVector=1500000000000999,Mode=CBC}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"CipherText": "33612AB9D6929C3A828EB6030082B2BD"
}
```
## Criptografe dados usando uma chave RSA
**Example**
Neste exemplo, criptografaremos dados em texto simples usando uma [chave pública RSA](terminology.md#terms.publickey) que foi importada usando a operação. [ImportKey](keys-import.md) Para essa operação, a chave deve ter sido KeyModesOfUse definida como `Encrypt` e KeyUsage definida como`TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais opções.
Para esquemas de preenchimento como o PKCS \$17 ou outros atualmente não compatíveis, aplique antes de chamar o serviço e selecione nenhum preenchimento ao omitir o indicador de preenchimento* 'Asymmetric=\$1\$1'*
```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/thfezpmsalcfwmsg --plain-text 31323334313233343132333431323334 --encryption-attributes 'Asymmetric={PaddingType=OAEP_SHA256}'
```
```
{
"CipherText": "12DF6A2F64CC566D124900D68E8AFEAA794CA819876E258564D525001D00AC93047A83FB13 \
E73F06329A100704FA484A15A49F06A7A2E55A241D276491AA91F6D2D8590C60CDE57A642BC64A897F4832A3930 \
0FAEC7981102CA0F7370BFBF757F271EF0BB2516007AB111060A9633D1736A9158042D30C5AE11F8C5473EC70F067 \
72590DEA1638E2B41FAE6FB1662258596072B13F8E2F62F5D9FAF92C12BB70F42F2ECDCF56AADF0E311D4118FE3591 \
FB672998CCE9D00FFFE05D2CD154E3120C5443C8CF9131C7A6A6C05F5723B8F5C07A4003A5A6173E1B425E2B5E42AD \
7A2966734309387C9938B029AFB20828ACFC6D00CD1539234A4A8D9B94CDD4F23A",
"KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/5dza7xqd6soanjtb",
"KeyCheckValue": "FF9DE9CE"
}
```
# Descriptografar dados
[[A `Decrypt Data` API é usada para descriptografar dados usando chaves de criptografia de dados simétricas e assimétricas, bem como chaves derivadas de DUKPT e EMV.](terminology.md#terms.emv)](terminology.md#terms.dukpt) Vários algoritmos e variações são compatíveis, incluindo `TDES`, `RSA` e `AES`.
As entradas primárias são a chave de descriptografia usada para descriptografar dados, dados de texto cifrado no formato hexBinary a serem descriptografados e atributos de descriptografia, como vetor de inicialização, modo como cifras de bloco etc. As saídas primárias incluem os dados descriptografados como texto simples no formato hexBinary e o valor da soma de verificação da chave de decodificação. Para obter detalhes sobre todas as opções disponíveis, consulte o Guia de API para [desencriptação](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DecryptData.html).
**Topics**
+ [Descriptografe dados usando a chave simétrica AES](#w2aac15c16c13b9)
+ [Descriptografe dados usando a chave DUKPT](#w2aac15c16c13c11)
+ [Descriptografe dados usando a chave simétrica derivada do EMV](#w2aac15c16c13c13)
+ [Descriptografe dados usando uma chave RSA](#crypto-ops.decrypt-rsa)
## Descriptografe dados usando a chave simétrica AES
**Example**
Neste exemplo, decifraremos dados de texto cifrado usando uma chave simétrica. Este exemplo mostra uma `AES` chave, mas `TDES_2KEY` ela também `TDES_3KEY` é suportada. Para essa operação, a chave deve ter sido KeyModesOfUse definida como `Decrypt` e KeyUsage definida como`TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais opções.
```
$ aws payment-cryptography-data decrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --cipher-text 33612AB9D6929C3A828EB6030082B2BD --decryption-attributes 'Symmetric={Mode=CBC}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"PlainText": "31323334313233343132333431323334"
}
```
## Descriptografe dados usando a chave DUKPT
**nota**
O uso de dados de decodificação com DUKPT para transações P2PE pode retornar o PAN do cartão de crédito e outros dados do titular do cartão ao seu aplicativo, que precisarão ser contabilizados ao determinar o escopo do PCI DSS.
**Example**
Neste exemplo, decifraremos dados de texto cifrado usando uma chave [DUKPT](terminology.md#terms.dukpt) que foi criada usando a Operação ou importada usando a [CreateKey](create-keys.md)Operação. [ImportKey](keys-import.md) Para essa operação, a chave deve ter sido KeyModesOfUse definida como `DeriveKey` e KeyUsage definida como`TR31_B0_BASE_DERIVATION_KEY`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais opções. Quando você usa `DUKPT`, para o algoritmo `TDES`, o comprimento dos dados do texto cifrado deve ser um múltiplo de 16 bytes. Para o algoritmo `AES`, o comprimento dos dados do texto cifrado deve ser um múltiplo de 32 bytes.
```
$ aws payment-cryptography-data decrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --cipher-text 33612AB9D6929C3A828EB6030082B2BD --decryption-attributes 'Dukpt={KeySerialNumber=FFFF9876543210E00001}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"PlainText": "31323334313233343132333431323334"
}
```
## Descriptografe dados usando a chave simétrica derivada do EMV
**Example**
Neste exemplo, decifraremos dados de texto cifrado usando uma chave simétrica derivada do EMV que foi criada usando a operação ou importada usando a operação. [CreateKey[ImportKey](keys-import.md)](create-keys.md) Para essa operação, a chave deve ter sido KeyModesOfUse definida como `Derive` e KeyUsage definida como `TR31_E1_EMV_MKEY_CONFIDENTIALITY` ou`TR31_E6_EMV_MKEY_OTHER`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais detalhes.
```
$ aws payment-cryptography-data decrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --cipher-text 33612AB9D6929C3A828EB6030082B2BD --decryption-attributes 'Emv={MajorKeyDerivationMode=EMV_OPTION_A,PanSequenceNumber=27,PrimaryAccountNumber=1000000000000432,SessionDerivationData=02BB000000000000, InitializationVector=1500000000000999,Mode=CBC}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"PlainText": "31323334313233343132333431323334"
}
```
## Descriptografe dados usando uma chave RSA
**Example**
Neste exemplo, decifraremos dados de texto cifrado usando um [par de chaves RSA que foi criado](terminology.md#terms.privatekey) usando a operação. [CreateKey](create-keys.md) Para essa operação, a chave deve estar KeyModesOfUse configurada para habilitar `Decrypt` e KeyUsage definida como`TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION`. Consulte [Chaves para operações criptográficas](crypto-ops-validkeys-ops.md) para obter mais opções.
Para esquemas de preenchimento como o PKCS \$17 ou outros atualmente não compatíveis, selecione nenhum preenchimento ao omitir o indicador de preenchimento *'Asymmetric= \$1\$1'* e remova o preenchimento após chamar o serviço.
```
$ aws payment-cryptography-data decrypt-data \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/5dza7xqd6soanjtb --cipher-text 8F4C1CAFE7A5DEF9A40BEDE7F2A264635C... \
--decryption-attributes 'Asymmetric={PaddingType=OAEP_SHA256}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/5dza7xqd6soanjtb",
"KeyCheckValue": "FF9DE9CE",
"PlainText": "31323334313233343132333431323334"
}
```
# Gerar e verificar dados do cartão
Gere e verifique os dados do cartão incorpora dados derivados dos dados do cartão, por exemplo, CVV CVV2, CVC e DCVV.
**Topics**
+ [Gerar dados do cartão](generate-card-data.md)
+ [Verificar dados do cartão](verify-card-data.md)
# Gerar dados do cartão
A `Generate Card Data` API é usada para gerar dados do cartão usando algoritmos como CVV CVV2 ou Dynamic CVV2. Para saber quais chaves podem ser usadas para esse comando, consulte a seção [Chaves válidas para operações criptográficas](crypto-ops-validkeys-ops.md).
Muitos valores criptográficos, como CVV, iCVV CVV2, CAVV V7, usam o mesmo algoritmo criptográfico, mas variam os valores de entrada. Por exemplo, [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) tem entradas de ServiceCode, Número do cartão e data de validade. Embora [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) tenha apenas duas dessas entradas, isso ocorre porque para CVV2/CVC2, o ServiceCode é fixado em 000. Da mesma forma, para iCVV, o ServiceCode é fixado em 999. Alguns algoritmos podem reutilizar os campos existentes, como CAVV V8. Nesse caso, você precisará consultar o manual do provedor para obter os valores de entrada corretos.
**nota**
A data de expiração deve ser inserida no mesmo formato (como MMYY versus YYMM) para que a geração e a validação produzam resultados corretos.
# Gerar CVV2
**Example**
Neste exemplo, geraremos um CVV2 para um determinado PAN com entradas `PAN` e data de validade do cartão. Isso pressupõe que você tenha [gerado](create-keys.md#cvvkey-example) uma chave de verificação do cartão.
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --generation-attributes CardVerificationValue2={CardExpiryDate=0123}
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "CADDA1",
"ValidationData": "801"
}
```
# Gerar 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 de 999 e a data de validade do cartão. Isso pressupõe que você tenha [gerado](create-keys.md#cvvkey-example) uma chave de verificação 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/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "CADDA1",
"ValidationData": "801"
}
```
# Verificar dados do cartão
O `Verify Card Data` é usado para verificar dados que foram criados usando algoritmos de pagamento que dependem de entidades principais de criptografia, como `DISCOVER_DYNAMIC_CARD_VERIFICATION_CODE`.
Os valores de entrada são normalmente fornecidos como parte de uma transação de entrada para um emissor ou parceiro de plataforma compatível. Para verificar um criptograma ARQC (usado para cartões com chips EMV), consulte [Verificar ARQC](data-operations.verifyauthrequestcryptogram.md).
Para obter mais informações, consulte [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)o guia da API.
Se o valor for verificado, a API retornará http/200. Se o valor não for verificado, ela retornará http/400.
# Verificar CVV2
**Example**
Neste exemplo, validaremos um CVV/ CVV2 para um determinado PAN. Normalmente, CVV2 é fornecido pelo titular do cartão ou usuário durante o período da transação para validação. Para validar sua entrada, os seguintes valores serão fornecidos em tempo de execução - [Chave de uso para validação (CVK)](create-keys.md#cvvkey-example)`PAN`, data de validade do cartão e CVV2 inseridos. O formato de vencimento do cartão deve corresponder ao utilizado na geração inicial do valor.
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 verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --verification-attributes CardVerificationValue2={CardExpiryDate=0123} --validation-data 801
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "CADDA1"
}
```
# Verifique o iCVV
**Example**
Neste exemplo, verificaremos um [iCVV](terminology.md#terms.icvv) para um determinado PAN com entradas de [Chave a ser usada para validação (CVK)](create-keys.md#cvvkey-example), um código de serviço de 999`PAN`, data de validade do cartão e o iCVV fornecido pela transação para validação.
iCVV não é um valor inserido pelo usuário (como CVV2), mas incorporado em um cartão EMV. Deve-se considerar se ele deve sempre ser validado quando fornecido.
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 verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999} --validation-data 801
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "CADDA1",
"ValidationData": "801"
}
```
# Gerar, traduzir e verificar dados de PIN
As funções de dados de PIN permitem gerar PINs aleatórios, valores de verificação de PIN (PVV) e validar PINs criptografados de entrada em relação a compensações de PIN ou PVV.
A tradução de PINs permite traduzir um PIN de uma chave funcional para outra sem expor o PIN em texto não criptografado, conforme especificado pelo requisito n.º 1 do PCI PIN.
**nota**
Como a geração e validação de PINs geralmente são funções do emissor e a tradução de PINs é uma função típica do adquirente, recomendamos que você considere o acesso menos privilegiado e defina políticas apropriadas para o caso de uso do seu sistema.
**Topics**
+ [Traduzir dados de PIN](translate-pin-data.md)
+ [Gerar dados de PIN](generate-pin-data.md)
+ [Verificar dados de PIN](verify-pin-data.md)
# Traduzir dados de PIN
As funções de tradução de dados de PIN são usadas para traduzir dados de PIN criptografados de um conjunto de chaves para outro sem que os dados criptografados saiam do HSM. Isso é usado para criptografia P2PE, na qual as chaves de trabalho devem mudar, mas o sistema de processamento não precisa ou não tem permissão para descriptografar os dados. As entradas primárias são os dados criptografados, a chave de criptografia usada para criptografar os dados, os parâmetros usados para gerar os valores de entrada. O outro conjunto de entradas são os parâmetros de saída solicitados, como a chave a ser usada para criptografar e os parâmetros usados para criar essa saída. As saídas primárias são um conjunto de dados recém-criptografado, bem como os parâmetros usados para gerá-lo.
**nota**
Para conformidade com o PCI, os PrimaryAccountNumber valores de entrada e saída devem corresponder. Não é permitido traduzir um PIN de um PAN para outro.
**Topics**
+ [PIN de PEK para DUKPT](#crypto-ops-pindata.pektodukpt)
+ [PIN de PEK para PEK](#crypto-ops-pindata.pektopek)
## PIN de PEK para DUKPT
**Example**
Neste exemplo, traduziremos um PIN de um bloco AES ISO 4 PIN usando a criptografia [DUKPT](terminology.md#terms.dukpt) para PEK TDES usando o bloco ISO 0 PIN. Isso é comum quando um terminal de pagamento criptografa um PIN em ISO 4 e, em seguida, ele pode ser traduzido de volta para o TDES para processamento posterior, se a próxima conexão ainda não suportar AES.
```
$ aws payment-cryptography-data translate-pin-data --encrypted-pin-block "AC17DC148BDA645E" --outgoing-translation-attributes=IsoFormat0='{PrimaryAccountNumber=171234567890123}' --outgoing-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --incoming-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/4pmyquwjs3yj4vwe --incoming-translation-attributes IsoFormat4="{PrimaryAccountNumber=171234567890123}" --incoming-dukpt-attributes KeySerialNumber="FFFF9876543210E00008"
```
```
{
"PinBlock": "1F4209C670E49F83E75CC72E81B787D9",
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
"KeyCheckValue": "7CC9E2"
}
```
## PIN de PEK para PEK
**Example**
Neste exemplo, traduzimos um PIN criptografado sob um PEK (PIN Encryption Key) para outro PEK. Isso geralmente é usado ao rotear transações entre sistemas ou parceiros diferentes que usam chaves de criptografia diferentes, mantendo a conformidade com o PIN PCI mantendo o PIN criptografado durante todo o processo. Ambas as chaves usam criptografia TDES 3KEY neste exemplo, mas várias opções estão disponíveis, incluindo AES ISO-4 a TDES ISO-0, DUKPT a PEK ou PEK. AS2805
```
$ aws payment-cryptography-data translate-pin-data --encrypted-pin-block "AC17DC148BDA645E" \
--incoming-translation-attributes IsoFormat0='{PrimaryAccountNumber=171234567890123}' \
--incoming-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt \
--outgoing-translation-attributes IsoFormat0='{PrimaryAccountNumber=171234567890123}' \
--outgoing-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/alsuwfxug3pgy6xh
```
```
{
"PinBlock": "E8F2A6C4D1B93E7F",
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/alsuwfxug3pgy6xh",
"KeyCheckValue": "9A325B"
}
```
O bloco PIN de saída agora está criptografado sob o segundo PEK e pode ser transmitido com segurança para o sistema downstream que contém a chave correspondente.
# Gerar dados de PIN
As funções de geração de dados de PIN são usadas para gerar valores relacionados ao PIN, como [PVV](terminology.md#terms.pvv) e compensações de bloco de PIN usados para validar a entrada de PINs pelos usuários durante a transação ou a autorização. Essa API também pode gerar um novo PIN aleatório usando vários algoritmos.
# Gere um pino aleatório e combine o Visa PVV
**Example**
Neste exemplo, geraremos um novo pino (aleatório) onde as saídas serão criptografadas `PIN block` (PinData. PinBlock) e um `PVV` (PinData.offset). As principais entradas são `PAN`, `Pin Verification Key`, `Pin Encryption Key` e `PIN block format`.
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"
}
}
```
# Gere um Visa PVV para um pin conhecido
**Example**
Neste exemplo, geraremos um PVV para um determinado pino (criptografado). Um PIN criptografado pode ser recebido a montante, como de um terminal de pagamento ou do titular do cartão, usando o fluxo de pinos [selecionável pelo usuário](https://github.com/aws-samples/samples-for-payment-cryptography-service/tree/main/python_sdk_example/ecdh_flows). As principais entradas são`PAN`, o`Pin Verification Key`, o`Pin Encryption Key`, o `Encrypted Pin Block` e o. `PIN block format`
```
$ 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 VisaPinVerificationValue={PinVerificationKeyIndex=1,EncryptedPinBlock=AA584CED31790F37}
```
```
{
"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"
}
}
```
# Gerar deslocamento de IBM3624 pino para um pino
O IBM 3624 PIN Offset às vezes também é chamado de método IBM. Esse método gera um natural/intermediate PIN usando os dados de validação (normalmente o PAN) e uma chave PIN (PVK). Os pinos naturais são efetivamente um valor derivado e, sendo determinísticos, é muito eficiente lidar com um emissor, pois nenhum dado de PIN precisa ser armazenado no nível do titular do cartão. A desvantagem mais óbvia é que esse esquema não considera os pinos selecionáveis ou aleatórios do titular do cartão. Para permitir esses tipos de pinos, um algoritmo de deslocamento foi adicionado ao esquema. O deslocamento representa a diferença entre o pino selecionado pelo usuário (ou aleatório) e a chave natural. O valor da compensação é armazenado pelo emissor ou processador do cartão. No momento da transação, o serviço AWS de criptografia de pagamento recalcula internamente o pino natural e aplica o deslocamento para encontrar o pino. Em seguida, ele compara isso com o valor fornecido pela autorização da transação.
Existem várias opções para IBM3624:
+ `Ibm3624NaturalPin`produzirá o pino natural e um bloco de pinos criptografado
+ `Ibm3624PinFromOffset`gerará um bloco de pinos criptografado com um deslocamento
+ `Ibm3624RandomPin`gerará um pino aleatório e, em seguida, o deslocamento correspondente e o bloco de pinos criptografado.
+ `Ibm3624PinOffset`gera o deslocamento do pino de acordo com um pino selecionado pelo usuário.
Internamente à criptografia de AWS pagamento, as seguintes etapas são executadas:
+ Preencha o plano fornecido com 16 caracteres. Se <16 for fornecido, pressione no lado direito usando o caractere de preenchimento fornecido.
+ Criptografa os dados de validação usando a chave de geração do PIN.
+ Decimalize os dados criptografados usando a tabela de decimalização. Isso mapeia dígitos hexidecimais para dígitos decimais, por exemplo, 'A' pode ser mapeado para 9 e 1 pode ser mapeado para 1.
+ Obtenha os primeiros 4 dígitos de uma representação hexidecimal da saída. Esse é o pino natural.
+ Se um pino selecionado pelo usuário ou aleatório foi gerado, o módulo subtrai o pino natural com o pino do cliente. O resultado é o deslocamento do pino.
**Topics**
+ [Exemplo: gerar deslocamento de IBM3624 pino para um pino](#generate-ibm3624-random-example)
## Exemplo: gerar deslocamento de IBM3624 pino para um pino
Neste exemplo, geraremos um novo pino (aleatório) onde as saídas serão criptografadas `PIN block` (PinData. PinBlock) e um valor de `IBM3624` deslocamento (pinData.offset). As entradas são `PAN` dados de validação (normalmente o pan), caractere de preenchimento, o`Pin Verification Key`, o `Pin Encryption Key` e o. `PIN block format`
Esse comando requer que a chave de geração de pinos seja do tipo `TR31_V1_IBM3624_PIN_VERIFICATION_KEY` e a chave de criptografia seja do tipo `TR31_P0_PIN_ENCRYPTION_KEY`
**Example**
O exemplo a seguir mostra a geração de um pino aleatório e, em seguida, a saída do bloco de pinos criptografados e do valor de IBM3624 deslocamento usando Ibm3624. RandomPin
```
$ 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 Ibm3624RandomPin="{DecimalizationTable=9876543210654321,PinValidationDataPadCharacter=D,PinValidationData=171234567890123}"
```
```
{
"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": {
"PinOffset": "5507"
}
}
```
# Verificar dados de PIN
As funções de verificação de dados de PIN são usadas para verificar se um PIN está correto. Isso normalmente envolve comparar o valor do PIN armazenado anteriormente com o que foi inserido pelo titular do cartão em um POI. Essas funções comparam dois valores sem expor o valor subjacente de nenhuma das fontes.
## 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: a chave usada para criptografar o pino de entrada (geralmente é um`IWK`) `PAN` e o valor a ser verificado (a `PVV` ou`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",
}
```
## Valide o PIN criptografado usando o método PVV - erro PIN incorreto
**Example**
Neste exemplo, tentaremos validar um PIN para um determinado PAN, mas isso falhará porque o PIN está incorreto.
Ao usar SDKs, isso aparece como \$1"Message” :"Falha na verificação do bloqueio de pinos.” , "Motivo” :"INVALID\$1PIN "\$1
```
$ 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=9999}" --encrypted-pin-block AC17DC148BDA645E
```
```
An error occurred (VerificationFailedException) when calling the VerifyPinData operation: Pin block verification failed.
```
## Valide o PIN criptografado usando o método PVV - erro de entradas incorretas
**Example**
Neste exemplo, tentaremos validar um PIN para um determinado PAN, mas ele falhará devido a entradas incorretas e os dados recebidos não eram um PIN válido. As causas comuns são: 1/chave errada sendo usada 2/parâmetros de entrada, como formato de bloco de pan ou pin, estão incorretos. O bloco de 3/pinos está corrompido.
```
$ aws payment-cryptography-data verify-pin-data --verification-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --verification-attributes VisaPin="{PinVerificationKeyIndex=1,VerificationValue=9999}" --encrypted-pin-block AC17DC148BDA645E
```
```
An error occurred (ValidationException) when calling the VerifyPinData operation: Pin block provided is invalid. Please check your input to ensure all field values are correct.
```
# Validar um PIN em relação ao deslocamento de IBM3624 pino armazenado anteriormente
Neste exemplo, validaremos o PIN fornecido pelo titular do cartão em relação ao deslocamento de PIN armazenado em arquivo com o emissor/processador do cartão. As entradas são semelhantes às [Gerar deslocamento de IBM3624 pino para um pino](generate-ibm3624.md) do PIN criptografado adicional fornecido pelo terminal de pagamento (ou outro provedor upstream, como a rede de cartões). Se o pino corresponder, a API retornará http 200. onde as saídas serão criptografadas `PIN block` (. PinData PinBlock) e um valor de `IBM3624` deslocamento (pinData.offset).
Esse comando requer que a chave de geração de pinos seja do tipo `TR31_V1_IBM3624_PIN_VERIFICATION_KEY` e a chave de criptografia seja do tipo `TR31_P0_PIN_ENCRYPTION_KEY`
**Example**
```
$ 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 Ibm3624RandomPin="{DecimalizationTable=9876543210654321,PinValidationDataPadCharacter=D,PinValidationData=171234567890123}"
```
```
{
"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": {
"PinOffset": "5507"
}
}
```
# Verificar o criptograma de solicitação de autenticação (ARQC)
A API do criptograma de solicitação de autenticação de verificação é usada para verificar o [ARQC](terminology.md#terms.arqc). A geração do ARQC está fora do escopo da criptografia de AWS pagamento e normalmente é realizada em um cartão com chip EMV (ou equivalente digital, como carteira móvel) durante o período de autorização da transação. Um ARQC é exclusivo para cada transação e tem como objetivo mostrar criptograficamente a validade do cartão e garantir que os dados da transação correspondam exatamente à transação atual (esperada).
AWS A criptografia de pagamento fornece uma variedade de opções para validar o ARQC e gerar valores ARPC opcionais, incluindo aqueles definidos no [EMV 4.4 Livro 2](https://www.emvco.com/specifications/?post_id=80377) e outros esquemas usados pela Visa e pela Mastercard. Para obter uma lista completa de todas as opções disponíveis, consulte a VerifyCardValidationData seção no [Guia da API](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html).
Os criptogramas ARQC normalmente requerem as seguintes entradas (embora isso possa variar de acordo com a implementação):
+ [PAN](terminology.md#terms.pan) - Especificado no PrimaryAccountNumber campo
+ [Número de sequência PAN (PSN)](terminology.md#terms.psn) - especificado no campo PanSequenceNumber
+ Método de derivação de chave, como Chave de sessão comum (CSK) - especificado no SessionKeyDerivationAttributes
+ Modo de derivação de chave mestra (como EMV Opção A) - Especificado no MajorKeyDerivationMode
+ Dados da transação - uma sequência de vários dados de transação, terminal e cartão, como valor e data - especificados no TransactionData campo
+ [Chave mestra do emissor](terminology.md#terms.imk) - a chave mestra usada para derivar a chave de criptograma (AC) usada para proteger transações individuais e especificada no campo KeyIdentifier
**Topics**
+ [Construir dados de transação](#w2aac15c25c13)
+ [Preenchimento de dados da transação](#w2aac15c25c15)
+ [Exemplos](#w2aac15c25c17)
## Construir dados de transação
O conteúdo exato (e a ordem) do campo de dados da transação variam de acordo com a implementação e o esquema de rede, mas os campos mínimos recomendados (e a sequência de concatenação) são definidos no [EMV 4.4 Livro 2, Seção 8.1.1](https://www.emvco.com/specifications/?post_id=80377) - Seleção de dados. Se os três primeiros campos forem valor (17,00), outro valor (0,00) e país de compra, isso resultaria nos dados da transação começando da seguinte forma:
+ 000000001700: quantidade: 12 posições decimais implícitas de dois dígitos
+ 000000000000: outro valor: 12 posições implícitas decimais de dois dígitos
+ 0124: código de país de quatro dígitos
+ Dados da transação de saída (parcial): 0000000017000000000000000124
## Preenchimento de dados da transação
Os dados da transação devem ser preenchidos antes de serem enviados para o serviço. A maioria dos esquemas usa preenchimento ISO 9797 Método 2, em que uma string hexadecimal é anexada por hexadecimal 80 seguido por 00 até que o campo seja um múltiplo do tamanho do bloco de criptografia; 8 bytes ou 16 caracteres para TDES e 16 bytes ou 32 caracteres para AES. A alternativa (método 1) não é tão comum, mas usa somente 00 como caracteres de preenchimento.
### Preenchimento ISO 9797 Método 1
Sem preenchimento: 00000000170000000000000008400080008000084016051700000000093800000B03011203 (74 caracteres ou 37 bytes)
Com preenchimento: 00000000170000000000000008400080008000084016051700000000093800000B03011203**000000** (80 caracteres ou 40 bytes)
### Preenchimento ISO 9797 Método 2
Sem preenchimento: 00000000170000000000000008400080008000084016051700000000093800000B1F220103000000 (80 caracteres ou 40 bytes)
Com preenchimento: 00000000170000000000000008400080008000084016051700000000093800000B1F220103000000**8000000000000000** (88 caracteres ou 44 bytes)
## Exemplos
### Visto CVN10
**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 ARCQ (Criptograma de Solicitação de Autorização) 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"
}
```
### Visa CVN18 e Visa CVN22
**Example**
Neste exemplo, validaremos um ARQC gerado usando Visa ou. CVN18 CVN22 As operações criptográficas são as mesmas entre CVN18 e CVN22 , mas os dados contidos nos dados da transação variam. Em comparação com CVN10, um criptograma completamente diferente é gerado mesmo com as mesmas entradas.
Se a criptografia AWS de pagamento for capaz de validar o ARQC, um http/200 será retornado. Se o ARCQ não for validado, ele retornará um http/400.
```
$ 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 00000000170000000000000008400080008000084016051700000000093800000B1F22010300000000000 \
00000000000000000000000000000000000000000008000000000000000
--session-key-derivation-attributes='{"EmvCommon":{"ApplicationTransactionCounter":"000B", \
"PanSequenceNumber":"01","PrimaryAccountNumber":"9137631040001422"}}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4"
}
```
# Gerar e verificar MAC
Os Message Authentication Codes (MAC – códigos de autenticação de mensagens) são normalmente usados para autenticar a integridade de uma mensagem (independentemente de ela ter sido modificada). Hashes criptográficos, como HMAC (Código de Autenticação de Mensagem Baseado em Hash), CBC-MAC e CMAC (Código de Autenticação de Mensagem Baseado em Cifra) fornecem garantia adicional ao remetente do MAC ao utilizar criptografia. O HMAC é baseado em funções de hash, enquanto o CMAC é baseado em cifras de bloco. O serviço também oferece suporte aos ISO9797 algoritmos 1 e 3, que são tipos de CBC-MACs.
Todos os algoritmos MAC deste serviço combinam uma função hash criptográfica e uma chave secreta compartilhada. Eles usam uma mensagem e uma chave secreta, como o material de chave em uma chave, e retornam uma tag ou MAC exclusivo. Se até mesmo um caractere da mensagem mudar, ou se a chave secreta mudar, a tag resultante será totalmente diferente. Ao exigir uma chave secreta, a criptografia MACs também fornece autenticidade; é impossível gerar um mac idêntico sem a chave secreta. Às vezes, as criptográficas MACs são chamadas de assinaturas simétricas, porque funcionam como assinaturas digitais, mas usam uma única chave para assinatura e verificação.
AWS A criptografia de pagamento suporta vários tipos de MACs:
**ISO9797 ALGORITMO 1**
Indicado por `KeyUsage` de \$1. ISO9797 ALGORITHM1 Se o campo não for um múltiplo do tamanho do bloco (8 bytes/16 caracteres hexadecimais para TDES, 16 bytes/32 caracteres para AES), a criptografia de pagamento aplicará automaticamente o Método de preenchimento 1. AWS ISO9797 Se outros métodos de preenchimento forem necessários, você poderá aplicá-los antes de ligar para o serviço.
**ISO9797 ALGORITMO 3 (MAC de varejo)**
Indicado por `KeyUsage` de \$1. ISO9797 ALGORITHM3 As mesmas regras de preenchimento se aplicam ao Algoritmo 1.
**ISO9797 ALGORITMO 5 (CMAC)**
Indicado por de \$1M6\$1ISO\$19797\$15\$1CMAC\$1KEY `KeyUsage` TR31
**HMAC**
Indicado por `KeyUsage` TR31 \$1M7\$1HMAC\$1KEY incluindo HMAC\$1, HMAC\$1, HMAC\$1 e HMAC\$1 SHA224 SHA256 SHA384 SHA512
**AS28054.4.1 MAC**
Indicado por de `KeyUsage` \$1M0\$1ISO\$116609\$1MAC\$1KEY. TR31 Para obter mais detalhes sobre AS2805, consulte [AS2805](advanced.regional.as2805.md)
**MACARRÃO ESVAZIADO**
O DUKPT MAC é normalmente usado para confirmar a origem e a carga útil dos terminais de pagamento de mensagens to/from . Ele deriva uma chave usando técnicas de derivação DUKPT e, em seguida, executa o MAC. As chaves usadas com essa opção são indicadas por um de `KeyUsage` \$1B0\$1BASE\$1DERIVATION\$1KEY TR31.
**EMV MAC**
O EMV MAC é normalmente chamado de chave de integridade na documentação do EMV. Ele deriva uma chave usando técnicas de derivação EMV e, em seguida, utiliza \$1 internamente. ISO9797 ALGORITHM3 Normalmente é usado para enviar scripts do emissor para um cartão com chip para reprogramação. As chaves usadas com essa opção são indicadas por um de `KeyUsage` \$1E2\$1EMV\$1MKEY\$1INTEGRITY TR31. Se você estiver enviando um script e atualizando um PIN offline, verifique [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange)se ele executa essas duas operações.
**Topics**
+ [Gerar MAC](generate-mac.md)
+ [Verificar MAC](verify-mac.md)
# Gerar MAC
A API Generate MAC é usada para autenticar dados relacionados ao cartão, como rastrear dados de uma tarja magnética do cartão, usando chaves criptográficas conhecidas para gerar um MAC (Código de Autenticação de Mensagens) para validação de dados entre as partes emissoras e receptoras. Os dados usados para gerar MACs incluem dados de mensagens, chaves secretas de criptografia MAC e algoritmo MAC para gerar um valor MAC exclusivo para transmissão. A parte receptora do MAC usará os mesmos dados da mensagem MAC, chave de criptografia MAC e algoritmo para reproduzir outro valor MAC para comparação e autenticação de dados. Se qualquer caractere da mensagem for alterado ou a chave MAC usada para verificação não for idêntica, o valor MAC resultante será diferente. A API é compatível com o Algoritmo 1 do ISO 9797-1 e o Algoritmo 3 do ISO 9797-1 MAC (usando uma chave MAC estática e uma chave DUKPT derivada), chaves de criptografia HMAC e EMV MAC para essa operação.
O valor de entrada para `message-data` devem ser dados hexBinary.
Para obter mais informações sobre todas as opções dessa API, consulte [GenerateMac[VerifyMac](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyMac.html)](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMac.html)e.
O parâmetro opcional mac-length permite que você trunque o valor de saída (embora isso também possa ser feito dentro do seu código). Um comprimento de 8 se refere a 8 bytes ou 16 caracteres hexadecimais.
As chaves MAC podem ser criadas com criptografia AWS de pagamento por chamada [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)ou importadas por chamada [ImportKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html).
**nota**
Os algoritmos CMAC e HMAC não exigem preenchimento. Todos os outros exigem que os dados sejam preenchidos ao tamanho do bloco do algoritmo, que é múltiplo de 8 bytes (16 caracteres hexadecimais) para TDES e 16 bytes (32 caracteres hexadecimais) para AES.
**Topics**
+ [Gerar HMAC](#generate-mac-hmac)
+ [Gere MAC usando o Algoritmo 3 do ISO 9797-1](#generate-mac-iso9797-alg3)
+ [Gere MAC usando CMAC](#generate-mac-cmac)
+ [Gere MAC usando DUKPT CMAC](#generate-mac-dukpt-cmac)
## Gerar HMAC
Neste exemplo, geraremos um HMAC (Código de autenticação de mensagens baseado em hash) para autenticação de dados do cartão usando o algoritmo HMAC `HMAC_SHA256` e a chave de criptografia HMAC. A chave deve estar KeyUsage configurada como `TR31_M7_HMAC_KEY` e KeyModesOfUse para`Generate`. O comprimento do hash (por exemplo, 256) é definido quando a chave é criada e não pode ser modificada.
O parâmetro opcional mac-length reduzirá o MAC de saída, embora isso também possa ser executado fora do serviço. Esse valor está em bytes, portanto, um valor de 16 esperará uma string hexadecimal de comprimento 32.
**Example**
```
$ aws payment-cryptography-data generate-mac \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6 \
--message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" \
--generation-attributes Algorithm=HMAC
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6",
"KeyCheckValue": "2976E7",
"Mac": "ED87F26E961C6D0DDB78DA5038AA2BDDEA0DCE03E5B5E96BDDD494F4A7AA470C"
}
```
## Gere MAC usando o Algoritmo 3 do ISO 9797-1
Neste exemplo, geraremos um MAC usando o Algoritmo 3 do ISO 9797-1 (MAC de varejo) para autenticação de dados do cartão. A chave deve estar KeyUsage configurada como `TR31_M3_ISO_9797_3_MAC_KEY` e KeyModesOfUse para`Generate`.
**Example**
```
$ aws payment-cryptography-data generate-mac \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/kwapwa6qaifllw2h \
--message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" \
--generation-attributes="Algorithm=ISO9797_ALGORITHM3"
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/kwapwa6qaifllw2h",
"KeyCheckValue": "2976EA",
"Mac": "A8F7A73DAF87B6D0"
}
```
## Gere MAC usando CMAC
O CMAC é mais comumente usado quando as chaves são AES, mas também suporta TDES. Neste exemplo, geraremos um MAC usando o CMAC (ISO 9797-1 Algorithm 5) para autenticação de dados do cartão com uma chave AES. A chave deve estar KeyUsage configurada como `TR31_M6_ISO_9797_5_CMAC_KEY` e KeyModesOfUse para`Generate`.
**Example**
```
$ aws payment-cryptography-data generate-mac \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi \
--message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" \
--generation-attributes Algorithm="CMAC"
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "C1EB8F",
"Mac": "1F8C36E63F91E4E93DF7842BF5E2E5F7"
}
```
## Gere MAC usando DUKPT CMAC
Neste exemplo, geraremos um MAC usando DUKPT (Derived Unique Key Per Transaction) com CMAC para autenticação de dados do cartão. A chave deve ter sido KeyUsage definida como verdadeira `TR31_B0_BASE_DERIVATION_KEY` e KeyModesOfUse `DeriveKey` definida como verdadeira. As chaves DUKPT derivam uma chave exclusiva para cada transação usando uma chave de derivação básica (BDK) e um número de série da chave (KSN).
**Example**
```
$ aws payment-cryptography-data generate-mac --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6 --message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" --generation-attributes="DukptCmac={KeySerialNumber="932A6E954ABB32DD00000001",Direction=BIDIRECTIONAL}"
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6",
"KeyCheckValue": "C1EB8F"
}
```
# Verificar MAC
A API de verificação de MAC é usada para verificar o MAC (Código de autenticação de mensagens) para autenticação de dados relacionados a cartões. Ela deve usar a mesma chave de criptografia usada durante a geração do MAC para reproduzir o valor do MAC para autenticação. A chave de criptografia MAC pode ser criada com criptografia AWS de pagamento por chamada [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)ou importada por chamada [ImportKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html). A API suporta chaves de criptografia DUKPT MAC, HMAC e EMV MAC para essa operação.
Se o valor for verificado, o parâmetro de resposta `MacDataVerificationSuccessful` retornará `Http/200`, caso contrário, `Http/400` com uma mensagem indicando que `Mac verification failed`.
**Topics**
+ [Verifique o HMAC](#verify-mac-hmac)
+ [Verifique o MAC usando o DUKPT CMAC](#verify-mac-dukpt-cmac)
## Verifique o HMAC
Neste exemplo, verificaremos um HMAC (Código de autenticação de mensagens baseado em hash) para autenticação de dados do cartão usando o algoritmo HMAC `HMAC_SHA256` e a chave de criptografia HMAC. A chave deve ter sido KeyUsage definida como verdadeira `TR31_M7_HMAC_KEY` e KeyModesOfUse `Verify` definida como verdadeira.
**Example**
```
$ aws payment-cryptography-data verify-mac \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6 \
--message-data "3b343038383439303031303733393431353d32343038323236303030373030303f33" \
--mac ED87F26E961C6D0DDB78DA5038AA2BDDEA0DCE03E5B5E96BDDD494F4A7AA470C \
--verification-attributes Algorithm=HMAC_SHA256
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6",
"KeyCheckValue": "2976E7"
}
```
## Verifique o MAC usando o DUKPT CMAC
Neste exemplo, verificaremos um MAC usando DUKPT (Derived Unique Key Per Transaction) com CMAC para autenticação de dados do cartão. A chave deve ter sido KeyUsage definida como verdadeira `TR31_B0_BASE_DERIVATION_KEY` e KeyModesOfUse `DeriveKey` definida como verdadeira. As chaves DUKPT derivam uma chave exclusiva para cada transação usando uma chave de derivação básica (BDK) e um número de série da chave (KSN). O valor de DukptKeyVariant deve corresponder entre o remetente e o destinatário. REQUEST normalmente será usado do terminal ao back-end, VERIFY do back-end ao terminal e BIDIRECTIONAL quando uma única chave é usada nas duas direções.
**Example**
```
$ aws payment-cryptography-data verify-mac \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi \
--message-data "3b343038383439303031303733393431353d32343038323236303030373030303f33" \
--mac D8E804EE74BF1D909A2C01C0BDE8EF34 \
--verification-attributes DukptCmac='{"KeySerialNumber":"932A6E954ABB32DD00000001","DukptKeyVariant":"BIDIRECTIONAL"}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "C1EB8F"
}
```
# Chaves válidas para operações criptográficas
Certas chaves podem ser usadas apenas para operações específicas. Além disso, algumas operações podem limitar os principais modos de uso das chaves. Consulte a tabela a seguir para ver as combinações permitidas.
**nota**
Certas combinações, embora permitidas, podem criar situações inutilizáveis, como gerar códigos CVV `(generate)`, mas não conseguir verificá-los `(verify)`.
**Topics**
+ [GenerateCardData](#w2aac15c31b9)
+ [VerifyCardData](#w2aac15c31c11)
+ [GeneratePinData (para VISA/ABA esquemas)](#w2aac15c31c15)
+ [GeneratePinData (para`IBM3624`)](#w2aac15c31c17)
+ [VerifyPinData (para VISA/ABA esquemas)](#w2aac15c31c21)
+ [VerifyPinData (para`IBM3624`)](#w2aac15c31c23)
+ [Descriptografar dados](#w2aac15c31c27)
+ [Criptografar dados](#w2aac15c31c33)
+ [Traduzir dados de PIN](#w2aac15c31c39)
+ [Gerar/verificar MAC](#crypto-ops-validkeys.generatemac)
+ [GenerateMacEmvPinChange](#crypto-ops-validkeys.generatemacemvpinchange)
+ [VerifyAuthRequestCryptogram](#w2aac15c31c51)
+ [Chave de importação/exportação](#crypto-ops-validkeys.importexport)
+ [Tipos de chave não utilizados](#w2aac15c31c57)
## GenerateCardData
| Endpoint de API | Operação criptográfica ou algoritmo | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- | --- |
| GenerateCardData | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1C0\$1CHAVE DE VERIFICAÇÃO DO CARTÃO | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 Generate = true \$1,\$1 Generate = true, Verify = true \$1 |
| GenerateCardData | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1C0\$1CHAVE DE VERIFICAÇÃO DO CARTÃO | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 Generate = true \$1,\$1 Generate = true, Verify = true \$1 |
| GenerateCardData | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E6\$1EMV\$1MKEY\$1OUTROS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 DeriveKey = verdadeiro\$1 |
| GenerateCardData | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E4\$1EMV\$1MKEY\$1DYNAMIC\$1NUMBERS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 DeriveKey = verdadeiro\$1 |
| GenerateCardData | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E6\$1EMV\$1MKEY\$1OUTROS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 DeriveKey = verdadeiro\$1 |
## VerifyCardData
| Operação criptográfica ou algoritmo | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1C0\$1CHAVE DE VERIFICAÇÃO DO CARTÃO | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 Generate = true \$1,\$1 Generate = true, Verify = true \$1 |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1C0\$1CHAVE DE VERIFICAÇÃO DO CARTÃO | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 Generate = true \$1,\$1 Generate = true, Verify = true \$1 |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E6\$1EMV\$1MKEY\$1OUTROS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 DeriveKey = verdadeiro\$1 |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E4\$1EMV\$1MKEY\$1DYNAMIC\$1NUMBERS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 DeriveKey = verdadeiro\$1 |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E6\$1EMV\$1MKEY\$1OUTROS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | \$1 DeriveKey = verdadeiro\$1 |
## GeneratePinData (para VISA/ABA esquemas)
`VISA_PIN or VISA_PIN_VERIFICATION_VALUE`
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave de criptografia de PIN | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave de geração de PIN | TR31\$1V2\$1VISA\$1PIN\$1CHAVE DE VERIFICAÇÃO | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## GeneratePinData (para`IBM3624`)
`IBM3624_PIN_OFFSET,IBM3624_NATURAL_PIN,IBM3624_RANDOM_PIN, IBM3624_PIN_FROM_OFFSET)`
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave de criptografia de PIN | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | Para IBM3624 \$1NATURAL\$1PIN, \$1RANDOM\$1PIN, \$1PIN\$1FROM\$1OFFSET IBM3624 IBM3624 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) Para IBM3624 \$1PIN\$1OFFSET [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave de geração de PIN | TR31\$1V1\$1 \$1PIN\$1CHAVE DE VERIFICAÇÃO IBM3624 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## VerifyPinData (para VISA/ABA esquemas)
`VISA_PIN`
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave de criptografia de PIN | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave de geração de PIN | TR31\$1V2\$1VISA\$1PIN\$1CHAVE DE VERIFICAÇÃO | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## VerifyPinData (para`IBM3624`)
`IBM3624_PIN_OFFSET,IBM3624_NATURAL_PIN,IBM3624_RANDOM_PIN, IBM3624_PIN_FROM_OFFSET)`
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave de criptografia de PIN | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | Para IBM3624 \$1NATURAL\$1PIN, \$1RANDOM\$1PIN, \$1PIN\$1FROM\$1OFFSET IBM3624 IBM3624 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave de verificação de PIN | TR31\$1V1\$1 \$1PIN\$1CHAVE DE VERIFICAÇÃO IBM3624 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## Descriptografar dados
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| DUKPT | TR31\$1B0\$1BASE\$1DERIVATION\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| EMV | TR31\$1E1\$1EMV\$1MKEY\$1CONFIDENCIALIDADE TR31\$1E6\$1EMV\$1MKEY\$1OUTROS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| RSA | TR31\$1D1\$1CHAVE\$1ASSIMÉTRICA PARA CRIPTOGRAFIA DE DADOS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chaves simétricas | TR31\$1D0\$1CHAVE DE CRIPTOGRAFIA DE DADOS SIMÉTRICA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## Criptografar dados
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| DUKPT | TR31\$1B0\$1BASE\$1DERIVATION\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| EMV | TR31\$1E1\$1EMV\$1MKEY\$1CONFIDENCIALIDADE TR31\$1E6\$1EMV\$1MKEY\$1OUTROS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| RSA | TR31\$1D1\$1CHAVE\$1ASSIMÉTRICA PARA CRIPTOGRAFIA DE DADOS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chaves simétricas | TR31\$1D0\$1CHAVE DE CRIPTOGRAFIA DE DADOS SIMÉTRICA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## Traduzir dados de PIN
| Direction | Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- | --- |
| Fonte de dados de entrada | DUKPT | TR31\$1B0\$1BASE\$1DERIVATION\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Fonte de dados de entrada | Não-DUKPT (PEK, AWK, IWK etc) | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Destino de dados de saída | DUKPT | TR31\$1B0\$1BASE\$1DERIVATION\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Destino de dados de saída | Não DUKPT (PEK, IWK, AWK etc) | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## Gerar/verificar MAC
As chaves MAC são usadas para criar hashes criptográficos message/body de vários dados. Não é recomendável criar uma chave com modos de uso limitados, pois você não conseguirá realizar a operação correspondente. No entanto, você pode usar import/export uma chave com apenas uma operação se o outro sistema for destinado a executar a outra metade do par de operações.
| Uso de chave permitido | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave MAC | TR31\$1M1\$1ISO\$19797\$11\$1MAC\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave MAC (MAC de varejo) | TR31\$1M1\$1ISO\$19797\$13\$1MAC\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave MAC (CMAC) | TR31\$1M6\$1ISO\$19797\$15\$1CHAVE CMAC | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave MAC (HMAC) | TR31CHAVE \$1M7\$1HMAC | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave MAC (AS2805) | TR31\$1M0\$1ISO\$116609\$1MAC\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## GenerateMacEmvPinChange
GenerateMacEmvPinChange combina geração de MAC e criptografia de PIN para operações de alteração de PIN offline do EMV. Essa operação requer dois tipos de chave diferentes: uma chave de integridade para geração de MAC e uma chave de confidencialidade para criptografia de PIN.
| Tipo de chave | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave de integridade de mensagens seguras | TR31\$1E2\$1EMV\$1MKEY\$1INTEGRITY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave de confidencialidade de mensagens seguras | TR31\$1E1\$1EMV\$1MKEY\$1CONFIDENCIALIDADE | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| PIN PEK atual (chave de criptografia PIN) | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Novo PIN PEK (chave de criptografia PIN) | TR31\$1P0\$1PIN\$1CHAVE DE CRIPTOGRAFIA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave ARQC Aplica-se apenas aos esquemas de derivação Visa e Amex. | TR31\$1E0\$1EMV\$1MKEY\$1APP\$1CRIPTOGRAMAS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## VerifyAuthRequestCryptogram
| Uso de chave permitido | Opção de EMV | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | TR31\$1E0\$1EMV\$1MKEY\$1APP\$1CRIPTOGRAMAS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## Chave de importação/exportação
| Tipo de operação | Uso de chave permitido | Algoritmo de chave permitido | Combinação permitida dos principais modos de uso |
| --- | --- | --- | --- |
| Chave de embrulho TR-31 | TR31\$1K1\$1KEY\$1BLOCK\$1PROTECTION\$1KEY TR31\$1K0\$1KEY\$1ENCRYPTION\$1KEY | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Importação de CA confiável | TR31\$1S0\$1CHAVE ASSIMÉTRICA PARA ASSINATURA DIGITAL | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Importação de certificado de chave pública para criptografia assimétrica | TR31\$1D1\$1CHAVE\$1ASSIMÉTRICA PARA CRIPTOGRAFIA DE DADOS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
| Chave usada para algoritmos de concordância chave, como ECDH | TR31\$1K3\$1CHAVE ASSIMÉTRICA POR ACORDO DE CHAVE | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) |
## Tipos de chave não utilizados
Os seguintes tipos de chave não são usados atualmente pela criptografia AWS de pagamento:
+ TR31\$1P1\$1PIN\$1GENERATION\$1KEY