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.
# Émetteurs et processeurs d'émetteurs
Les cas d'utilisation par les émetteurs se composent généralement de quelques parties. Cette section est organisée par fonction (utilisation d'épingles, par exemple). Dans un système de production, les clés sont généralement limitées à un compartiment de cartes donné et sont créées lors de la configuration du compartiment plutôt qu'en ligne, comme indiqué ici.
**Topics**
+ [Fonctions générales](use-cases-issuers.generalfunctions.md)
+ [Fonctions spécifiques au réseau](use-cases-issuers.networkfunctions.md)
# 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"
}
```
# Fonctions spécifiques au réseau
**Topics**
+ [Fonctions spécifiques à Visa](use-cases-issuers.networkfunctions.visa.md)
+ [Fonctions spécifiques à Mastercard](use-cases-issuers.networkfunctions.mastercard.md)
+ [Fonctions spécifiques à American Express](use-cases-issuers.networkfunctions.amex.md)
+ [Fonctions spécifiques au JCB](use-cases-issuers.networkfunctions.jcb.md)
# Fonctions spécifiques à Visa
**Topics**
+ [ARQC -/ CVN18CVN22](#use-cases-issuers.networkfunctions.visa.cvn18)
+ [ARQC - CVN10](#use-cases-issuers.networkfunctions.visa.cvn10)
+ [3DS CAVV V7](#use-cases-issuers.networkfunctions.visa.cavv-v7)
+ [DCVV (valeur de vérification dynamique de la carte) - CVN17](#use-cases-issuers.networkfunctions.visa.dcvv)
## ARQC -/ CVN18CVN22
CVN18 et CVN22 utilisez la [méthode CSK](use-cases-issuers.generalfunctions.arqc.md) de dérivation des clés. Les données de transaction exactes varient entre ces deux méthodes. Consultez la documentation du schéma pour plus de détails sur la création du champ de données de transaction.
## ARQC - CVN10
CVN10 est une ancienne méthode Visa pour les transactions EMV qui utilise la dérivation de clé par carte plutôt que la dérivation de session (par transaction) et utilise également une charge utile différente. Pour plus d'informations sur le contenu de la charge utile, veuillez contacter le programme pour plus de détails.
### Créer une 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":"CVN10"},{"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.
### Valider l'ARQC
**Example**
Dans cet exemple, nous allons valider un ARQC généré à l'aide de Visa CVN10.
Si AWS Payment Cryptography est en mesure de valider l'ARQC, un http/200 est renvoyé. Si l'arqc n'est pas validé, il renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram D791093C8A921769 \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \
--major-key-derivation-mode EMV_OPTION_A \
--transaction-data 00000000170000000000000008400080008000084016051700000000093800000B03011203000000 \
--session-key-derivation-attributes='{"Visa":{"PanSequenceNumber":"01" \
,"PrimaryAccountNumber":"9137631040001422"}}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4"
}
```
## 3DS CAVV V7
Pour les transactions Visa Secure (3DS), une valeur de vérification de l'authentification du titulaire de la carte (CAVV) est générée par le serveur de contrôle d'accès (ACS) de l'émetteur. Le CAVV prouve que l'authentification du titulaire de la carte a eu lieu. Il est unique pour chaque transaction d'authentification et est fourni par l'acquéreur dans le message d'autorisation. CAVV v7 lie des données supplémentaires sur la transaction à l'approbation, y compris des éléments tels que le nom du commerçant, le montant de l'achat et la date d'achat. De cette manière, il s'agit effectivement d'un hachage cryptographique de la charge utile de la transaction.
Sur le plan cryptographique, le CAVV V7 utilise l'algorithme CVV, mais les entrées ont toutes été de la changed/repurposed. Please consult appropriate third party/Visa documentation sur la façon de produire les entrées pour générer une charge utile CAVV V7.
### 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":"CAVV-V7"},{"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/dnaeyrjgdjjtw6dk",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "F3FB13",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/dnaeyrjgdjjtw6dk. Vous en aurez besoin à l'étape suivante.
### Générer un CAVV V7
**Example**
Dans cet exemple, nous allons générer un CAVV V7 pour une transaction donnée avec des entrées telles que spécifiées dans les spécifications. Notez que pour cet algorithme, les champs peuvent être réutilisés/réutilisés. Il ne faut donc pas supposer que les étiquettes des champs correspondent aux entrées.
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/dnaeyrjgdjjtw6dk --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=9431,ServiceCode=431}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk",
"KeyCheckValue": "F3FB13",
"ValidationData": "491"
}
```
### Valider CAVV V7
**Example**
Pour la validation, les entrées sont le CVK, les valeurs d'entrée calculées et le CAVV 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 CAVV n'est pas une valeur saisie par l'utilisateur (similaire CVV2) mais est calculé par l'émetteur ACS. Il convient de se demander 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/dnaeyrjgdjjtw6dk --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=9431,ServiceCode=431} --validation-data 491
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/dnaeyrjgdjjtw6dk",
"KeyCheckValue": "F3FB13",
"ValidationData": "491"
}
```
## DCVV (valeur de vérification dynamique de la carte) - CVN17
Le DCVV (Dynamic Card Verification Value) est un cryptogramme dynamique spécifique à Visa utilisé pour les transactions EMV sans contact. Il est connu sous le nom d'EMV et offre une sécurité renforcée en générant une valeur de vérification unique pour chaque transaction. Le DCVV utilise des entrées telles que le numéro de compte principal (PAN), le numéro de séquence PAN (PSN), le compteur de transactions d'application (ATC), le nombre imprévisible et les données de suivi. Il est toujours utilisé à certains endroits, mais a été principalement remplacé par d'autres algorithmes tels que CVN18.
Pour tous les paramètres disponibles, consultez [DynamicCardVerificationValue](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DynamicCardVerificationValue.html)le guide de référence de l'API.
### Créer une clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"DCVV"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
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/mw7dn3qxvkfh8ztc",
"KeyAttributes": {
"KeyUsage": "TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "A8E4D2",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2025-02-02T11:45:30.648000-08:00",
"UsageStartTimestamp": "2025-02-02T11:45:30.626000-08:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/mw7dn3qxvkfh8ztc. Vous en aurez besoin à l'étape suivante.
### Générer un DCVV
**Example**
Dans cet exemple, nous allons générer un DCVV pour une transaction EMV sans contact. Les entrées incluent le PAN, le numéro de séquence PAN, le compteur de transactions d'application, le nombre imprévisible et les données de suivi.
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc \
--primary-account-number=5111112627662122 \
--generation-attributes DynamicCardVerificationValue='{ApplicationTransactionCounter=01,PanSequenceNumber=00,TrackData=12345,UnpredictableNumber=123}' \
--validation-data-length 5
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc",
"KeyCheckValue": "A8E4D2",
"ValidationData": "36667"
}
```
### Valider DCVV
**Example**
Dans cet exemple, nous allons valider un DCVV fourni lors d'une transaction. Les mêmes entrées utilisées pour la génération doivent être fournies pour la validation.
Si AWS Payment Cryptography est en mesure de valider, un http/200 est renvoyé. Si la valeur n'est pas validée, elle renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc \
--primary-account-number=5111112627662122 \
--validation-data=36667 \
--verification-attributes DynamicCardVerificationValue='{ApplicationTransactionCounter=01,PanSequenceNumber=00,TrackData=12345,UnpredictableNumber=123}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/mw7dn3qxvkfh8ztc",
"KeyCheckValue": "A8E4D2"
}
```
# Fonctions spécifiques à Mastercard
**Topics**
+ [DCVC3](#use-cases-issuers.networkfunctions.mastercard.dcvc)
+ [ARQC -/ CVN14CVN15](#use-cases-issuers.networkfunctions.mastercard.cvn14)
+ [ARQC -/ CVN12CVN13](#use-cases-issuers.networkfunctions.mastercard.cvn12)
+ [3DS AAV SPA2](#use-cases-issuers.networkfunctions.mastercard.spa2aav)
## DCVC3
DCVC3 est antérieur aux CVN12 systèmes EMV CSK et Mastercard et représente une autre approche d'utilisation des clés dynamiques. Il est parfois également réutilisé pour d'autres cas d'utilisation. Dans ce schéma, les entrées sont les données PAN, PSN, Track1/Track2, un nombre imprévisible et un compteur de transactions (ATC).
### Créer une clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=TDES_2KEY,KeyUsage=TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{DeriveKey=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"DCVC3"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
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/hrh6qgbi3sk4y3wq",
"KeyAttributes": {
"KeyUsage": "TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": false,
"Sign": false,
"Verify": false,
"DeriveKey": true,
"NoRestrictions": false
}
},
"KeyCheckValue": "08D7B4",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2024-03-07T06:41:46.648000-07:00",
"UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east- 2:111122223333:key/hrh6qgbi3sk4y3wq*. Vous en aurez besoin à l'étape suivante.
### Générez un DCVC3
**Example**
Bien qu'il DCVC3 soit généralement généré par une carte à puce, il peut également être généré manuellement, comme dans cet exemple
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --primary-account-number=5413123456784808 --generation-attributes DynamicCardVerificationCode='{ApplicationTransactionCounter=0000,TrackData=5241060000000069D13052020000000000003F,PanSequenceNumber=00,UnpredictableNumber=00000000}''
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4",
"ValidationData": "865"
}
```
### Validez le DCVC3
**Example**
Dans cet exemple, nous allons valider un DCVC3. Notez que l'ATC doit être fourni sous forme de numéro hexadécimal, par exemple un compteur de 11 doit être représenté par 000B. Le service attend une valeur à 3 chiffres DCVC3, donc si vous avez enregistré une valeur à 4 (ou 5) chiffres, tronquez simplement les caractères de gauche jusqu'à obtenir 3 chiffres (par exemple, 15321 devrait entraîner une valeur de donnée de validation de 321).
Si AWS Payment Cryptography est en mesure de valider, un http/200 est renvoyé. Si la valeur n'est pas validée, elle renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk --primary-account-number=5413123456784808 --verification-attributes DynamicCardVerificationCode='{ApplicationTransactionCounter=000B,TrackData=5241060000000069D13052020000000000003F,PanSequenceNumber=00,UnpredictableNumber=00000001}' --validation-data 398
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4"
}
```
## ARQC -/ CVN14CVN15
CVN14 et CVN15 utilisez la [méthode EMV CSK de dérivation](use-cases-issuers.generalfunctions.arqc.md) de clés. Les données de transaction exactes varient entre ces deux méthodes. Consultez la documentation du schéma pour plus de détails sur la création du champ de données de transaction.
## ARQC -/ CVN12CVN13
CVN12 et CVN13 sont une ancienne méthode spécifique à MasterCard pour les transactions EMV qui incorpore un nombre imprévisible dans la dérivation par transaction et utilise également une charge utile différente. Pour plus d'informations sur le contenu de la charge utile, veuillez contacter le programme.
### Créer une 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":"CVN12"},{"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.
### Valider l'ARQC
**Example**
Dans cet exemple, nous allons valider un ARQC généré à l'aide de Mastercard CVN12.
Si AWS Payment Cryptography est en mesure de valider l'ARQC, un http/200 est renvoyé. Si l'arqc n'est pas validé, il renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-auth-request-cryptogram --auth-request-cryptogram 31BE5D49F14A5F01 \
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \
--major-key-derivation-mode EMV_OPTION_A \
--transaction-data 00000000170000000000000008400080008000084016051700000000093800000B1F2201030000000000000000000000000000000000000000000000000000008000000000000000 \
--session-key-derivation-attributes='{"MastercardSessionKey":{"ApplicationTransactionCounter":"000B","PanSequenceNumber":"01","PrimaryAccountNumber":"5413123456784808","UnpredictableNumber":"00000001"}}'
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
"KeyCheckValue": "08D7B4"
}
```
## 3DS AAV SPA2
SPA2 L'AAV (Account Authentication Value) est utilisé pour les transactions Mastercard 3DS (également connues sous le nom de Mastercard Idenity Check). Il fournit une authentification cryptographique pour les transactions de commerce électronique à l'aide de la génération MAC basée sur HMAC. L'AAV est généré à l'aide de données spécifiques à la transaction et d'une clé secrète partagée.
### Créer une clé
```
$ aws payment-cryptography create-key --exportable --key-attributes KeyAlgorithm=HMAC_SHA256,KeyUsage=TR31_M7_HMAC_KEY,KeyClass=SYMMETRIC_KEY,KeyModesOfUse='{Generate=true,Verify=true}' --tags='[{"Key":"KEY_PURPOSE","Value":"SPA2_AAV"},{"Key":"CARD_BIN","Value":"12345678"}]'
```
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-west-2:111122223333:key/q5vjtshsg67cz5gn",
"KeyAttributes": {
"KeyUsage": "TR31_M7_HMAC_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "HMAC_SHA256",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "C661F9",
"KeyCheckValueAlgorithm": "HMAC",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2024-03-07T06:41:46.648000-07:00",
"UsageStartTimestamp": "2024-03-07T06:41:46.626000-07:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-west* - 2:111122223333:key/q5vjtshsg67cz5gn. Vous en aurez besoin à l'étape suivante.
### Générer SPA2 AAV
**Example**
Dans cet exemple, nous allons générer le composant Issuer Authentication Value (IAV) de l' SPA2 AAV à l'aide de la génération HMAC MAC. Les données du message contiennent les informations spécifiques à la transaction qui seront authentifiées. Le format des données du message doit suivre les SPA2 spécifications de Mastercard et n'est pas couvert dans cet exemple.
Veuillez consulter les spécifications de votre carte Mastercard pour connaître le formatage permettant d'insérer l'IAV dans la valeur AAV.
```
$ aws payment-cryptography-data generate-mac --key-identifier arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn --message-data "2226400099919520FFFFd8b448be65694fe7b42f836bad396e9d" --generation-attributes Algorithm=HMAC --region us-west-2
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn",
"KeyCheckValue": "C661F9",
"Mac": "6FB2405E9D8A4C1F7B173F73ADD1A6DC358531CAB0E9994FC5B62012ADDE91FC"
}
```
### Vérifiez SPA2 AAV
**Example**
Dans cet exemple, nous allons vérifier un SPA2 AAV. Les mêmes données de message et la même valeur MAC sont fournies à des fins de vérification.
Si AWS Payment Cryptography est en mesure de valider le MAC, un http/200 est renvoyé. Si le MAC n'est pas validé, il renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-mac --key-identifier arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn --message-data "2226400099919520FFFFd8b448be65694fe7b42f836bad396e9d" --mac "6FB2405E9D8A4C1F7B173F73ADD1A6DC358531CAB0E9994FC5B62012ADDE91FC" --verification-attributes Algorithm=HMAC --region us-west-2
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-west-2:111122223333:key/q5vjtshsg67cz5gn",
"KeyCheckValue": "C661F9"
}
```
# Fonctions spécifiques à American Express
**Topics**
+ [CSC1](#use-cases-issuers.networkfunctions.amex.csc)
+ [CSC2](#use-cases-issuers.networkfunctions.amex.csc2)
+ [iCSC](#use-cases-issuers.networkfunctions.amex.csc3)
+ [3DS AEVV](#use-cases-issuers.networkfunctions.amex.3dsaevv)
## CSC1
La version 1 du CSC est également connue sous le nom d'algorithme CSC classique. Le service peut le fournir sous forme de numéro à 3,4 ou 5 chiffres.
Pour tous les paramètres disponibles, voir [AmexCardSecurityCodeVersion1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion1.html) dans le guide de référence de l'API.
### Créer une 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":"CSC1"},{"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/esh6hn7pxdtttzgq",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "8B5077",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/esh6hn7pxdtttzgq. Vous en aurez besoin à l'étape suivante.
### Générez un CSC1
**Example**
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion1='{CardExpiryDate=1224}' --validation-data-length 4
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq",
"KeyCheckValue": "8B5077",
"ValidationData": "3938"
}
```
### Validez le CSC1
**Example**
Dans cet exemple, nous allons valider un CSC1.
Si AWS Payment Cryptography est en mesure de valider, un http/200 est renvoyé. Si la valeur n'est pas validée, elle renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion1='{CardExpiryDate=1224}'' --validation-data 3938
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/esh6hn7pxdtttzgq",
"KeyCheckValue": "8B5077"
}
```
## CSC2
La version 2 du CSC est également connue sous le nom d'algorithme CSC amélioré. Le service peut le fournir sous forme de numéro à 3,4 ou 5 chiffres. Le code de service pour CSC2 est généralement 000.
Pour tous les paramètres disponibles, reportez-vous à la section [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) du guide de référence de l'API.
### Créer une 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":"CSC2"},{"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/erlm445qvunmvoda",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyAlgorithm": "TDES_2KEY",
"KeyModesOfUse": {
"Encrypt": false,
"Decrypt": false,
"Wrap": false,
"Unwrap": false,
"Generate": true,
"Sign": false,
"Verify": true,
"DeriveKey": false,
"NoRestrictions": false
}
},
"KeyCheckValue": "BF1077",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyState": "CREATE_COMPLETE",
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"CreateTimestamp": "2023-06-05T06:41:46.648000-07:00",
"UsageStartTimestamp": "2023-06-05T06:41:46.626000-07:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/erlm445qvunmvoda. Vous en aurez besoin à l'étape suivante.
### Générez un CSC2
Dans cet exemple, nous allons générer un CSC2 avec une longueur de 4. Le CSC peut être généré avec une longueur de 3,4 ou 5. Pour American Express, PANs il doit comporter 15 chiffres et commencer par 34 ou 37. La date d'expiration est généralement au format YYMM. Le code de service peut varier. Consultez votre manuel, mais les valeurs typiques sont 000, 201 ou 702
**Example**
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=2412,ServiceCode=000}' --validation-data-length 4
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda",
"KeyCheckValue": "BF1077",
"ValidationData": "3982"
}
```
### Validez le CSC2
**Example**
Dans cet exemple, nous allons valider un CSC2.
Si AWS Payment Cryptography est en mesure de valider, un http/200 est renvoyé. Si la valeur n'est pas validée, elle renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=2412,ServiceCode=000}' --validation-data 3982
```
```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/erlm445qvunmvoda",
"KeyCheckValue": "BF1077"
}
```
## iCSC
L'iCSC est également connu sous le nom d'algorithme CSC statique et est calculé à l'aide de CSC version 2. Le service peut le fournir sous forme de numéro à 3,4 ou 5 chiffres.
Utilisez le code de service 999 pour calculer l'iCSC pour une carte de visite. Utilisez le code de service 702 pour calculer l'iCSC pour une carte sans contact.
Pour tous les paramètres disponibles, reportez-vous à la section [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) du guide de référence de l'API.
### Créer une 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":"CSC1"},{"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-1:111122223333:key/7vrybrbvjcvwtunv",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY"
"KeyAlgorithm": "TDES_2KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyModesOfUse": {
"Decrypt": false,
"DeriveKey": false,
"Encrypt": false,
"Generate": true,
"NoRestrictions": false,
"Sign": false,
"Unwrap": false,
"Verify": true,
"Wrap": false
},
},
"KeyCheckValue": "7121C7",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"KeyState": "CREATE_COMPLETE",
"CreateTimestamp": "2025-01-29T09:19:21.209000-05:00",
"UsageStartTimestamp": "2025-01-29T09:19:21.192000-05:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east- 1:111122223333:key/7vrybrbvjcvwtunv*. Vous en aurez besoin à l'étape suivante.
### Générer un iCSC
Dans cet exemple, nous allons générer un iCSC d'une longueur de 4, pour une carte sans contact utilisant le code de service 702. Le CSC peut être généré avec une longueur de 3,4 ou 5. Pour American Express, PANs il doit comporter 15 chiffres et commencer par 34 ou 37.
**Example**
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1224,ServiceCode=702}' --validation-data-length 4
```
```
{
"KeyArn": arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv,
"KeyCheckValue": 7121C7,
"ValidationData": "2365"
}
```
### Valider l'iCSC
**Example**
Dans cet exemple, nous allons valider un iCSC.
Si AWS Payment Cryptography est en mesure de valider, un http/200 est renvoyé. Si la valeur n'est pas validée, elle renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1224,ServiceCode=702}' --validation-data 2365
```
```
{
"KeyArn": arn:aws:payment-cryptography:us-east-1:111122223333:key/7vrybrbvjcvwtunv,
"KeyCheckValue": 7121C7
}
```
## 3DS AEVV
3DS AEVV (3-D Secure Account Verification Value) est utilisé pour l'authentification 3-D Secure d'American Express. Il utilise le même algorithme, CSC2 mais avec des paramètres d'entrée différents. Le champ de date d'expiration doit être rempli avec un nombre imprévisible (aléatoire), et le code de service se compose du code des résultats de l'authentification AEVV (1 chiffre) et du code d'authentification à deuxième facteur (2 chiffres). La longueur de sortie doit être de 3 chiffres.
Pour tous les paramètres disponibles, reportez-vous à la section [AmexCardSecurityCodeVersion2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_AmexCardSecurityCodeVersion2.html) du guide de référence de l'API.
### Créer une 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":"3DS_AEVV"},{"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/kw8djn5qxvfh3ztm",
"KeyAttributes": {
"KeyUsage": "TR31_C0_CARD_VERIFICATION_KEY"
"KeyAlgorithm": "TDES_2KEY",
"KeyClass": "SYMMETRIC_KEY",
"KeyModesOfUse": {
"Decrypt": false,
"DeriveKey": false,
"Encrypt": false,
"Generate": true,
"NoRestrictions": false,
"Sign": false,
"Unwrap": false,
"Verify": true,
"Wrap": false
},
},
"KeyCheckValue": "8F3A21",
"KeyCheckValueAlgorithm": "ANSI_X9_24",
"Enabled": true,
"Exportable": true,
"KeyOrigin": "AWS_PAYMENT_CRYPTOGRAPHY",
"KeyState": "CREATE_COMPLETE",
"CreateTimestamp": "2025-02-02T10:30:15.209000-05:00",
"UsageStartTimestamp": "2025-02-02T10:30:15.192000-05:00"
}
}
```
Prenez note de `KeyArn` ce qui représente la clé, par exemple *arn:aws:payment-cryptography:us-east* - 2:111122223333:key/kw8djn5qxvfh3ztm. Vous en aurez besoin à l'étape suivante.
### Générer un 3DS AEVV
Dans cet exemple, nous allons générer un 3DS AEVV d'une longueur de 3. Le champ de date d'expiration contient un nombre imprévisible (aléatoire) (par exemple, 1234), et le code de service se compose du code de résultats d'authentification AEVV (1 chiffre) et du code d'authentification à deuxième facteur (2 chiffres), par exemple 543 où 5 est le code des résultats d'authentification et 43 est le code d'authentification à deuxième facteur. Pour American Express, PANs il doit comporter 15 chiffres et commencer par 34 ou 37.
**Example**
```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm --primary-account-number=344131234567848 --generation-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1234,ServiceCode=543}' --validation-data-length 3
```
```
{
"KeyArn": arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm,
"KeyCheckValue": 8F3A21,
"ValidationData": "921"
}
```
### Validez le 3DS AEVV
**Example**
Dans cet exemple, nous allons valider un 3DS AEVV.
Si AWS Payment Cryptography est en mesure de valider, un http/200 est renvoyé. Si la valeur n'est pas validée, elle renverra une réponse http/400.
```
$ aws payment-cryptography-data verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm --primary-account-number=344131234567848 --verification-attributes AmexCardSecurityCodeVersion2='{CardExpiryDate=1234,ServiceCode=543}' --validation-data 921
```
```
{
"KeyArn": arn:aws:payment-cryptography:us-east-2:111122223333:key/kw8djn5qxvfh3ztm,
"KeyCheckValue": 8F3A21
}
```
# Fonctions spécifiques au JCB
**Topics**
+ [ARQC - CVN04](#use-cases-issuers.networkfunctions.jcb.cvn04)
+ [ARQC - CVN01](#use-cases-issuers.networkfunctions.jcb.cvn01)
## ARQC - CVN04
JCB CVN04 utilise la [méthode CSK de dérivation des clés](use-cases-issuers.generalfunctions.arqc.md). Consultez la documentation du schéma pour plus de détails sur la création du champ de données de transaction.
## ARQC - CVN01
CVN01 est une ancienne méthode JCB pour les transactions EMV qui utilise la dérivation de clé par carte plutôt que la dérivation de session (par transaction) et utilise également une charge utile différente. Ce message est également utilisé par Visa, c'est pourquoi le nom de l'élément porte ce nom même s'il est également utilisé pour JCB. Pour plus d'informations sur le contenu de la charge utile, veuillez contacter la documentation du schéma.
### Créer une 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":"CVN10"},{"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.
### Valider l'ARQC
**Example**
Dans cet exemple, nous allons valider un ARQC généré à l'aide de CVN01 JCB. Cela utilise les mêmes options que la méthode Visa, d'où le nom du paramètre.
Si AWS Payment Cryptography est en mesure de valider l'ARQC, un http/200 est renvoyé. Si l'arqc n'est pas validé, il renverra une réponse 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"
}
```