Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonctions générales
**Topics**
+ [Générez une épingle aléatoire et le PVV associé, puis vérifiez la valeur](use-cases-issuers.generalfunctions.pvv.md)
+ [Générer ou vérifier un CVV pour une carte donnée](use-cases-issuers.generalfunctions.cvv.md)
+ [Générer ou vérifier une CVV2 pour une carte spécifique](use-cases-issuers.generalfunctions.cvv2.md)
+ [Générer ou vérifier un iCVV pour une carte spécifique](use-cases-issuers.generalfunctions.icvv.md)
+ [Vérifiez un ARQC EMV et générez un ARPC](use-cases-issuers.generalfunctions.arqc.md)
+ [Générer et vérifier un MAC EMV](use-cases-issuers.generalfunctions.emvmac.md)
+ [Générer un MAC EMV pour le changement de code PIN](use-cases-issuers.generalfunctions.emvpinchange.md)
# Générez une épingle aléatoire et le PVV associé, puis vérifiez la valeur
**Topics**
+ [Créez la ou les clés](#use-cases-issuers.generalfunctions.pvv.setup)
+ [Générez un code PIN aléatoire, générez le PVV et renvoyez le code PIN et le PVV cryptés](#use-cases-issuers.generalfunctions.pvv.generate)
+ [Valider le code PIN crypté en utilisant la méthode PVV](#use-cases-issuers.generalfunctions.pvv.verify)
## Créez la ou les clés
Pour générer un code PIN aléatoire et le code [PVV](terminology.md#terms.pvv), vous aurez besoin de deux clés : une [clé de vérification du code PIN (PVK)](terminology.md#terms.pvk) pour générer le code PIN et une [clé de cryptage du code PIN](terminology.md#terms.pek) pour chiffrer le code PIN. Le code PIN lui-même est généré de manière aléatoire en toute sécurité dans le service et n'est lié cryptographiquement à aucune des clés.
Le PGK doit être une clé de l'algorithme TDES\$12KEY basé sur l'algorithme PVV lui-même. Un PEK peut être TDES\$12KEY, TDES\$13KEY ou AES\$1128. Dans ce cas, étant donné que le PEK est destiné à un usage interne au sein de votre système, AES\$1128 serait un bon choix. Si un PEK est utilisé pour échanger avec d'autres systèmes (par exemple, des réseaux de cartes, des acquéreurs ATMs) ou s'il est déplacé dans le cadre d'une migration, TDES\$12KEY peut être le choix le plus approprié pour des raisons de compatibilité.
### Créez le PEK
```
$ aws payment-cryptography create-key \
--exportable
--key-attributes KeyAlgorithm=AES_128,KeyUsage=TR31_P0_PIN_ENCRYPTION_KEY,\
KeyClass=SYMMETRIC_KEY,\
KeyModesOfUse='{Encrypt=true,Decrypt=true,Wrap=true,Unwrap=true}' --tags='[{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/ivi5ksfsuplneuyt. Vous en aurez besoin à l'étape suivante.
### Créez le PVK
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_V2_VISA_PIN_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/ov6icy4ryas4zcza. Vous en aurez besoin à l'étape suivante.
## Générez un code PIN aléatoire, générez le PVV et renvoyez le code PIN et le PVV cryptés
**Example**
Dans cet exemple, nous allons générer un nouveau code PIN (aléatoire) à 4 chiffres dont les sorties seront chiffrées `PIN block` (PinData. PinBlock) et a `PVV` (PinData. VerificationValue). Les entrées principales sont `PAN` le format `Pin Verification Key` (également connu sous le nom de clé de génération de code PIN) `Pin Encryption Key` et le format [PIN Block](terminology.md#terms.pinblock).
Cette commande nécessite que la clé soit de type`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"
}
}
```
## Valider le code PIN crypté en utilisant la méthode PVV
**Example**
Dans cet exemple, nous allons valider un code PIN pour un PAN donné. Le code PIN est généralement fourni par le titulaire de la carte ou l'utilisateur au moment de la transaction à des fins de validation et est comparé à la valeur enregistrée (l'entrée du titulaire de la carte est fournie sous forme de valeur cryptée par le terminal ou un autre fournisseur en amont). Afin de valider cette entrée, les valeurs suivantes seront également fournies lors de l'exécution : le code PIN crypté, la clé utilisée pour chiffrer le code PIN d'entrée (souvent appelé [IWK](terminology.md#terms.iwk)) `PAN` et la valeur par rapport à laquelle vérifier (un `PVV` ou`PIN offset`).
Si AWS Payment Cryptography parvient à valider le code PIN, un http/200 est renvoyé. Si le code PIN n'est pas validé, il renverra un http/400.
```
$ aws payment-cryptography-data verify-pin-data --verification-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --verification-attributes VisaPin="{PinVerificationKeyIndex=1,VerificationValue=5507}" --encrypted-pin-block AC17DC148BDA645E
```
```
{
"VerificationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2",
"VerificationKeyCheckValue": "7F2363",
"EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
"EncryptionKeyCheckValue": "7CC9E2",
}
```
# Générer ou vérifier un CVV pour une carte donnée
Le [CVV](terminology.md#terms.cvv) ou CVV1 est une valeur traditionnellement intégrée à la bande magnétique d'une carte. Ce n'est pas la même chose que CVV2 (visible pour le titulaire de la carte et pour les achats en ligne).
La première étape consiste à créer une clé. Pour ce didacticiel, vous allez créer une clé [CVK](terminology.md#terms.cvk) 3DES double longueur (2KEY TDES).
**Note**
CVV CVV2 et iCVV utilisent tous des algorithmes similaires, voire identiques, mais font varier les données d'entrée. Ils utilisent tous le même type de clé TR31 \$1C0\$1CARD\$1VERIFICATION\$1KEY, mais il est recommandé d'utiliser des clés distinctes pour chaque utilisation. Ils peuvent être distingués à l'aide de and/or balises alias, comme dans l'exemple ci-dessous.
## Créez la clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVV"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/r52o3wbqxyf6qlqr. Vous en aurez besoin à l'étape suivante.
## Générer un CVV
**Example**
Dans cet exemple, nous allons générer un [CVV](terminology.md#terms.cvv) pour un PAN donné avec les entrées suivantes : 121 comme code de `PAN` service (tel que défini par ISO/IEC 7813) et date d'expiration de la carte.
Pour tous les paramètres disponibles, voir [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) dans le guide de référence de l'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"
}
```
## Valider le CVV
**Example**
Dans cet exemple, nous allons vérifier un [CVV](terminology.md#terms.cvv) pour un PAN donné en saisissant un CVK, un code de service de 121`PAN`, la date d'expiration de la carte et le CVV fourni lors de la transaction à valider.
Pour tous les paramètres disponibles, voir [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) dans le guide de référence de l'API.
Le CVV n'est pas une valeur saisie par l'utilisateur (comme CVV2) mais il est généralement intégré à une bande magnétique. Il convient de déterminer s'il doit toujours être validé lorsqu'il est fourni.
```
$ 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"
}
```
# Générer ou vérifier une CVV2 pour une carte spécifique
[CVV2](terminology.md#terms.cvv2)est une valeur qui est traditionnellement indiquée au dos d'une carte et qui est utilisée pour les achats en ligne. Pour les cartes virtuelles, elles peuvent également être affichées sur une application ou un écran. Sur le plan cryptographique, c'est le même que CVV1 , mais avec une valeur de code de service différente.
## Créez la clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVV2"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/7f7g4spf3xcklhzu. Vous en aurez besoin à l'étape suivante.
## Générez un CVV2
**Example**
Dans cet exemple, nous allons générer un [CVV2](terminology.md#terms.cvv2)pour un PAN donné avec des entrées indiquant la date d'expiration de la carte `PAN` et la date d'expiration de la carte.
Pour tous les paramètres disponibles, voir [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) dans le guide de référence de l'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"
}
```
## Valider un CVV2
**Example**
Dans cet exemple, nous allons vérifier un [CVV2](terminology.md#terms.cvv2)pour un PAN donné en saisissant un CVK, la date d'expiration de la carte `PAN` et le CVV fournis lors de la transaction à valider.
Pour tous les paramètres disponibles, voir [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) dans le guide de référence de l'API.
CVV2 et les autres entrées sont des valeurs saisies par l'utilisateur. Ce n'est donc pas nécessairement le signe d'un problème que cela échoue périodiquement à valider.
```
$ 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"
}
```
# Générer ou vérifier un iCVV pour une carte spécifique
[iCVV](terminology.md#terms.icvv) utilise le même algorithme que CVV/ CVV2 mais iCVV est intégré dans une carte à puce. Son code de service est 999.
## Créez la clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_C0_CARD_VERIFICATION_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"ICVV"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/c7dsi763r6s7lfp3. Vous en aurez besoin à l'étape suivante.
## Générer un iCVV
**Example**
Dans cet exemple, nous allons générer un [iCVV](terminology.md#terms.icvv) pour un PAN donné avec les entrées suivantes : un code de `PAN` service (tel que défini par ISO/IEC 7813) de 999 et la date d'expiration de la carte.
Pour tous les paramètres disponibles, voir [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) dans le guide de référence de l'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"
}
```
## Valider iCVV
**Example**
Pour la validation, les entrées sont le CVK`PAN`, un code de service 999, la date d'expiration de la carte et l'iCVV fourni lors de la transaction à valider.
Pour tous les paramètres disponibles, voir [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) dans le guide de référence de l'API.
iCVV n'est pas une valeur saisie par l'utilisateur (comme CVV2) mais est généralement intégrée à une EMV/chip carte. Il convient de déterminer s'il doit toujours être validé lorsqu'il est fourni.
```
$ 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"
}
```
# Vérifiez un ARQC EMV et générez un ARPC
L'[ARQC](terminology.md#terms.arqc) (Authorization Request Cryptogram) est un cryptogramme généré par une carte EMV (puce) et utilisé pour valider les détails de la transaction ainsi que l'utilisation d'une carte autorisée. Il intègre les données de la carte, du terminal et de la transaction elle-même.
Au moment de la validation sur le backend, les mêmes entrées sont fournies à AWS Payment Cryptography, le cryptogramme est recréé en interne et celui-ci est comparé à la valeur fournie avec la transaction. En ce sens, il est similaire à un MAC. [Le livre 2 de l'EMV 4.4](https://www.emvco.com/specifications/?post_id=80377) définit trois aspects de cette fonction : les méthodes de dérivation de clés (connues sous le nom de clé de session commune - CSK) pour générer des clés de transaction uniques, une charge utile minimale et les méthodes de génération d'une réponse (ARPC).
Les schémas de cartes individuels peuvent spécifier des champs transactionnels supplémentaires à intégrer ou l'ordre dans lequel ces champs apparaissent. D'autres schémas de dérivation spécifiques au schéma (généralement obsolètes) existent également et sont abordés ailleurs dans cette documentation.
Pour plus d'informations, consultez [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)le guide de l'API.
## Créez la clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN18"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/pw3s6nl62t5ushfk. Vous en aurez besoin à l'étape suivante.
## Générer un ARQC
L'ARQC est généré exclusivement par une carte EMV. En tant que telle, la cryptographie des AWS paiements ne permet pas de générer une telle charge utile. À des fins de test, un certain nombre de bibliothèques sont disponibles en ligne et peuvent générer une charge utile appropriée ainsi que des valeurs connues généralement fournies par les différents schémas.
## Valider un ARQC
**Example**
Si AWS Payment Cryptography est en mesure de valider l'ARQC, un http/200 est renvoyé. Un ARPC (réponse) peut éventuellement être fourni et inclus dans la réponse une fois l'ARQC validé.
```
$ 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"
}
```
# Générer et vérifier un MAC EMV
EMV MAC est un MAC utilisant l'entrée d'une clé dérivée d'EMV, puis exécutant un MAC ISO9797 -3 (Retail) sur les données résultantes. Le MAC EMV est généralement utilisé pour envoyer des commandes à une carte EMV, telles que des scripts de déblocage.
**Note**
AWS La cryptographie des paiements ne valide pas le contenu du script. Veuillez consulter le manuel de votre schéma ou de votre carte pour plus de détails sur les commandes spécifiques à inclure.
Pour plus d'informations, consultez [MacAlgorithmEmv](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_MacAlgorithmEmv.html)le guide de l'API.
**Topics**
+ [Créez la clé](#use-cases-issuers.generalfunctions.emvmac.setup)
+ [Générer un MAC EMV](#use-cases-issuers.generalfunctions.emvmac.generate)
## Créez la clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E2_EMV_MKEY_INTEGRITY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"CVN18"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
La réponse renvoie les paramètres de la demande, y compris un ARN pour les appels suivants ainsi qu'une valeur de contrôle clé (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"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/pw3s6nl62t5ushfk. Vous en aurez besoin à l'étape suivante.
## Générer un MAC EMV
Généralement, un processus principal génère un script EMV (tel que le déblocage d'une carte), le signe à l'aide de cette commande (qui déduit une clé à usage unique spécifique à une carte en particulier), puis renvoie le MAC. Ensuite, la commande \$1 MAC est envoyée à la carte à appliquer. L'envoi de la commande à la carte ne relève pas du champ d'application de la cryptographie des AWS paiements.
**Note**
Cette commande est destinée aux commandes lorsqu'aucune donnée cryptée (telle que le code PIN) n'est envoyée. EMV Encrypt peut être combiné à cette commande pour ajouter des données chiffrées au script de l'émetteur avant d'appeler cette commande
Données du message
Les données du message incluent l'en-tête et la commande APDU. Bien que cela puisse varier selon l'implémentation, cet exemple est l'en-tête APDU pour le déblocage (84 24 00 00 08), suivi de l'ATC (0007) puis de l'ARQC de la transaction précédente (999E57 F47CACE). FD0 Le service ne valide pas le contenu de ce champ.
Mode de dérivation des clés de session
Ce champ définit le mode de génération de la clé de session. EMV\$1COMMON\$1SESSION\$1KEY est généralement utilisé pour les nouvelles implémentations, tandis que EMV2000 \$1 AMEX \$1 MASTERCARD\$1SESSION\$1KEY \$1 VISA peut également être utilisé.
MajorKeyDerivationMode
EMV définit le mode A, B ou C. Le mode A est le plus courant et la cryptographie des AWS paiements prend actuellement en charge le mode A ou le mode B.
PAN
Le numéro de compte, généralement disponible dans le champ de puce 5A ou ISO8583 le champ 2, mais peut également être extrait du système de carte.
PSN
Le numéro de séquence de la carte. S'il n'est pas utilisé, entrez 00.
SessionKeyDerivationValue
Il s'agit des données de dérivation par session. Il peut s'agir du dernier ARQC (ApplicationCryptogram) du champ 9F26 ou du dernier ATC du champ 9F36 selon le schéma de dérivation.
Remplissage
Le rembourrage est automatiquement appliqué et utilise la méthode de rembourrage 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"
}
```
# Générer un MAC EMV pour le changement de code PIN
Le changement de code PIN EMV combine deux opérations : générer un code MAC pour un script émetteur et chiffrer un nouveau code PIN pour un changement de code PIN hors ligne sur une carte à puce EMV. Cette commande n'est nécessaire que dans certains pays où le code PIN est enregistré sur la carte à puce (c'est courant dans les pays européens). Ceci est couramment utilisé lorsqu'un titulaire de carte doit changer son code PIN et que le nouveau code PIN doit être transmis de manière sécurisée à la carte avec un MAC pour vérifier l'authenticité de la commande.
**Note**
Si vous devez uniquement envoyer des commandes à la carte sans modifier le code PIN, pensez plutôt à utiliser les commandes [ARPC CSU](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyAuthRequestCryptogram.html) ou [Generate EMV MAC](use-cases-issuers.generalfunctions.emvmac.md).
Pour plus d'informations, consultez [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange.html)le guide de l'API.
## Générez un MAC EMV et un code PIN crypté pour le changement de code PIN
Cette opération nécessite deux clés : une clé d'intégrité EMV (KeyUsage: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) pour la génération de MAC et une clé de confidentialité EMV (: \$1E4\$1EMV\$1MKEY\$1CONFIDENTIALITY) pour le chiffrement par code PIN. KeyUsage TR31 Généralement, un processus principal génère un script de modification du code PIN EMV, qui inclut à la fois le MAC du script émetteur et le nouveau code PIN crypté. La commande et le code PIN chiffré sont ensuite envoyés à la carte pour mettre à jour le code PIN hors ligne. L'envoi de la commande à la carte ne relève pas du champ d'application de la cryptographie des AWS paiements.
Données du message
Les données du message incluent la commande APDU pour le script de l'émetteur. Le service ne valide pas le contenu de ce champ.
Nouveau bloc PIN crypté
Le nouveau bloc PIN crypté qui sera envoyé à la carte. Cela doit être fourni sous forme de valeur cryptée à l'aide d'une clé de cryptage par code PIN.
Nouvel identifiant PIN PEK
La clé utilisée pour chiffrer le nouveau code PIN avant qu'il ne soit transmis à cette API.
Clé d'intégrité de la messagerie sécurisée
La clé d'intégrité EMV (KeyUsage: TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY) utilisée pour la génération de MAC.
Clé de confidentialité de la messagerie sécurisée
La clé de confidentialité EMV (KeyUsage: TR31 \$1E4\$1EMV\$1MKEY\$1CONFIDENTIALITY) utilisée pour le chiffrement par code PIN.
MajorKeyDerivationMode
EMV définit le mode A, B ou C. Le mode A est le plus courant et la cryptographie des AWS paiements prend actuellement en charge le mode A ou le mode B.
Mode
Le mode de cryptage, généralement CBC pour les opérations de changement de code PIN.
PAN
Le numéro de compte, généralement disponible dans le champ de puce 5A ou ISO8583 le champ 2, mais peut également être extrait du système de carte.
PanSequenceNumber
Le numéro de séquence de la carte. S'il n'est pas utilisé, entrez 00.
ApplicationCryptogram
Il s'agit des données de dérivation par session, généralement le dernier ARQC du champ 9F26.
PinBlockLengthPosition
Spécifie l'endroit où la longueur du bloc PIN est codée. Généralement défini sur NONE. Vérifiez les spécifications de votre système de cartes en cas de doute.
PinBlockPaddingType
Spécifie le type de rembourrage pour le bloc PIN. Généralement défini sur NO\$1PADDING. Vérifiez les spécifications de votre système de cartes en cas de doute.
**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"
}
```