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 gerais
**Topics**
+ [Gere um pino aleatório e o PVV associado e, em seguida, verifique o valor](use-cases-issuers.generalfunctions.pvv.md)
+ [Gere ou verifique um CVV para um determinado cartão](use-cases-issuers.generalfunctions.cvv.md)
+ [Gere ou verifique um CVV2 para um cartão específico](use-cases-issuers.generalfunctions.cvv2.md)
+ [Gere ou verifique um iCVV para um cartão específico](use-cases-issuers.generalfunctions.icvv.md)
+ [Verifique um EMV ARQC e gere um ARPC](use-cases-issuers.generalfunctions.arqc.md)
+ [Gere e verifique um MAC EMV](use-cases-issuers.generalfunctions.emvmac.md)
+ [Gere EMV MAC para alteração de PIN](use-cases-issuers.generalfunctions.emvpinchange.md)
# Gere um pino aleatório e o PVV associado e, em seguida, verifique o valor
**Topics**
+ [Crie a (s) chave (s)](#use-cases-issuers.generalfunctions.pvv.setup)
+ [Gere um pino aleatório, gere PVV e retorne o PIN e o PVV criptografados](#use-cases-issuers.generalfunctions.pvv.generate)
+ [Valide o PIN criptografado usando o método PVV](#use-cases-issuers.generalfunctions.pvv.verify)
## Crie a (s) chave (s)
Para gerar um pino aleatório e o [PVV](terminology.md#terms.pvv), você precisará de duas chaves, uma [chave de verificação de pinos (PVK) para gerar o PVV](terminology.md#terms.pvk) e uma [chave de criptografia de pinos](terminology.md#terms.pek) para criptografar o pino. O pino em si é gerado aleatoriamente de forma segura dentro do serviço e não está relacionado criptograficamente a nenhuma das chaves.
O PGK deve ser uma chave do algoritmo TDES\$12KEY com base no próprio algoritmo PVV. Um PEK pode ser TDES\$12KEY, TDES\$13KEY ou AES\$1128. Nesse caso, como o PEK é destinado ao uso interno em seu sistema, o AES\$1128 seria uma boa escolha. Se um PEK for usado para intercâmbio com outros sistemas (por exemplo, redes de cartões, adquirentes ATMs) ou estiver sendo movido como parte de uma migração, o TDES\$12KEY pode ser a escolha mais apropriada por motivos de compatibilidade.
### Crie o PEK
```
$ aws payment-cryptography create-key \
--exportable
--key-attributes KeyAlgorithm=AES_128,KeyUsage=TR31_P0_PIN_ENCRYPTION_KEY,\
KeyClass=SYMMETRIC_KEY,\
KeyModesOfUse='{Encrypt=true,Decrypt=true,Wrap=true,Unwrap=true}' --tags='[{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
"KeyAttributes": {
"KeyUsage": "TR31_P0_PIN_ENCRYPTION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "AES_128",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "7CC9E2",
"KeyCheckValueAlgorithm": "CMAC",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/ivi5ksfsuplneuyt. Isso será necessário na próxima etapa.
### Crie o PVK
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_V2_VISA_PIN_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ov6icy4ryas4zcza",
"KeyAttributes": {
"KeyUsage": "TR31_V2_VISA_PIN_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "51A200",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/ov6icy4ryas4zcza. Isso será necessário na próxima etapa.
## Gere um pino aleatório, gere PVV e retorne o PIN e o PVV criptografados
**Example**
Neste exemplo, geraremos um novo pino (aleatório) de 4 dígitos em que as saídas serão criptografadas `PIN block` (. PinData PinBlock) e um `PVV` (pinData. VerificationValue). As entradas principais são `PAN` o `Pin Verification Key` (também conhecido como chave de geração de pinos) `Pin Encryption Key` e o formato [PIN Block](terminology.md#terms.pinblock).
Esse comando exige que a chave seja do tipo`TR31_V2_VISA_PIN_VERIFICATION_KEY`.
```
$ aws payment-cryptography-data generate-pin-data --generation-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --generation-attributes VisaPin={PinVerificationKeyIndex=1}
```
```
{
"GenerationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2",
"GenerationKeyCheckValue": "7F2363",
"EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
"EncryptionKeyCheckValue": "7CC9E2",
"EncryptedPinBlock": "AC17DC148BDA645E",
"PinData": {
"VerificationValue": "5507"
}
}
```
## Valide o PIN criptografado usando o método PVV
**Example**
Neste exemplo, validaremos um PIN para um PAN específico. O PIN normalmente é fornecido pelo titular do cartão ou pelo usuário durante o período da transação para validação e é comparado com o valor registrado (a entrada do titular do cartão é fornecida como um valor criptografado do terminal ou de outro provedor upstream). Para validar essa entrada, os seguintes valores também serão fornecidos em tempo de execução: o pino criptografado, a chave usada para criptografar o pino de entrada (geralmente chamado de [IWK](terminology.md#terms.iwk)) `PAN` e o valor a ser verificado (a ou). `PVV` `PIN offset`
Se a criptografia AWS de pagamento conseguir validar o PIN, um http/200 será retornado. Se o PIN não for validado, ela retornará um http/400.
```
$ aws payment-cryptography-data verify-pin-data --verification-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --verification-attributes VisaPin="{PinVerificationKeyIndex=1,VerificationValue=5507}" --encrypted-pin-block AC17DC148BDA645E
```
```
{
"VerificationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2",
"VerificationKeyCheckValue": "7F2363",
"EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
"EncryptionKeyCheckValue": "7CC9E2",
}
```
# Gere ou verifique um CVV para um determinado cartão
[CVV](terminology.md#terms.cvv) ou CVV1 é um valor tradicionalmente incorporado na tarja magnética de um cartão. Não é o mesmo que CVV2 (visível para o titular do cartão e para uso em compras on-line).
A primeira etapa é criar uma chave. Para este tutorial, você cria uma chave [CVK](terminology.md#terms.cvk) 3DES de comprimento duplo (2KEY TDES).
**nota**
CVV CVV2 e iCVV usam algoritmos semelhantes, se não idênticos, mas variam os dados de entrada. Todos usam o mesmo tipo de chave TR31 \$1C0\$1CARD\$1VERIFICATION\$1KEY, mas é recomendável usar chaves separadas para cada finalidade. Eles podem ser diferenciados usando and/or tags de aliases, como no exemplo abaixo.
## Crie a chave
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVV"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "DE89F9",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/r52o3wbqxyf6qlqr*. Isso será necessário na próxima etapa.
## Gere um CVV
**Example**
Neste exemplo, geraremos um [CVV](terminology.md#terms.cvv) para um determinado PAN com entradas de`PAN`, um código de serviço (conforme definido pelo ISO/IEC 7813) de 121 e a data de validade do cartão.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=121}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr",
"KeyCheckValue": "DE89F9",
"ValidationData": "801"
}
```
## Validar CVV
**Example**
Neste exemplo, verificaremos um [CVV](terminology.md#terms.cvv) para um determinado PAN com entradas de um CVK, um código de serviço de 121`PAN`, a data de validade do cartão e o CVV fornecido durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
O CVV não é um valor inserido pelo usuário (como CVV2), mas normalmente está incorporado em uma tarja magnética. Deve-se considerar se ele deve sempre ser validado quando fornecido.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=121} --validation-data 801
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/r52o3wbqxyf6qlqr",
"KeyCheckValue": "DE89F9",
"ValidationData": "801"
}
```
# Gere ou verifique um CVV2 para um cartão específico
[CVV2](terminology.md#terms.cvv2)é um valor tradicionalmente fornecido no verso de um cartão e usado para compras on-line. Para cartões virtuais, ele também pode ser exibido em um aplicativo ou tela. Criptograficamente, é o mesmo, CVV1 mas com um valor de código de serviço diferente.
## Crie a chave
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVV2"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "AEA5CD",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/7f7g4spf3xcklhzu*. Isso será necessário na próxima etapa.
## Gere um CVV2
**Example**
Neste exemplo, geraremos um [CVV2](terminology.md#terms.cvv2)para um determinado PAN com entradas `PAN` e data de validade do cartão.
Para todos os parâmetros disponíveis, consulte [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) no guia de referência da API.
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu --primary-account-number=171234567890123 --generation-attributes CardVerificationValue2='{CardExpiryDate=1127}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu",
"KeyCheckValue": "AEA5CD",
"ValidationData": "321"
}
```
## Validar um CVV2
**Example**
Neste exemplo, verificaremos um [CVV2](terminology.md#terms.cvv2)determinado PAN com entradas de um CVK, a data de validade do cartão `PAN` e o CVV fornecido durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) no guia de referência da API.
CVV2 e as outras entradas são valores inseridos pelo usuário. Dessa forma, não é necessariamente um sinal de um problema que isso falhe periodicamente em validar.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu --primary-account-number=171234567890123 --verification-attributes CardVerificationValue2='{CardExpiryDate=1127} --validation-data 321
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/7f7g4spf3xcklhzu",
"KeyCheckValue": "AEA5CD",
"ValidationData": "801"
}
```
# Gere ou verifique um iCVV para um cartão específico
O [iCVV](terminology.md#terms.icvv) usa o mesmo algoritmo que o CVV/, CVV2 mas o iCVV é incorporado dentro de um cartão com chip. Seu código de serviço é 999.
## Crie a chave
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"ICVV"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "1201FB",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/c7dsi763r6s7lfp3. Isso será necessário na próxima etapa.
## Gere um iCVV
**Example**
Neste exemplo, geraremos um [iCVV](terminology.md#terms.icvv) para um determinado PAN com entradas de`PAN`, um código de serviço (conforme definido pelo ISO/IEC 7813) de 999 e a data de validade do cartão.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3 --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3",
"KeyCheckValue": "1201FB",
"ValidationData": "532"
}
```
## Validar o iCVV
**Example**
Para validação, as entradas são CVK`PAN`, um código de serviço de 999, data de validade do cartão e o iCVV fornecido durante a transação para validação.
Para ver todos os parâmetros disponíveis, consulte [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) no guia de referência da API.
O iCVV não é um valor inserido pelo usuário (como CVV2), mas normalmente está incorporado em um EMV/chip cartão. Deve-se considerar se ele deve sempre ser validado quando fornecido.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3 --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999} --validation-data 532
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/c7dsi763r6s7lfp3",
"KeyCheckValue": "1201FB",
"ValidationData": "532"
}
```
# Verifique um EMV ARQC e gere um ARPC
[O ARQC](terminology.md#terms.arqc) (Criptograma de Solicitação de Autorização) é um criptograma gerado por um cartão EMV (chip) e usado para validar os detalhes da transação, bem como o uso de um cartão autorizado. Ele incorpora dados do cartão, do terminal e da própria transação.
No momento da validação no back-end, as mesmas entradas são fornecidas para a criptografia de AWS pagamento, o criptograma é recriado internamente e comparado com o valor fornecido com a transação. Nesse sentido, é semelhante a um MAC. O [EMV 4.4 Livro 2](https://www.emvco.com/specifications/?post_id=80377) define três aspectos dessa função: métodos de derivação de chave (conhecidos como chave de sessão comum - CSK) para gerar chaves de transação únicas, uma carga útil mínima e métodos para gerar uma resposta (ARPC).
Esquemas de cartões individuais podem especificar campos transacionais adicionais a serem incorporados ou a ordem em que esses campos aparecem. Outros esquemas de derivação específicos do esquema (geralmente obsoletos) também existem e são abordados em outra parte desta documentação.
Para obter mais informações, consulte [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)o guia da API.
## Crie a chave
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN18"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyAttributes": {
"KeyUsage": "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": false,
"Sign": false,
"Verify": false,
"DeriveKey": true,
"NoRestrictions": false
}
},
"KeyCheckValue": "08D7B4",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2024-03-07T06:41:46.648000-07:00",
"UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
## Gere um ARQC
O ARQC é gerado exclusivamente por um cartão EMV. Dessa AWS forma, a criptografia de pagamento não tem facilidade para gerar essa carga útil. Para fins de teste, várias bibliotecas estão disponíveis on-line que podem gerar uma carga útil apropriada, bem como valores conhecidos que geralmente são fornecidos pelos vários esquemas.
## Validar um ARQC
**Example**
Se a criptografia AWS de pagamento for capaz de validar o ARQC, um http/200 será retornado. Opcionalmente, um ARPC (resposta) pode ser fornecido e incluído na resposta após a validação do ARQC.
```
$ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram 61EDCC708B4C97B4 --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --major-key-derivation-mode EMV_OPTION_A --transaction-data 00000000170000000000000008400080008000084016051700000000093800000B1F2201030000000000000000000000000000000000000000000000000000008000000000000000 --session-key-derivation-attributes='{"EmvCommon":{"ApplicationTransactionCounter":"000B", "PanSequenceNumber":"01","PrimaryAccountNumber":"9137631040001422"}}' --auth-response-attributes='{"ArpcMethod2":{"CardStatusUpdate":"12345678"}}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4",
"AuthResponseValue":"2263AC85"
}
```
# Gere e verifique um MAC EMV
EMV MAC é MAC usando uma entrada de uma chave derivada de EMV e, em seguida, executando um MAC ISO9797 -3 (varejo) sobre os dados resultantes. O EMV MAC é normalmente usado para enviar comandos para uma placa EMV, como scripts de desbloqueio.
**nota**
AWS A criptografia de pagamento não valida o conteúdo do script. Consulte o manual do esquema ou da placa para obter detalhes sobre os comandos específicos a serem incluídos.
Para obter mais informações, consulte [MacAlgorithmEmv](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_MacAlgorithmEmv.html)o guia da API.
**Topics**
+ [Crie a chave](#use-cases-issuers.generalfunctions.emvmac.setup)
+ [Gere um MAC EMV](#use-cases-issuers.generalfunctions.emvmac.generate)
## Crie a chave
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E2_EMV_MKEY_INTEGRITY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN18"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
A resposta reflete os parâmetros da solicitação, incluindo um ARN para chamadas subsequentes, bem como um valor de verificação chave (KCV).
```
{
"Key": {
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyAttributes": {
"KeyUsage": "TR31_E2_EMV_MKEY_INTEGRITY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": false,
"Sign": false,
"Verify": false,
"DeriveKey": true,
"NoRestrictions": false
}
},
"KeyCheckValue": "08D7B4",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2024-03-07T06:41:46.648000-07:00",
"UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00"
}
}
```
Anote o `KeyArn` que representa a chave, por exemplo, *arn:aws:payment-cryptography:us-east- 2:111122223333:key/pw3s6nl62t5ushfk*. Isso será necessário na próxima etapa.
## Gere um MAC EMV
O fluxo típico é que um processo de back-end gera um script EMV (como desbloqueio de cartão), assina-o usando esse comando (que deriva uma chave única específica para uma placa específica) e, em seguida, retornará o MAC. Em seguida, o comando \$1 MAC é enviado para o cartão a ser aplicado. Enviar o comando para o cartão está fora do escopo da criptografia de AWS pagamento.
**nota**
Esse comando é destinado a comandos quando nenhum dado criptografado (como PIN) é enviado. O EMV Encrypt pode ser combinado com esse comando para anexar dados criptografados ao script do emissor antes de chamar esse comando.
Dados da mensagem
Os dados da mensagem incluem o cabeçalho e o comando APDU. Embora isso possa variar de acordo com a implementação, este exemplo é o cabeçalho APDU para desbloqueio (84 24 00 00 08), seguido pelo ATC (0007) e depois pelo ARQC da transação anterior (999E57 F47CACE). FD0 O serviço não valida o conteúdo desse campo.
Modo de derivação da chave de sessão
Esse campo define como a chave de sessão é gerada. O EMV\$1COMMON\$1SESSION\$1KEY geralmente é usado para as novas implementações, enquanto EMV2000 \$1 AMEX \$1 MASTERCARD\$1SESSION\$1KEY \$1 VISA também pode ser usado.
MajorKeyDerivationMode
O EMV define o modo A, B ou C. O modo A é o mais comum e a criptografia AWS de pagamento atualmente suporta o modo A ou o modo B.
PAN
O número da conta, normalmente disponível no campo de chip 5A ou ISO8583 campo 2, mas também pode ser recuperado do sistema de cartão.
PSN
O número de sequência do cartão. Se não for usado, insira 00.
SessionKeyDerivationValue
Esses são os dados de derivação por sessão. Pode ser o último ARQC (ApplicationCryptogram) do campo 9F26 ou o último ATC do 9F36, dependendo do esquema de derivação.
Padding
O preenchimento é aplicado automaticamente e usa o método de preenchimento ISO/IEC 9797-1 2.
**Example**
```
$ aws payment-cryptography-data generate-mac --message-data 84240000080007999E57FD0F47CACE --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --message-data 8424000008999E57FD0F47CACE0007 --generation-attributes EmvMac="{MajorKeyDerivationMode=EMV_OPTION_A,PanSequenceNumber='00',PrimaryAccountNumber='2235521304123282',SessionKeyDerivationMode=EMV_COMMON_SESSION_KEY,SessionKeyDerivationValue={ApplicationCryptogram='999E57FD0F47CACE'}}"
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4",
"Mac":"5652EEDF83EA0D84"
}
```
# Gere EMV MAC para alteração de PIN
A alteração do PIN EMV combina duas operações: gerar um MAC para um script do emissor e criptografar um novo PIN para alteração offline do PIN em um cartão com chip EMV. Esse comando só é necessário em alguns países onde o PIN está armazenado no cartão com chip (isso é comum em países europeus). Isso é comumente usado quando o titular do cartão precisa alterar seu PIN e o novo PIN deve ser transmitido com segurança ao cartão junto com um MAC para verificar a autenticidade do comando.
**nota**
Se você precisar apenas enviar comandos para a placa, mas não alterar o PIN, considere usar os comandos [ARPC CSU](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyAuthRequestCryptogram.html) ou [Generate EMV MAC](use-cases-issuers.generalfunctions.emvmac.md).
Para obter mais informações, consulte [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange.html)o guia da API.
## Gere EMV MAC e PIN criptografado para alteração de PIN
Essa operação requer duas chaves: uma chave de integridade EMV (: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) para geração de MAC e uma chave de confidencialidade EMV (KeyUsage: \$1E4\$1EMV\$1MKEY\$1CONFIDENTIALITY) para criptografia de PIN. KeyUsage TR31 O fluxo típico é que um processo de back-end gera um script de alteração de PIN EMV, que inclui tanto o MAC do script do emissor quanto o novo PIN criptografado. O comando e o PIN criptografado são então enviados ao cartão para atualizar o PIN offline. Enviar o comando para o cartão está fora do escopo da criptografia de AWS pagamento.
Dados da mensagem
Os dados da mensagem incluem o comando APDU para o script do emissor. O serviço não valida o conteúdo desse campo.
Novo bloco de PIN criptografado
O novo bloco de PIN criptografado que será enviado para o cartão. Isso deve ser fornecido como um valor criptografado usando uma chave de criptografia PIN.
Novo identificador PIN PEK
A chave usada para criptografar o novo PIN antes de ser passado para essa API.
Chave de integridade de mensagens seguras
A chave de integridade EMV (KeyUsage: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) usada para geração de MAC.
Chave de confidencialidade de mensagens seguras
A chave de confidencialidade EMV (KeyUsage: TR31 \$1E4\$1EMV\$1MKEY\$1CONFIDENTIALITY) usada para criptografia de PIN.
MajorKeyDerivationMode
O EMV define o Modo A, B ou C. O Modo A é o mais comum e a Criptografia de AWS Pagamento atualmente suporta o modo A ou o modo B.
Modo
O modo de criptografia, normalmente CBC para operações de alteração de PIN.
PAN
O número da conta, normalmente disponível no campo de chip 5A ou ISO8583 campo 2, mas também pode ser recuperado do sistema de cartão.
PanSequenceNumber
O número de sequência do cartão. Se não for usado, insira 00.
ApplicationCryptogram
Esses são os dados de derivação por sessão, normalmente o último ARQC do campo 9F26.
PinBlockLengthPosition
Especifica onde o comprimento do bloco PIN é codificado. Normalmente definido como NENHUM. Verifique as especificações do esquema do cartão se não tiver certeza.
PinBlockPaddingType
Especifica o tipo de preenchimento para o bloco de PIN. Normalmente definido como NO\$1PADDING. Verifique as especificações do esquema do cartão se não tiver certeza.
**Example**
```
$ aws payment-cryptography-data generate-mac-emv-pin-change \
--message-data 00A4040008A000000004101080D80500000001010A04000000000000 \
--new-encrypted-pin-block 67FB27C75580EFE7 \
--new-pin-pek-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt \
--pin-block-format ISO_FORMAT_0 \
--secure-messaging-confidentiality-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi \
--secure-messaging-integrity-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \
--derivation-method-attributes 'EmvCommon={ApplicationCryptogram=1234567890123457,MajorKeyDerivationMode=EMV_OPTION_A,Mode=CBC,PanSequenceNumber=00,PinBlockLengthPosition=NONE,PinBlockPaddingType=NO_PADDING,PrimaryAccountNumber=171234567890123}'
```
```
{
"SecureMessagingIntegrityKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"SecureMessagingIntegrityKeyCheckValue": "08D7B4",
"SecureMessagingConfidentialityKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"SecureMessagingConfidentialityKeyCheckValue": "C1EB8F",
"Mac": "5652EEDF83EA0D84",
"EncryptedPinBlock": "F1A2B3C4D5E6F7A8"
}
```