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.

# Opérations relatives aux données
<a name="data-operations"></a>

Une fois que vous avez défini une clé AWS de chiffrement des paiements, celle-ci peut être utilisée pour effectuer des opérations cryptographiques. Les différentes opérations exécutent différents types d'activités, allant du chiffrement au hachage, en passant par des algorithmes spécifiques au domaine tels que la CVV2 génération.

Les données cryptées ne peuvent pas être déchiffrées sans la clé de déchiffrement correspondante (clé symétrique ou clé privée selon le type de chiffrement). De même, les algorithmes de hachage et spécifiques au domaine ne peuvent pas être vérifiés sans la clé symétrique ou la clé publique. 

Pour plus d'informations sur les types de clés valides pour des opérations spécifiques, voir [Clés valides pour les opérations cryptographiques](crypto-ops-validkeys-ops.md).

**Note**  
Nous recommandons d'utiliser les données de test dans un environnement hors production. L'utilisation de clés et de données de production (PAN, ID BDK, etc.) dans un environnement hors production peut avoir un impact sur votre périmètre de conformité, par exemple pour les normes PCI DSS et PCI P2PE. 

**Topics**
+ [Chiffrer, déchiffrer et rechiffrer les données](crypto-ops.encryptdecrypt.md)
+ [Génération et vérification des données de carte](crypto-ops-carddata.md)
+ [Générez, traduisez et vérifiez les données PIN](data-operations.pindata.md)
+ [Cryptogramme de demande d'authentification (ARQC)](data-operations.verifyauthrequestcryptogram.md)
+ [Générer et vérifier MAC](crypto-ops-mac.md)
+ [Clés valides pour les opérations cryptographiques](crypto-ops-validkeys-ops.md)

# Chiffrer, déchiffrer et rechiffrer les données
<a name="crypto-ops.encryptdecrypt"></a>

Les méthodes de chiffrement et de déchiffrement peuvent être utilisées pour chiffrer ou déchiffrer des données à l'aide de diverses techniques symétriques et asymétriques, notamment TDES, AES et RSA. Ces méthodes prennent également en charge les clés dérivées à l'aide des techniques [DUKPT](terminology.md#terms.dukpt) et [EMV](terminology.md#terms.emv). Dans les cas d'utilisation où vous souhaitez sécuriser les données sous une nouvelle clé sans exposer les données sous-jacentes, la ReEncrypt commande peut également être utilisée.

**Note**  
 Lorsque vous utilisez les encrypt/decrypt fonctions, toutes les entrées sont supposées être en hexadécimal. Par exemple, une valeur de 1 sera saisie sous la forme 31 (hexadécimal) et un t minuscule est représenté par 74 (hexadécimal). Toutes les sorties sont également en HexBinary. 

[Pour plus de détails sur toutes les options disponibles, veuillez consulter le guide de l'API pour le [chiffrement](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_EncryptData.html), le [déchiffrement et le rechiffrement](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DecryptData.html).](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_ReEncryptData.html) 

**Topics**
+ [Chiffrer des données](encrypt-data.md)
+ [Déchiffrer des données](decrypt-data.md)

# Chiffrer des données
<a name="encrypt-data"></a>

 [L'`Encrypt Data`API est utilisée pour chiffrer les données à l'aide de clés de chiffrement symétriques et asymétriques ainsi que de clés dérivées du [DUKPT](terminology.md#terms.dukpt) et de l'EMV.](terminology.md#terms.emv) Différents algorithmes et variantes sont pris en charge`TDES`, notamment, `RSA` et`AES`.

Les entrées principales sont la clé de chiffrement utilisée pour chiffrer les données, les données en texte brut au format HexBinary à chiffrer et les attributs de chiffrement tels que le vecteur d'initialisation et le mode pour les chiffrements par blocs tels que TDES. Les données en texte brut doivent être exprimées en multiples de 8 octets pour`TDES`, 16 octets pour `AES` et de la longueur de la clé dans le cas de`RSA`. Les entrées clés symétriques (TDES, AES, DUKPT, EMV) doivent être complétées dans les cas où les données d'entrée ne répondent pas à ces exigences. Le tableau suivant indique la longueur maximale du texte brut pour chaque type de clé et le type de remplissage que vous définissez `EncryptionAttributes` pour les clés RSA.


| Type de rembourrage | RSA\$12048 | RSA\$13072 | RSA\$14096 | 
| --- | --- | --- | --- | 
| OAEP SHA1 | 428 | 684 | 940 | 
| OAEP SHA256 | 380 | 636 | 892 | 
| OAEP SHA512 | 252 | 508 | 764 | 
| PKCS1 | 488 | 744 | 1 000 | 
| None | 488 | 744 | 1 000 | 

Les sorties principales incluent les données chiffrées sous forme de texte chiffré au format HexBinary et la valeur de la somme de contrôle pour la clé de chiffrement. Pour plus de détails sur toutes les options disponibles, veuillez consulter le guide de l'API pour [Encrypt](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_EncryptData.html). 

**Topics**
+ [Chiffrer les données à l'aide d'une clé symétrique AES](#w2aac15c16c11c13)
+ [Chiffrer les données à l'aide de la clé DUKPT](#w2aac15c16c11c15)
+ [Chiffrer les données à l'aide d'une clé symétrique dérivée de l'EMV](#w2aac15c16c11c17)
+ [Chiffrer les données à l'aide d'une clé RSA](#crypto-ops.encrypt-rsa)

## Chiffrer les données à l'aide d'une clé symétrique AES
<a name="w2aac15c16c11c13"></a>

**Note**  
 Tous les exemples supposent que la clé correspondante existe déjà. Les clés peuvent être créées à l'aide de l'[CreateKey](create-keys.md)opération ou importées à l'aide de l'[ImportKey](keys-import.md)opération. 

**Example**  
 Dans cet exemple, nous chiffrerons les données en texte brut à l'aide d'une clé symétrique créée à l'aide de l'[CreateKey](create-keys.md)opération ou importée à l'aide de l'opération. [ImportKey](keys-import.md) Pour cette opération, la clé doit être KeyModesOfUse réglée sur `Encrypt` et KeyUsage définie sur`TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus d'options.   

```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --plain-text 31323334313233343132333431323334 --encryption-attributes 'Symmetric={Mode=CBC}'
```

```
         
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "71D7AE",
    "CipherText": "33612AB9D6929C3A828EB6030082B2BD"
}
```

## Chiffrer les données à l'aide de la clé DUKPT
<a name="w2aac15c16c11c15"></a>

**Example**  
 Dans cet exemple, nous allons chiffrer les données en texte brut à l'aide d'une clé [DUKPT](terminology.md#terms.dukpt). AWS Supports de cryptographie des paiements `TDES` et clés `AES` DUKPT. Pour cette opération, la clé doit être KeyModesOfUse réglée sur `DeriveKey` et KeyUsage définie sur`TR31_B0_BASE_DERIVATION_KEY`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus d'options.   

```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --plain-text 31323334313233343132333431323334 --encryption-attributes 'Dukpt={KeySerialNumber=FFFF9876543210E00001}'
```

```
         
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "71D7AE",
    "CipherText": "33612AB9D6929C3A828EB6030082B2BD"
}
```

## Chiffrer les données à l'aide d'une clé symétrique dérivée de l'EMV
<a name="w2aac15c16c11c17"></a>

**Example**  
 Dans cet exemple, nous allons chiffrer des données en texte clair à l'aide d'une clé symétrique dérivée de l'EMV qui a déjà été créée. Vous pouvez utiliser une commande comme celle-ci pour envoyer des données vers une carte EMV. Pour cette opération, la clé doit être KeyModesOfUse définie sur `Derive` et KeyUsage définie sur `TR31_E1_EMV_MKEY_CONFIDENTIALITY` ou`TR31_E6_EMV_MKEY_OTHER`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus de détails.   

```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --plain-text 33612AB9D6929C3A828EB6030082B2BD --encryption-attributes 'Emv={MajorKeyDerivationMode=EMV_OPTION_A,PanSequenceNumber=27,PrimaryAccountNumber=1000000000000432,SessionDerivationData=02BB000000000000, InitializationVector=1500000000000999,Mode=CBC}'
```

```
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "71D7AE",
    "CipherText": "33612AB9D6929C3A828EB6030082B2BD"
}
```

## Chiffrer les données à l'aide d'une clé RSA
<a name="crypto-ops.encrypt-rsa"></a>

**Example**  
 Dans cet exemple, nous allons chiffrer les données en texte brut à l'aide d'une [clé publique RSA](terminology.md#terms.publickey) importée à l'aide de l'opération. [ImportKey](keys-import.md) Pour cette opération, la clé doit être KeyModesOfUse réglée sur `Encrypt` et KeyUsage définie sur`TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus d'options.   
 *Pour le PKCS \$17 ou d'autres systèmes de rembourrage non pris en charge actuellement, veuillez en faire la demande avant d'appeler le service et sélectionner aucun rembourrage en omettant l'indicateur de rembourrage « Asymmetric= \$1\$1 »*   

```
$ aws payment-cryptography-data encrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/thfezpmsalcfwmsg --plain-text 31323334313233343132333431323334 --encryption-attributes 'Asymmetric={PaddingType=OAEP_SHA256}'
```

```
     
{
 "CipherText": "12DF6A2F64CC566D124900D68E8AFEAA794CA819876E258564D525001D00AC93047A83FB13 \ 
 E73F06329A100704FA484A15A49F06A7A2E55A241D276491AA91F6D2D8590C60CDE57A642BC64A897F4832A3930 \ 
 0FAEC7981102CA0F7370BFBF757F271EF0BB2516007AB111060A9633D1736A9158042D30C5AE11F8C5473EC70F067 \ 
 72590DEA1638E2B41FAE6FB1662258596072B13F8E2F62F5D9FAF92C12BB70F42F2ECDCF56AADF0E311D4118FE3591 \ 
 FB672998CCE9D00FFFE05D2CD154E3120C5443C8CF9131C7A6A6C05F5723B8F5C07A4003A5A6173E1B425E2B5E42AD \ 
 7A2966734309387C9938B029AFB20828ACFC6D00CD1539234A4A8D9B94CDD4F23A",
 "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/5dza7xqd6soanjtb",
 "KeyCheckValue": "FF9DE9CE"
}
```

# Déchiffrer des données
<a name="decrypt-data"></a>

 [L'`Decrypt Data`API est utilisée pour déchiffrer les données à l'aide de clés de chiffrement symétriques et asymétriques ainsi que de clés dérivées de [DUKPT](terminology.md#terms.dukpt) et EMV.](terminology.md#terms.emv) Différents algorithmes et variantes sont pris en charge`TDES`, notamment, `RSA` et`AES`.

 Les entrées principales sont la clé de déchiffrement utilisée pour déchiffrer les données, les données chiffrées au format HexBinary à déchiffrer et les attributs de déchiffrement tels que le vecteur d'initialisation, le mode sous forme de blocs, etc. Les sorties principales incluent les données déchiffrées sous forme de texte brut au format HexBinary et la valeur de la somme de contrôle pour la clé de déchiffrement. Pour plus de détails sur toutes les options disponibles, veuillez consulter le guide de l'API pour le [déchiffrement](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DecryptData.html). 

**Topics**
+ [Déchiffrer les données à l'aide d'une clé symétrique AES](#w2aac15c16c13b9)
+ [Déchiffrer les données à l'aide de la clé DUKPT](#w2aac15c16c13c11)
+ [Déchiffrer les données à l'aide d'une clé symétrique dérivée d'EMV](#w2aac15c16c13c13)
+ [Déchiffrer les données à l'aide d'une clé RSA](#crypto-ops.decrypt-rsa)

## Déchiffrer les données à l'aide d'une clé symétrique AES
<a name="w2aac15c16c13b9"></a>

**Example**  
 Dans cet exemple, nous allons déchiffrer les données chiffrées à l'aide d'une clé symétrique. Cet exemple montre une `AES` clé, mais elle `TDES_2KEY` est également prise en charge. `TDES_3KEY` Pour cette opération, la clé doit être KeyModesOfUse réglée sur `Decrypt` et KeyUsage définie sur`TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus d'options.   

```
$ aws payment-cryptography-data decrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --cipher-text 33612AB9D6929C3A828EB6030082B2BD --decryption-attributes 'Symmetric={Mode=CBC}'
```

```
         
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "71D7AE",
    "PlainText": "31323334313233343132333431323334"
}
```

## Déchiffrer les données à l'aide de la clé DUKPT
<a name="w2aac15c16c13c11"></a>

**Note**  
 L'utilisation de données de déchiffrement avec DUKPT pour les transactions P2PE peut renvoyer à votre application les données PAN et autres données du titulaire de la carte, qui devront être prises en compte lors de la détermination de son champ d'application PCI DSS. 

**Example**  
 Dans cet exemple, nous allons déchiffrer les données chiffrées à l'aide d'une clé [DUKPT](terminology.md#terms.dukpt) créée à l'aide de l'[CreateKey](create-keys.md)opération ou importée à l'aide de l'opération. [ImportKey](keys-import.md) Pour cette opération, la clé doit être KeyModesOfUse réglée sur `DeriveKey` et KeyUsage définie sur`TR31_B0_BASE_DERIVATION_KEY`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus d'options. Lorsque vous utilisez`DUKPT`, pour l'`TDES`algorithme, la longueur des données du texte chiffré doit être un multiple de 16 octets. Pour `AES` l'algorithme, la longueur des données du texte chiffré doit être un multiple de 32 octets.   

```
$ aws payment-cryptography-data decrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --cipher-text 33612AB9D6929C3A828EB6030082B2BD --decryption-attributes 'Dukpt={KeySerialNumber=FFFF9876543210E00001}'
```

```
         
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "71D7AE",
    "PlainText": "31323334313233343132333431323334"
}
```

## Déchiffrer les données à l'aide d'une clé symétrique dérivée d'EMV
<a name="w2aac15c16c13c13"></a>

**Example**  
 Dans cet exemple, nous allons déchiffrer les données de texte chiffré à l'aide d'une clé symétrique dérivée de l'EMV créée à l'aide de l'opération ou importée à l'aide de l'[CreateKey](create-keys.md)opération. [ImportKey](keys-import.md) Pour cette opération, la clé doit être KeyModesOfUse définie sur `Derive` et KeyUsage définie sur `TR31_E1_EMV_MKEY_CONFIDENTIALITY` ou`TR31_E6_EMV_MKEY_OTHER`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus de détails.   

```
$ aws payment-cryptography-data decrypt-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --cipher-text 33612AB9D6929C3A828EB6030082B2BD --decryption-attributes 'Emv={MajorKeyDerivationMode=EMV_OPTION_A,PanSequenceNumber=27,PrimaryAccountNumber=1000000000000432,SessionDerivationData=02BB000000000000, InitializationVector=1500000000000999,Mode=CBC}'
```

```
{
"KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
"KeyCheckValue": "71D7AE",
"PlainText": "31323334313233343132333431323334"
}
```

## Déchiffrer les données à l'aide d'une clé RSA
<a name="crypto-ops.decrypt-rsa"></a>

**Example**  
 Dans cet exemple, nous allons déchiffrer les données de texte chiffré à l'aide d'une [paire de clés](terminology.md#terms.privatekey) RSA créée à l'aide de l'opération. [CreateKey](create-keys.md) Pour cette opération, la clé doit être KeyModesOfUse réglée sur Activé `Decrypt` et KeyUsage définie sur`TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION`. Consultez la section [Clés pour les opérations cryptographiques](crypto-ops-validkeys-ops.md) pour plus d'options.   
 Pour le PKCS \$17 ou d'autres systèmes de rembourrage non pris en charge actuellement, veuillez ne sélectionner aucun rembourrage en omettant l'indicateur de rembourrage *« Asymmetric= \$1\$1 »* et supprimez le rembourrage après avoir appelé le service.   

```
$ aws payment-cryptography-data decrypt-data \ 
        --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/5dza7xqd6soanjtb --cipher-text 8F4C1CAFE7A5DEF9A40BEDE7F2A264635C... \ 
        --decryption-attributes 'Asymmetric={PaddingType=OAEP_SHA256}'
```

```
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-1:111122223333:key/5dza7xqd6soanjtb",
    "KeyCheckValue": "FF9DE9CE",
    "PlainText": "31323334313233343132333431323334"
}
```

# Génération et vérification des données de carte
<a name="crypto-ops-carddata"></a>

La génération et la vérification des données de carte intègrent des données dérivées des données de carte, par exemple CVV CVV2, CVC et DCVV.

**Topics**
+ [Générer des données de carte](generate-card-data.md)
+ [Vérifier les données de la carte](verify-card-data.md)

# Générer des données de carte
<a name="generate-card-data"></a>

 L'`Generate Card Data`API est utilisée pour générer des données de carte à l'aide d'algorithmes tels que CVV CVV2 ou Dynamic CVV2. Pour savoir quelles clés peuvent être utilisées pour cette commande, consultez la section [Clés valides pour les opérations cryptographiques](crypto-ops-validkeys-ops.md). 

De nombreuses valeurs cryptographiques telles que CVV, iCVV CVV2, CAVV V7 utilisent le même algorithme cryptographique mais font varier les valeurs d'entrée. Par exemple, [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) contient les entrées « numéro de ServiceCode carte » et « date d'expiration ». Bien que [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) ne possède que deux de ces entrées, cela est dû au fait que pour CVV2/CVC2, le ServiceCode est fixé à 000. De même, pour iCVV, ServiceCode il est fixé à 999. Certains algorithmes peuvent réutiliser les champs existants, tels que CAVV V8, auquel cas vous devrez consulter le manuel de votre fournisseur pour obtenir les valeurs d'entrée correctes. 

**Note**  
 La date d'expiration doit être saisie dans le même format (tel que MMYY ou YYMM) pour la génération et la validation afin de produire des résultats corrects. 

# Générer CVV2
<a name="generate-cvv2"></a>

**Example**  
Dans cet exemple, nous allons générer un 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. Cela suppose qu'une clé de vérification de carte a été [générée](create-keys.md#cvvkey-example).   

```
$ aws payment-cryptography-data generate-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --generation-attributes CardVerificationValue2={CardExpiryDate=0123}
```

```
  {
      "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
      "KeyCheckValue": "CADDA1",
      "ValidationData": "801"
  }
```

# Générer iCVV
<a name="generate-iCVV"></a>

**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 999 et une date d'expiration de la carte. Cela suppose qu'une clé de vérification de carte a été [générée](create-keys.md#cvvkey-example).   
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/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --generation-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999}'
```

```
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "CADDA1",
    "ValidationData": "801"
}
```

# Vérifier les données de la carte
<a name="verify-card-data"></a>

`Verify Card Data`est utilisé pour vérifier les données créées à l'aide d'algorithmes de paiement basés sur des principes de cryptage tels que`DISCOVER_DYNAMIC_CARD_VERIFICATION_CODE`. 

Les valeurs d'entrée sont généralement fournies dans le cadre d'une transaction entrante à un émetteur ou à un partenaire de plateforme de support. [Pour vérifier un cryptogramme ARQC (utilisé pour les cartes à puce EMV), veuillez consulter Vérifier l'ARQC.](data-operations.verifyauthrequestcryptogram.md) 

Pour plus d'informations, consultez [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)le guide de l'API.

Si la valeur est vérifiée, l'API renverra http/200. Si la valeur n'est pas vérifiée, elle renverra http/400.

# Vérifiez CVV2
<a name="verify-cvv2"></a>

**Example**  
Dans cet exemple, nous allons valider un CVV/ CVV2 pour un PAN donné. CVV2 Il est généralement fourni par le titulaire de la carte ou l'utilisateur au moment de la transaction pour validation. Afin de valider leur saisie, les valeurs suivantes seront fournies lors de l'exécution : [clé à utiliser pour la validation (CVK)](create-keys.md#cvvkey-example)`PAN`, date d'expiration de la carte et CVV2 saisies. Le format d'expiration de la carte doit correspondre à celui utilisé lors de la génération de valeur initiale.   
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 verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --verification-attributes CardVerificationValue2={CardExpiryDate=0123} --validation-data 801
```

```
  {
      "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
      "KeyCheckValue": "CADDA1"
  }
```

# Vérifiez iCVV
<a name="verify-iCVV"></a>

**Example**  
Dans cet exemple, nous allons vérifier un [iCVV](terminology.md#terms.icvv) pour un PAN donné en saisissant la [clé à utiliser pour la validation (CVK)](create-keys.md#cvvkey-example), le code de service 999`PAN`, la date d'expiration de la carte et l'iCVV fourni par la transaction à valider.   
iCVV n'est pas une valeur saisie par l'utilisateur (comme CVV2) mais intégrée sur une carte EMV. Il convient de déterminer s'il doit toujours être validé lorsqu'il est fourni.  
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 verify-card-validation-data --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi --primary-account-number=171234567890123 --verification-attributes CardVerificationValue1='{CardExpiryDate=1127,ServiceCode=999} --validation-data 801
```

```
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "CADDA1",
    "ValidationData": "801"
}
```

# Générez, traduisez et vérifiez les données PIN
<a name="data-operations.pindata"></a>

Les fonctions de données PIN vous permettent de générer des codes PIN aléatoires, des valeurs de vérification des codes PIN (PVV) et de valider les codes PIN chiffrés entrants par rapport au PVV ou aux décalages de code PIN. 

La traduction par épingle vous permet de traduire une épingle d'une touche fonctionnelle à une autre sans exposer l'épingle en texte clair, conformément à l'exigence 1 du code PIN PCI.

**Note**  
 Étant donné que la génération et la validation du code PIN sont généralement des fonctions de l'émetteur et que la traduction du code PIN est une fonction typique de l'acquéreur, nous vous recommandons de prendre en compte l'accès le moins privilégié et de définir des politiques adaptées au cas d'utilisation de vos systèmes. 

**Topics**
+ [Translate les données du code PIN](translate-pin-data.md)
+ [Générer des données PIN](generate-pin-data.md)
+ [Vérifier les données du code PIN](verify-pin-data.md)

# Translate les données du code PIN
<a name="translate-pin-data"></a>

Les fonctions Translate PIN data sont utilisées pour traduire les données PIN cryptées d'un jeu de clés à un autre sans que les données chiffrées ne quittent le HSM. Il est utilisé pour le chiffrement P2PE où les clés de travail doivent changer mais où le système de traitement n'a pas besoin de déchiffrer les données ou n'est pas autorisé à le faire. Les entrées principales sont les données cryptées, la clé de chiffrement utilisée pour chiffrer les données, les paramètres utilisés pour générer les valeurs d'entrée. L'autre ensemble d'entrées est constitué des paramètres de sortie demandés, tels que la clé à utiliser pour chiffrer la sortie et les paramètres utilisés pour créer cette sortie. Les principaux résultats sont un ensemble de données nouvellement crypté ainsi que les paramètres utilisés pour le générer. 

**Note**  
Pour garantir la conformité à la norme PCI, les PrimaryAccountNumber valeurs entrantes et sortantes doivent correspondre. La traduction d'un code PIN d'un PAN à un autre n'est pas autorisée.

**Topics**
+ [Code PIN de PEK à DUKPT](#crypto-ops-pindata.pektodukpt)
+ [Code PIN de PEK à PEK](#crypto-ops-pindata.pektopek)

## Code PIN de PEK à DUKPT
<a name="crypto-ops-pindata.pektodukpt"></a>

**Example**  
Dans cet exemple, nous allons convertir un code PIN d'un bloc PIN AES ISO 4 utilisant le chiffrement [DUKPT](terminology.md#terms.dukpt) en un code PEK TDES utilisant un bloc PIN ISO 0. Cela est courant lorsqu'un terminal de paiement chiffre un code PIN en ISO 4, puis il peut être retraduit en TDES pour un traitement en aval si la prochaine connexion ne prend pas encore en charge l'AES.   

```
$ aws payment-cryptography-data translate-pin-data --encrypted-pin-block "AC17DC148BDA645E" --outgoing-translation-attributes=IsoFormat0='{PrimaryAccountNumber=171234567890123}' --outgoing-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt  --incoming-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/4pmyquwjs3yj4vwe --incoming-translation-attributes IsoFormat4="{PrimaryAccountNumber=171234567890123}" --incoming-dukpt-attributes KeySerialNumber="FFFF9876543210E00008"  
```

```
    {
            "PinBlock": "1F4209C670E49F83E75CC72E81B787D9",
            "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
            "KeyCheckValue": "7CC9E2"
        }
```

## Code PIN de PEK à PEK
<a name="crypto-ops-pindata.pektopek"></a>

**Example**  
Dans cet exemple, nous traduisons un code PIN chiffré sous un PEK (clé de cryptage PIN) en un autre PEK. Ceci est couramment utilisé lors du routage des transactions entre différents systèmes ou partenaires qui utilisent des clés de chiffrement différentes, tout en maintenant la conformité au code PIN PCI en le cryptant tout au long du processus. Les deux clés utilisent le chiffrement TDES 3KEY dans cet exemple, mais diverses options sont disponibles, notamment AES ISO-4 à TDES ISO-0, DUKPT à PEK ou à PEK. AS2805   

```
$ aws payment-cryptography-data translate-pin-data --encrypted-pin-block "AC17DC148BDA645E" \
    --incoming-translation-attributes IsoFormat0='{PrimaryAccountNumber=171234567890123}' \
    --incoming-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt \
    --outgoing-translation-attributes IsoFormat0='{PrimaryAccountNumber=171234567890123}' \
    --outgoing-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/alsuwfxug3pgy6xh
```

```
{
    "PinBlock": "E8F2A6C4D1B93E7F",
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/alsuwfxug3pgy6xh",
    "KeyCheckValue": "9A325B"
}
```
Le bloc PIN de sortie est désormais crypté sous le deuxième PEK et peut être transmis en toute sécurité au système en aval qui détient la clé correspondante.

# Générer des données PIN
<a name="generate-pin-data"></a>

Les fonctions de génération de données PIN sont utilisées pour générer des valeurs liées au code PIN, telles que le [PVV](terminology.md#terms.pvv) et les décalages par blocs de code utilisés pour valider la saisie du code PIN par les utilisateurs pendant la transaction ou le délai d'autorisation. Cette API peut également générer une nouvelle épingle aléatoire à l'aide de divers algorithmes.

# Générez un code PIN aléatoire et un visa PVV correspondant
<a name="generate-pvv-random"></a>

**Example**  
Dans cet exemple, nous allons générer une nouvelle épingle (aléatoire) dont les sorties seront chiffrées `PIN block` (PinData. PinBlock) et a `PVV` (PinData.offset). Les entrées principales sont les `PAN` suivantes : le`Pin Verification Key`, le `Pin Encryption Key` et le`PIN block format`.   
 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"
            }
        }
```

# Générez un visa PVV pour un code PIN connu
<a name="generate-pvv-givenpin"></a>

**Example**  
Dans cet exemple, nous allons générer un PVV pour un code PIN (crypté) donné. Un code PIN crypté peut être reçu en amont, par exemple en provenance d'un terminal de paiement ou d'un titulaire de carte, en utilisant le flux de [code PIN sélectionnable par l'utilisateur](https://github.com/aws-samples/samples-for-payment-cryptography-service/tree/main/python_sdk_example/ecdh_flows). Les entrées principales sont les `PAN` suivantes : le`Pin Verification Key`, le`Pin Encryption Key`, le `Encrypted Pin Block` et le`PIN block format`.   

```
$ aws payment-cryptography-data generate-pin-data --generation-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --generation-attributes VisaPinVerificationValue={PinVerificationKeyIndex=1,EncryptedPinBlock=AA584CED31790F37}
```

```
{
            "GenerationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2",
            "GenerationKeyCheckValue": "7F2363",
            "EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
            "EncryptionKeyCheckValue": "7CC9E2",
            "EncryptedPinBlock": "AC17DC148BDA645E",
            "PinData": {
                "VerificationValue": "5507"
            }
        }
```

# Générer un décalage d' IBM3624 épingle pour une épingle
<a name="generate-ibm3624"></a>

 IBM 3624 PIN Offset est aussi parfois appelée méthode IBM. Cette méthode génère un natural/intermediate code PIN à l'aide des données de validation (généralement le PAN) et d'une clé PIN (PVK). Les épingles naturelles sont en fait une valeur dérivée et le caractère déterministe est très efficace à gérer pour un émetteur, car aucune donnée PIN n'a besoin d'être stockée au niveau du titulaire de la carte. L'inconvénient le plus évident est que ce système ne prend pas en compte les épingles sélectionnables ou aléatoires par le titulaire de la carte. Pour autoriser ces types de broches, un algorithme de décalage a été ajouté au schéma. Le décalage représente la différence entre l'épingle sélectionnée (ou aléatoire) par l'utilisateur et la touche naturelle. La valeur de décalage est enregistrée par l'émetteur ou le processeur de la carte. Au moment de la transaction, le service AWS de cryptographie des paiements recalcule en interne le code PIN naturel et applique le décalage pour trouver le code PIN. Il compare ensuite cette valeur à la valeur fournie par l'autorisation de transaction. 

Plusieurs options existent pour IBM3624 :
+ `Ibm3624NaturalPin`affichera le code PIN naturel et un bloc de code PIN crypté
+ `Ibm3624PinFromOffset`générera un bloc PIN crypté en fonction d'un décalage
+ `Ibm3624RandomPin`générera un code PIN aléatoire, puis le décalage correspondant et le bloc de code crypté.
+  `Ibm3624PinOffset`génère le décalage de broche en fonction d'une épingle sélectionnée par l'utilisateur.

En interne à la cryptographie des AWS paiements, les étapes suivantes sont effectuées :
+ Ajoutez le plan fourni à 16 caractères. Si <16 est indiqué, tapez sur le côté droit en utilisant le caractère de rembourrage fourni.
+ Chiffre les données de validation à l'aide de la clé de génération du code PIN.
+ Décimalisez les données chiffrées à l'aide de la table de décimalisation. Cela fait correspondre des chiffres hexadécimaux à des chiffres décimaux, par exemple « A » peut correspondre à 9 et 1 peut correspondre à 1.
+ Obtenez les 4 premiers chiffres à partir d'une représentation hexadécimale de la sortie. C'est l'épingle naturelle.
+ Si un code PIN a été sélectionné par l'utilisateur ou généré au hasard, modulo soustrait le code naturel du code PIN du client. Le résultat est le décalage de la broche.

**Topics**
+ [Exemple : générer un décalage d' IBM3624 épingle pour une épingle](#generate-ibm3624-random-example)

## Exemple : générer un décalage d' IBM3624 épingle pour une épingle
<a name="generate-ibm3624-random-example"></a>

Dans cet exemple, nous allons générer une nouvelle épingle (aléatoire) dont les sorties seront chiffrées `PIN block` (PinData. PinBlock) et une valeur de `IBM3624` décalage (Pindata.offset). Les entrées sont `PAN` les données de validation (généralement le pan), le caractère de remplissage, le`Pin Verification Key`, le `Pin Encryption Key` et le`PIN block format`.

 Cette commande nécessite que la clé de génération du code PIN soit de type `TR31_V1_IBM3624_PIN_VERIFICATION_KEY` et que la clé de chiffrement soit de type `TR31_P0_PIN_ENCRYPTION_KEY` 

**Example**  
L'exemple suivant montre la génération d'une épingle aléatoire, puis la sortie du bloc de code PIN crypté et de la valeur de IBM3624 décalage à l'aide de Ibm3624. RandomPin   

```
$ aws payment-cryptography-data generate-pin-data --generation-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --generation-attributes Ibm3624RandomPin="{DecimalizationTable=9876543210654321,PinValidationDataPadCharacter=D,PinValidationData=171234567890123}"
```

```
{
              "GenerationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2",
              "GenerationKeyCheckValue": "7F2363",
              "EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
              "EncryptionKeyCheckValue": "7CC9E2",
              "EncryptedPinBlock": "AC17DC148BDA645E",
              "PinData": {
                  "PinOffset": "5507"
              }
          }
```

# Vérifier les données du code PIN
<a name="verify-pin-data"></a>

Les fonctions de vérification des données PIN sont utilisées pour vérifier si un code PIN est correct. Cela implique généralement de comparer la valeur du code PIN précédemment enregistrée à celle saisie par le titulaire de la carte lors d'un POI. Ces fonctions comparent deux valeurs sans exposer la valeur sous-jacente de l'une ou l'autre des sources. 

## Valider le code PIN crypté en utilisant la méthode PVV
<a name="verify-pin-data.pvv-example"></a>

**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 : la clé utilisée pour chiffrer le code PIN d'entrée (il s'agit souvent d'un`IWK`) `PAN` et la valeur par rapport à laquelle vérifier (un `PVV` ou`PIN offset`).   
Si AWS Payment Cryptography est en mesure de 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",
    
        }
```

## Valider le code PIN crypté à l'aide de la méthode PVV - erreur : code PIN incorrect
<a name="verify-pin-data.pvv-example.badpin"></a>

**Example**  
Dans cet exemple, nous allons essayer de valider un code PIN pour un PAN donné, mais cela échouera car le code PIN est incorrect.   
Lors de l'utilisation SDKs, cela apparaît sous la forme « \$1" Message » « Échec de la vérification du bloc d'épingles ». , « Motif » « INVALID\$1PIN »\$1  

```
$ aws payment-cryptography-data verify-pin-data --verification-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0  --verification-attributes VisaPin="{PinVerificationKeyIndex=1,VerificationValue=9999}" --encrypted-pin-block AC17DC148BDA645E 
```

```
        An error occurred (VerificationFailedException) when calling the VerifyPinData operation: Pin block verification failed. 
```

## Valider le code PIN crypté à l'aide de la méthode PVV - erreur, mauvaises entrées
<a name="verify-pin-data.pvv-example.badkey"></a>

**Example**  
Dans cet exemple, nous allons essayer de valider un code PIN pour un PAN donné, mais cela échouera en raison de mauvaises entrées et du fait que les données entrantes n'étaient pas un code PIN valide. Les causes courantes sont les suivantes : 1/mauvaise touche utilisée 2/les paramètres d'entrée tels que le format du bloc panoramique ou pin sont incorrects 3/le bloc pin est endommagé.   

```
$ aws payment-cryptography-data verify-pin-data --verification-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier  --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0  --verification-attributes VisaPin="{PinVerificationKeyIndex=1,VerificationValue=9999}" --encrypted-pin-block AC17DC148BDA645E 
```

```
        An error occurred (ValidationException) when calling the VerifyPinData operation: Pin block provided is invalid. Please check your input to ensure all field values are correct.
```

# Valider un code PIN par rapport au décalage de IBM3624 code précédemment enregistré
<a name="verify-pin-data.ibm3624-example"></a>

Dans cet exemple, nous validerons le code PIN fourni par le titulaire de la carte par rapport à l'offset du code enregistré auprès de l'émetteur/du processeur de la carte. Les entrées sont similaires [Générer un décalage d' IBM3624 épingle pour une épingle](generate-ibm3624.md) à l'ajout du code PIN crypté fourni par le terminal de paiement (ou un autre fournisseur en amont tel que le réseau de cartes). Si le code PIN correspond, l'API renverra http 200, où les sorties seront cryptées `PIN block` (PinData. PinBlock) et une valeur de `IBM3624` décalage (Pindata.offset). 

 Cette commande nécessite que la clé de génération du code PIN soit de type `TR31_V1_IBM3624_PIN_VERIFICATION_KEY` et que la clé de chiffrement soit de type `TR31_P0_PIN_ENCRYPTION_KEY` 

**Example**  

```
$ aws payment-cryptography-data generate-pin-data --generation-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2 --encryption-key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt --primary-account-number 171234567890123 --pin-block-format ISO_FORMAT_0 --generation-attributes Ibm3624RandomPin="{DecimalizationTable=9876543210654321,PinValidationDataPadCharacter=D,PinValidationData=171234567890123}"
```

```
{
"GenerationKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/37y2tsl45p5zjbh2",
"GenerationKeyCheckValue": "7F2363",
"EncryptionKeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/ivi5ksfsuplneuyt",
"EncryptionKeyCheckValue": "7CC9E2",
"EncryptedPinBlock": "AC17DC148BDA645E",
"PinData": {
  "PinOffset": "5507"
}
}
```

# Cryptogramme de demande d'authentification (ARQC)
<a name="data-operations.verifyauthrequestcryptogram"></a>

 [L'API de cryptogramme de demande d'authentification de vérification est utilisée pour vérifier l'ARQC.](terminology.md#terms.arqc) La génération de l'ARQC n'entre pas dans le cadre de la cryptographie des AWS paiements et est généralement effectuée sur une carte à puce EMV (ou un équivalent numérique tel qu'un portefeuille mobile) pendant le temps d'autorisation de la transaction. Un ARQC est unique à chaque transaction et est destiné à montrer de manière cryptographique à la fois la validité de la carte et à garantir que les données de transaction correspondent exactement à la transaction en cours (attendue). 

AWS La cryptographie des paiements fournit diverses options pour valider l'ARQC et générer des valeurs ARPC facultatives, notamment celles définies dans le [livre 2 de l'EMV 4.4](https://www.emvco.com/specifications/?post_id=80377) et d'autres schémas utilisés par Visa et Mastercard. Pour une liste complète de toutes les options disponibles, consultez la VerifyCardValidationData section du [guide de l'API](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html). 

Les cryptogrammes ARQC nécessitent généralement les entrées suivantes (bien que cela puisse varier en fonction de l'implémentation) : 
+ [PAN](terminology.md#terms.pan) - Spécifié dans le PrimaryAccountNumber champ
+ [Numéro de séquence PAN (PSN)](terminology.md#terms.psn) - spécifié dans le champ PanSequenceNumber 
+ Méthode de dérivation des clés, telle que la clé de session commune (CSK), spécifiée dans le SessionKeyDerivationAttributes
+ Mode de dérivation de la clé principale (tel que l'option A EMV) - Spécifié dans le MajorKeyDerivationMode
+ Données de transaction - une chaîne de diverses données de transaction, de terminal et de carte telles que le montant et la date - spécifiées dans le TransactionData champ
+ [Clé principale de l'émetteur](terminology.md#terms.imk) : clé principale utilisée pour dériver la clé cryptographique (AC) utilisée pour protéger les transactions individuelles et spécifiée dans le champ KeyIdentifier 

**Topics**
+ [Création de données de transaction](#w2aac15c25c13)
+ [Rembourrage des données de transaction](#w2aac15c25c15)
+ [Exemples](#w2aac15c25c17)

## Création de données de transaction
<a name="w2aac15c25c13"></a>

Le contenu exact (et l'ordre) du champ de données de transaction varie en fonction de l'implémentation et du schéma de réseau, mais les champs minimaux recommandés (et la séquence de concaténation) sont définis dans le [livre 2 de l'EMV 4.4, section 8.1.1](https://www.emvco.com/specifications/?post_id=80377) - Sélection des données. Si les trois premiers champs sont le montant (17,00), l'autre montant (0,00) et le pays d'achat, les données de transaction commenceront comme suit :
+ 000000001700 - montant - 12 positions décimales implicites à deux chiffres
+ 000000000000 - autre montant - 12 positions décimales implicites à deux chiffres
+ 0124 - code de pays à quatre chiffres 
+  Données de transaction (partielles) de sortie - 0000000017000000000000000124 

## Rembourrage des données de transaction
<a name="w2aac15c25c15"></a>

Les données de transaction doivent être complétées avant d'être envoyées au service. La plupart des schémas utilisent le remplissage de la méthode 2 ISO 9797, où une chaîne hexadécimale est ajoutée par 80 puis par 00 jusqu'à ce que le champ soit un multiple de la taille du bloc de chiffrement ; 8 octets ou 16 caractères pour TDES et 16 octets ou 32 caractères pour AES. L'alternative (méthode 1) n'est pas aussi courante mais utilise uniquement 00 comme caractères de remplissage. 

### Rembourrage ISO 9797 Méthode 1
<a name="w2aac15c25c15b5"></a>

 Non rembourré : 000000000000000000000008400080008000084016051700000000093800000B03011203 (74 caractères ou 37 octets) 

 **Rembourré : 000000000000000000000008400080008000084016051700000000093800000B03011203 000000 (80 caractères ou 40 octets)** 

### Rembourrage ISO 9797 Méthode 2
<a name="w2aac15c25c15b7"></a>

 Non rembourré : 000000000000000000000008400080008000084016051700000000093800000B1F220103000000 (80 caractères ou 40 octets) 

 **Rembourré : 000000000000000000000008400080008000084016051700000000093800000B1F220103000000 8000000000000000 (88 caractères ou 44 octets)** 

## Exemples
<a name="w2aac15c25c17"></a>

### Visa CVN10
<a name="w2aac15c25c17b3"></a>

**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'ARCQ (Authorization Request Cryptogram) 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"
}
```

### Visa CVN18 et visa CVN22
<a name="w2aac15c25c17b5"></a>

**Example**  
Dans cet exemple, nous allons valider un ARQC généré à l'aide de Visa CVN18 ou CVN22. Les opérations cryptographiques sont les mêmes entre CVN18 et CVN22 mais les données contenues dans les données de transaction varient. Par rapport à CVN10, un cryptogramme complètement différent est généré même avec les mêmes entrées.  
Si AWS Payment Cryptography est en mesure de valider l'ARQC, un http/200 est renvoyé. Si l'ARCQ n'est pas validé, il renverra un http/400.  

```
$ aws payment-cryptography-data verify-auth-request-cryptogram \ 
--auth-request-cryptogram 61EDCC708B4C97B4
--key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk \ 
--major-key-derivation-mode EMV_OPTION_A 
--transaction-data 00000000170000000000000008400080008000084016051700000000093800000B1F22010300000000000 \
00000000000000000000000000000000000000000008000000000000000
--session-key-derivation-attributes='{"EmvCommon":{"ApplicationTransactionCounter":"000B", \
"PanSequenceNumber":"01","PrimaryAccountNumber":"9137631040001422"}}'
```

```
{
  "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/pw3s6nl62t5ushfk",
  "KeyCheckValue": "08D7B4"
}
```

# Générer et vérifier MAC
<a name="crypto-ops-mac"></a>

Les codes d'authentification de message (MAC) sont généralement utilisés pour authentifier l'intégrité d'un message (s'il a été modifié). Les hachages cryptographiques tels que le HMAC (code d'authentification de message basé sur le hachage), le CBC-MAC et le CMAC (code d'authentification de message basé sur le chiffrement) fournissent une assurance supplémentaire à l'expéditeur du MAC en utilisant la cryptographie. HMAC est basé sur des fonctions de hachage tandis que CMAC est basé sur des chiffrements par blocs. Le service prend également en charge les ISO9797 algorithmes 1 et 3, qui sont des types de CBC-MACs. 

Tous les algorithmes MAC de ce service combinent une fonction de hachage cryptographique et une clé secrète partagée. Ils prennent un message et une clé secrète, tels que le contenu clé d'une clé, et renvoient un tag ou un mac unique. Si un seul caractère du message change, ou si la clé secrète change, le tag obtenu est totalement différent. En exigeant une clé secrète, la cryptographie garantit MACs également l'authenticité ; il est impossible de générer un Mac identique sans la clé secrète. Les signatures cryptographiques MACs sont parfois appelées signatures symétriques, car elles fonctionnent comme des signatures numériques, mais utilisent une clé unique pour la signature et la vérification. 

AWS La cryptographie des paiements prend en charge plusieurs types de MACs :

**ISO9797 ALGORITHME 1**  
Désigné par ou `KeyUsage` ISO9797 \$1ALGORITHM1. Si le champ n'est pas un multiple de la taille du bloc (8 octets/16 caractères hexadécimaux pour TDES, 16 octets/32 caractères pour AES), Payment Cryptography applique automatiquement la méthode de remplissage 1. AWS ISO9797 Si d'autres méthodes de rembourrage sont nécessaires, vous pouvez les appliquer avant d'appeler le service.

**ISO9797 ALGORITHME 3 (Retail MAC)**  
Désigné par ou `KeyUsage` ISO9797 \$1ALGORITHM3. Les mêmes règles de remplissage s'appliquent que celles de l'algorithme 1

**ISO9797 ALGORITHME 5 (CMAC)**  
Désigné par ou `KeyUsage` \$1M6\$1ISO\$19797\$15\$1CMAC\$1KEY TR31

**HMAC**  
Désigné par `KeyUsage` TR31 \$1M7\$1HMAC\$1KEY, y compris HMAC\$1, HMAC\$1, HMAC\$1 et HMAC\$1 SHA224 SHA256 SHA384 SHA512

**AS28054.4.1 MAC**  
Désigné par ou `KeyUsage` TR31 \$1M0\$1ISO\$116609\$1MAC\$1KEY. Pour plus de détails sur AS2805, voir [AS2805](advanced.regional.as2805.md)

**DUKPT MAC**  
DUKPT MAC est généralement utilisé pour confirmer la source et la charge utile des messages to/from des terminaux de paiement. Il déduit une clé à l'aide des techniques de dérivation DUKPT, puis exécute le MAC. Les clés utilisées avec cette option sont désignées par `KeyUsage` TR31 \$1B0\$1BASE\$1DERIVATION\$1KEY. 

**EMV MAC**  
Le MAC EMV est généralement appelé clé d'intégrité dans la documentation EMV. Il déduit une clé à l'aide de techniques de dérivation EMV, puis utilise ISO9797 \$1 en interne. ALGORITHM3 Il est généralement utilisé pour envoyer des scripts d'émetteur à une carte à puce à des fins de reprogrammation. Les clés utilisées avec cette option sont désignées par `KeyUsage` TR31 \$1E2\$1EMV\$1MKEY\$1INTEGRITY. Si vous envoyez un script et mettez à jour un code PIN hors ligne, veillez à [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange)ce qu'il effectue ces deux opérations. 

**Topics**
+ [Générer un MAC](generate-mac.md)
+ [Vérifiez le MAC](verify-mac.md)

# Générer un MAC
<a name="generate-mac"></a>

L'API Generate MAC est utilisée pour authentifier les données relatives aux cartes, telles que le suivi des données provenant d'une bande magnétique de carte, en utilisant des clés cryptographiques connues pour générer un code d'authentification de message (MAC) pour la validation des données entre les parties émettrices et réceptrices. Les données utilisées pour générer le MAC incluent des données de message, une clé de cryptage MAC secrète et un algorithme MAC pour générer une valeur MAC unique pour la transmission. Le destinataire du MAC utilisera les mêmes données de message MAC, la même clé de chiffrement MAC et le même algorithme pour reproduire une autre valeur MAC à des fins de comparaison et d'authentification des données. Même si un caractère du message change ou si la clé MAC utilisée pour la vérification n'est pas identique, la valeur MAC obtenue est différente. L'API prend en charge les clés de chiffrement MAC ISO 9797-1 Algorithme 1 et ISO 9797-1 Algorithme 3 MAC (utilisant une clé MAC statique et une clé DUKPT dérivée), HMAC et EMV MAC pour cette opération.

La valeur d'entrée pour `message-data` doit être des données HexBinary.

Pour plus d'informations sur toutes les options de cette API, consultez [GenerateMac](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMac.html)et [VerifyMac](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyMac.html).

Le paramètre optionnel mac-length vous permet de tronquer la valeur de sortie (bien que cela puisse également être fait dans votre code). Une longueur de 8 correspond à 8 octets ou 16 caractères hexadécimaux.

Les clés MAC peuvent être créées avec AWS Payment Cryptography en appelant [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)ou importées en appelant [ImportKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html). 

**Note**  
Les algorithmes CMAC et HMAC ne nécessitent pas de rembourrage. Tous les autres nécessitent que les données soient complétées en fonction de la taille de bloc de l'algorithme, qui est un multiple de 8 octets (16 caractères hexadécimaux) pour le TDES et de 16 octets (32 caractères hexadécimaux) pour l'AES. 

**Topics**
+ [Générer un HMAC](#generate-mac-hmac)
+ [Générer un MAC à l'aide de l'algorithme ISO 9797-1 3](#generate-mac-iso9797-alg3)
+ [Générer un MAC à l'aide de CMAC](#generate-mac-cmac)
+ [Générer un MAC à l'aide de DUKPT CMAC](#generate-mac-dukpt-cmac)

## Générer un HMAC
<a name="generate-mac-hmac"></a>

Dans cet exemple, nous allons générer un code HMAC (Hash-Based Message Authentication Code) pour l'authentification des données de carte à l'aide de l'algorithme HMAC `HMAC_SHA256` et de la clé de cryptage HMAC. La clé doit être KeyUsage réglée sur `TR31_M7_HMAC_KEY` et KeyModesOfUse sur`Generate`. La longueur de hachage (par exemple 256) est définie lors de la création de la clé et ne peut pas être modifiée. 

Le paramètre optionnel mac-length réduira le MAC de sortie, bien que cela puisse également être effectué en dehors du service. Cette valeur est en octets, donc une valeur de 16 suppose une chaîne hexadécimale de 32 caractères.

**Example**  

```
$ aws payment-cryptography-data generate-mac \ 
    --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6 \ 
    --message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" \
    --generation-attributes Algorithm=HMAC
```

```
           
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6",
    "KeyCheckValue": "2976E7",
    "Mac": "ED87F26E961C6D0DDB78DA5038AA2BDDEA0DCE03E5B5E96BDDD494F4A7AA470C"
}
```

## Générer un MAC à l'aide de l'algorithme ISO 9797-1 3
<a name="generate-mac-iso9797-alg3"></a>

Dans cet exemple, nous allons générer un MAC à l'aide de l'algorithme ISO 9797-1 3 (Retail MAC) pour l'authentification des données de carte. La clé doit être KeyUsage réglée sur `TR31_M3_ISO_9797_3_MAC_KEY` et KeyModesOfUse sur`Generate`. 

**Example**  

```
$ aws payment-cryptography-data generate-mac \ 
    --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/kwapwa6qaifllw2h \ 
    --message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" \ 
    --generation-attributes="Algorithm=ISO9797_ALGORITHM3"
```

```
           
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/kwapwa6qaifllw2h",
    "KeyCheckValue": "2976EA",
    "Mac": "A8F7A73DAF87B6D0"
}
```

## Générer un MAC à l'aide de CMAC
<a name="generate-mac-cmac"></a>

Le CMAC est le plus souvent utilisé lorsque les touches sont en AES, mais il prend également en charge le TDES. Dans cet exemple, nous allons générer un MAC à l'aide du CMAC (algorithme ISO 9797-1 5) pour l'authentification des données de carte à l'aide d'une clé AES. La clé doit être KeyUsage réglée sur `TR31_M6_ISO_9797_5_CMAC_KEY` et KeyModesOfUse sur`Generate`. 

**Example**  

```
$ aws payment-cryptography-data generate-mac \ 
    --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi \ 
    --message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" \ 
    --generation-attributes Algorithm="CMAC"
```

```
           
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "C1EB8F",
    "Mac": "1F8C36E63F91E4E93DF7842BF5E2E5F7"
}
```

## Générer un MAC à l'aide de DUKPT CMAC
<a name="generate-mac-dukpt-cmac"></a>

Dans cet exemple, nous allons générer un MAC à l'aide de DUKPT (Derived Unique Key Per Transaction) avec CMAC pour l'authentification des données de carte. La clé doit être KeyUsage définie sur `TR31_B0_BASE_DERIVATION_KEY` et KeyModesOfUse `DeriveKey` définie sur true. Les clés DUKPT dérivent une clé unique pour chaque transaction à l'aide d'une clé de dérivation de base (BDK) et d'un numéro de série de clé (KSN). 



**Example**  

```
$ aws payment-cryptography-data generate-mac --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6 --message-data "3b313038383439303031303733393431353d32343038323236303030373030303f33" --generation-attributes="DukptCmac={KeySerialNumber="932A6E954ABB32DD00000001",Direction=BIDIRECTIONAL}"
```

```
       
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6",
    "KeyCheckValue": "C1EB8F"
}
```

# Vérifiez le MAC
<a name="verify-mac"></a>

L'API Verify MAC est utilisée pour vérifier le MAC (code d'authentification des messages) pour l'authentification des données liées à la carte. Il doit utiliser la même clé de chiffrement que celle utilisée lors de la génération du MAC pour reproduire la valeur MAC à des fins d'authentification. La clé de chiffrement MAC peut être créée avec AWS Payment Cryptography en appelant [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)ou importée par appel [ImportKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html). L'API prend en charge les clés de chiffrement DUKPT MAC, HMAC et EMV MAC pour cette opération.

Si la valeur est vérifiée, le paramètre de réponse `MacDataVerificationSuccessful` sera renvoyé`Http/200`, sinon `Http/400` avec un message l'indiquant`Mac verification failed`.

**Topics**
+ [Vérifiez HMAC](#verify-mac-hmac)
+ [Vérifiez le MAC à l'aide de DUKPT CMAC](#verify-mac-dukpt-cmac)

## Vérifiez HMAC
<a name="verify-mac-hmac"></a>

Dans cet exemple, nous allons vérifier un code HMAC (Hash-Based Message Authentication Code) pour l'authentification des données de carte à l'aide de l'algorithme HMAC `HMAC_SHA256` et de la clé de cryptage HMAC. La clé doit être KeyUsage définie sur `TR31_M7_HMAC_KEY` et KeyModesOfUse `Verify` définie sur true. 

**Example**  

```
$ aws payment-cryptography-data verify-mac \ 
     --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6 \ 
     --message-data "3b343038383439303031303733393431353d32343038323236303030373030303f33" \ 
     --mac ED87F26E961C6D0DDB78DA5038AA2BDDEA0DCE03E5B5E96BDDD494F4A7AA470C \ 
     --verification-attributes Algorithm=HMAC_SHA256
```

```
       
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/qnobl5lghrzunce6",
    "KeyCheckValue": "2976E7"
}
```

## Vérifiez le MAC à l'aide de DUKPT CMAC
<a name="verify-mac-dukpt-cmac"></a>

Dans cet exemple, nous allons vérifier un MAC à l'aide du DUKPT (Derived Unique Key Per Transaction) avec le CMAC pour l'authentification des données de carte. La clé doit être KeyUsage définie sur `TR31_B0_BASE_DERIVATION_KEY` et KeyModesOfUse `DeriveKey` définie sur true. Les clés DUKPT dérivent une clé unique pour chaque transaction à l'aide d'une clé de dérivation de base (BDK) et d'un numéro de série de clé (KSN). La valeur de DukptKeyVariant doit correspondre entre l'expéditeur et le destinataire. REQUEST est généralement utilisé d'un terminal à l'autre, VERIFY d'un backend à un autre et BIDIRECTIONAL lorsqu'une seule touche est utilisée dans les deux sens. 

**Example**  

```
$ aws payment-cryptography-data verify-mac \ 
     --key-identifier arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi \ 
     --message-data "3b343038383439303031303733393431353d32343038323236303030373030303f33" \ 
     --mac D8E804EE74BF1D909A2C01C0BDE8EF34 \ 
     --verification-attributes DukptCmac='{"KeySerialNumber":"932A6E954ABB32DD00000001","DukptKeyVariant":"BIDIRECTIONAL"}'
```

```
       
{
    "KeyArn": "arn:aws:payment-cryptography:us-east-2:111122223333:key/tqv5yij6wtxx64pi",
    "KeyCheckValue": "C1EB8F"
}
```

# Clés valides pour les opérations cryptographiques
<a name="crypto-ops-validkeys-ops"></a>

Certaines touches ne peuvent être utilisées que pour certaines opérations. En outre, certaines opérations peuvent limiter les modes d'utilisation des touches. Consultez le tableau suivant pour connaître les combinaisons autorisées. 

**Note**  
Certaines combinaisons, bien qu'autorisées, peuvent créer des situations inutilisables, telles que la génération de codes CVV `(generate)` mais l'impossibilité de les vérifier. `(verify)` 

**Topics**
+ [GenerateCardData](#w2aac15c31b9)
+ [VerifyCardData](#w2aac15c31c11)
+ [GeneratePinData (pour les VISA/ABA programmes)](#w2aac15c31c15)
+ [GeneratePinData (pour`IBM3624`)](#w2aac15c31c17)
+ [VerifyPinData (pour les VISA/ABA programmes)](#w2aac15c31c21)
+ [VerifyPinData (pour`IBM3624`)](#w2aac15c31c23)
+ [Déchiffrer des données](#w2aac15c31c27)
+ [Encrypt Data](#w2aac15c31c33)
+ [Translate Pin Data](#w2aac15c31c39)
+ [Générer/vérifier un MAC](#crypto-ops-validkeys.generatemac)
+ [GenerateMacEmvPinChange](#crypto-ops-validkeys.generatemacemvpinchange)
+ [VerifyAuthRequestCryptogram](#w2aac15c31c51)
+ [Clé d'Import/Export](#crypto-ops-validkeys.importexport)
+ [Types de clés non utilisés](#w2aac15c31c57)

## GenerateCardData
<a name="w2aac15c31b9"></a>


| Point de terminaison API | Opération ou algorithme cryptographique | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | --- | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CARD\$1VERIFICATION\$1KEY |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Générer = vrai\$1, \$1Générer = vrai, Vérifier = vrai\$1 | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CARD\$1VERIFICATION\$1KEY |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Générer = vrai\$1, \$1Générer = vrai, Vérifier = vrai\$1 | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1AUTRE |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1 DeriveKey = vrai\$1 | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E4\$1EMV\$1MKEY\$1DYNAMIC\$1NUMBERS |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1 DeriveKey = vrai\$1 | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1AUTRE |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1 DeriveKey = vrai\$1 | 

## VerifyCardData
<a name="w2aac15c31c11"></a>


| Opération ou algorithme cryptographique | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CARD\$1VERIFICATION\$1KEY |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Générer = vrai\$1, \$1Générer = vrai, Vérifier = vrai\$1 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CARD\$1VERIFICATION\$1KEY |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Générer = vrai\$1, \$1Générer = vrai, Vérifier = vrai\$1 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1AUTRE |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1 DeriveKey = vrai\$1 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E4\$1EMV\$1MKEY\$1DYNAMIC\$1NUMBERS |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1 DeriveKey = vrai\$1 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1AUTRE |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1 DeriveKey = vrai\$1 | 

## GeneratePinData (pour les VISA/ABA programmes)
<a name="w2aac15c31c15"></a>

`VISA_PIN or VISA_PIN_VERIFICATION_VALUE`


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé de cryptage PIN  |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé de génération de code PIN  |  TR31\$1V2\$1VISA\$1PIN\$1VERIFICATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## GeneratePinData (pour`IBM3624`)
<a name="w2aac15c31c17"></a>

`IBM3624_PIN_OFFSET,IBM3624_NATURAL_PIN,IBM3624_RANDOM_PIN, IBM3624_PIN_FROM_OFFSET)`


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé de cryptage PIN  |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  Pour IBM3624 \$1NATURAL\$1PIN, \$1RANDOM\$1PIN, IBM3624 \$1PIN\$1FROM\$1OFFSET IBM3624 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) Pour IBM3624 \$1PIN\$1OFFSET [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  Clé de génération de code PIN  |  TR31\$1V1\$1 \$1CLÉ IBM3624 DE VÉRIFICATION PAR CODE PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## VerifyPinData (pour les VISA/ABA programmes)
<a name="w2aac15c31c21"></a>

`VISA_PIN`


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé de cryptage PIN  |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé de génération de code PIN  |  TR31\$1V2\$1VISA\$1PIN\$1VERIFICATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## VerifyPinData (pour`IBM3624`)
<a name="w2aac15c31c23"></a>

`IBM3624_PIN_OFFSET,IBM3624_NATURAL_PIN,IBM3624_RANDOM_PIN, IBM3624_PIN_FROM_OFFSET)`


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé de cryptage PIN  |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  Pour IBM3624 \$1NATURAL\$1PIN, \$1RANDOM\$1PIN, IBM3624 \$1PIN\$1FROM\$1OFFSET IBM3624 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  Clé de vérification du code PIN  |  TR31\$1V1\$1 \$1CLÉ IBM3624 DE VÉRIFICATION PAR CODE PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Déchiffrer des données
<a name="w2aac15c31c27"></a>


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  DUKPT  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  EMV  |  TR31\$1E1\$1EMV\$1MKEY\$1CONFIDENTIALITÉ TR31\$1E6\$1EMV\$1MKEY\$1AUTRE  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  RSA  |  TR31\$1D1\$1CLÉ ASYMÉTRIQUE POUR LE CHIFFREMENT DES DONNÉES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clés symétriques  |  TR31\$1D0\$1CLÉ\$1DE CHIFFREMENT DES DONNÉES SYMÉTRIQUES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Encrypt Data
<a name="w2aac15c31c33"></a>


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  DUKPT  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  EMV  |  TR31\$1E1\$1EMV\$1MKEY\$1CONFIDENTIALITÉ TR31\$1E6\$1EMV\$1MKEY\$1AUTRE  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  RSA  |  TR31\$1D1\$1CLÉ ASYMÉTRIQUE POUR LE CHIFFREMENT DES DONNÉES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clés symétriques  |  TR31\$1D0\$1CLÉ\$1DE CHIFFREMENT DES DONNÉES SYMÉTRIQUES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Translate Pin Data
<a name="w2aac15c31c39"></a>


| Direction | Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | --- | 
|  Source de données entrante  |  DUKPT  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Source de données entrante  |  Non dopé (PEK, AWK, IWK, etc.)  |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Cible de données sortantes  |  DUKPT  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Cible de données sortantes  |  Non dopé (PEK, IWK, AWK, etc.)  |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Générer/vérifier un MAC
<a name="crypto-ops-validkeys.generatemac"></a>

 Les clés MAC sont utilisées pour créer des hachages cryptographiques message/body d'une donnée. Il n'est pas recommandé de créer une clé avec des modes d'utilisation limités car vous ne pourrez pas effectuer l'opération correspondante. Cependant, vous pouvez import/export utiliser une touche avec une seule opération si l'autre système est destiné à effectuer l'autre moitié de la paire d'opérations. 


| Utilisation autorisée des clés | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé MAC   |  TR31\$1M1\$1ISO\$19797\$11\$1MAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé MAC (MAC pour le commerce de détail)   |  TR31\$1M1\$1ISO\$19797\$13\$1MAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé MAC (CMAC)   |  TR31\$1M6\$1ISO\$19797\$15\$1CMAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé MAC (HMAC)   |  TR31\$1M7\$1HMAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé MAC (AS2805)   |  TR31\$1M0\$1ISO\$116609\$1MAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## GenerateMacEmvPinChange
<a name="crypto-ops-validkeys.generatemacemvpinchange"></a>

 GenerateMacEmvPinChange combine la génération de MAC et le chiffrement du code PIN pour les opérations de changement de code PIN hors ligne EMV. Cette opération nécessite deux types de clés différents : une clé d'intégrité pour la génération de MAC et une clé de confidentialité pour le chiffrement par code PIN. 


| Type de clé | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé d'intégrité de la messagerie sécurisée   |  TR31\$1E2\$1EMV\$1MKEY\$1INTEGRITY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé de confidentialité de la messagerie sécurisée   |  TR31\$1E1\$1EMV\$1MKEY\$1CONFIDENTIALITÉ  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  PIN PEK actuel (clé de cryptage PIN)   |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Nouveau code PIN PEK (clé de cryptage PIN)   |  TR31CLÉ DE CHIFFREMENT \$1P0\$1PIN  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé ARQC   S'applique uniquement aux systèmes de dérivation Visa et Amex.   |  TR31\$1E0\$1EMV\$1MKEY\$1APP\$1CRYPTOGRAMMES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## VerifyAuthRequestCryptogram
<a name="w2aac15c31c51"></a>


| Utilisation autorisée des clés | Option EMV | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  TR31\$1E0\$1EMV\$1MKEY\$1APP\$1CRYPTOGRAMMES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Clé d'Import/Export
<a name="crypto-ops-validkeys.importexport"></a>


| Type d'opération | Utilisation autorisée des clés | Algorithme clé autorisé | Combinaison autorisée des principaux modes d'utilisation | 
| --- | --- | --- | --- | 
|  Clé d'emballage TR-31  |  TR31\$1K1\$1KEY\$1BLOCK\$1PROTECTION\$1KEY TR31\$1K0\$1KEY\$1CRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Importation d'une autorité de certification approuvée  |  TR31\$1S0\$1CLÉ\$1ASYMÉTRIQUE POUR SIGNATURE NUMÉRIQUE  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Importation d'un certificat à clé publique pour le chiffrement asymétrique  |  TR31\$1D1\$1CLÉ ASYMÉTRIQUE POUR LE CHIFFREMENT DES DONNÉES  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Clé utilisée pour les algorithmes d'accord clés tels que l'ECDH  |  TR31\$1K3\$1CLÉ\$1ASYMÉTRIQUE\$1POUR\$1KEY\$1AGREEMENT  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Types de clés non utilisés
<a name="w2aac15c31c57"></a>

Les types de clés suivants ne sont pas actuellement utilisés par AWS Payment Cryptography :
+  TR31\$1P1\$1PIN\$1GENERATION\$1KEY