Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Operazioni sui dati
<a name="data-operations"></a>

Dopo aver stabilito una chiave AWS di crittografia dei pagamenti, questa può essere utilizzata per eseguire operazioni crittografiche. Operazioni diverse eseguono diversi tipi di attività, dalla crittografia all'hashing fino agli algoritmi specifici del dominio come la generazione. CVV2 

I dati crittografati non possono essere decrittografati senza la chiave di decrittografia corrispondente (la chiave simmetrica o la chiave privata a seconda del tipo di crittografia). Analogamente, gli algoritmi di hashing e quelli specifici del dominio non possono essere verificati senza la chiave simmetrica o la chiave pubblica. 

Per informazioni sui tipi di chiave validi per operazioni specifiche, consulta Chiavi [valide](crypto-ops-validkeys-ops.md) per operazioni crittografiche

**Nota**  
Si consiglia di utilizzare i dati di test in un ambiente non di produzione. L'utilizzo di chiavi e dati di produzione (PAN, BDK ID, ecc.) in un ambiente non di produzione può influire sull'ambito di conformità, ad esempio per PCI DSS e PCI P2PE. 

**Topics**
+ [Crittografa, decrittografa e ricrittografa i dati](crypto-ops.encryptdecrypt.md)
+ [Genera e verifica i dati della carta](crypto-ops-carddata.md)
+ [Generazione, traduzione e verifica dei dati PIN](data-operations.pindata.md)
+ [Crittogramma Verify Auth Request (ARQC)](data-operations.verifyauthrequestcryptogram.md)
+ [Genera e verifica MAC](crypto-ops-mac.md)
+ [Chiavi valide per operazioni crittografiche](crypto-ops-validkeys-ops.md)

# Crittografa, decrittografa e ricrittografa i dati
<a name="crypto-ops.encryptdecrypt"></a>

I metodi di crittografia e decrittografia possono essere utilizzati per crittografare o decrittografare i dati utilizzando una varietà di tecniche simmetriche e asimmetriche tra cui TDES, AES e RSA. [[Questi metodi supportano anche chiavi derivate utilizzando le tecniche DUKPT ed EMV.](terminology.md#terms.emv)](terminology.md#terms.dukpt) Nei casi d'uso in cui si desidera proteggere i dati con una nuova chiave senza esporre i dati sottostanti, è possibile utilizzare anche il ReEncrypt comando.

**Nota**  
 Quando si utilizzano le encrypt/decrypt funzioni, si presume che tutti gli input siano in HexBinary, ad esempio un valore 1 verrà immesso come 31 (hex) e una t minuscola viene rappresentata come 74 (hex). Tutti gli output sono anche in HexBinary. 

[Per i dettagli su tutte le opzioni disponibili, consulta la Guida API per [Encrypt, Decrypt](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_EncryptData.html)[e Re-Encrypt](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**
+ [Crittografare i dati](encrypt-data.md)
+ [Decrittare i dati](decrypt-data.md)

# Crittografare i dati
<a name="encrypt-data"></a>

 [[L'`Encrypt Data`API viene utilizzata per crittografare i dati utilizzando chiavi di crittografia dei dati simmetriche e asimmetriche, nonché chiavi derivate da DUKPT ed EMV.](terminology.md#terms.emv)](terminology.md#terms.dukpt) Sono supportati vari algoritmi e varianti, tra cui, e. `TDES` `RSA` `AES`

Gli input principali sono la chiave di crittografia utilizzata per crittografare i dati, i dati in testo semplice in formato HexBinary da crittografare e gli attributi di crittografia come il vettore di inizializzazione e la modalità per i cifrari a blocchi come TDES. I dati in chiaro devono essere espressi in multipli di 8 byte per, 16 byte per `TDES` e della lunghezza della chiave nel caso di. `AES` `RSA` Gli input chiave simmetrici (TDES, AES, DUKPT, EMV) devono essere aggiunti nei casi in cui i dati di input non soddisfino questi requisiti. La tabella seguente mostra la lunghezza massima del testo in chiaro per ogni tipo di chiave e il tipo di padding definito per le chiavi RSA. `EncryptionAttributes`


| Tipo di imbottitura | RSA\$12048 | RSA\$13072 | RSA\$14096 | 
| --- | --- | --- | --- | 
| OAEP SHA1 | 428 | 684 | 940 | 
| OAEP SHA256 | 380 | 636 | 892 | 
| OAEP SHA512 | 252 | 508 | 764 | 
| PKCS1 | 488 | 744 | 1000 | 
| None | 488 | 744 | 1000 | 

Gli output primari includono i dati crittografati come testo cifrato in formato HexBinary e il valore di checksum per la chiave di crittografia. [Per i dettagli su tutte le opzioni disponibili, consulta la Guida API per Encrypt.](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_EncryptData.html) 

**Topics**
+ [Crittografa i dati utilizzando la chiave simmetrica AES](#w2aac15c16c11c13)
+ [Crittografa i dati utilizzando la chiave DUKPT](#w2aac15c16c11c15)
+ [Crittografa i dati utilizzando una chiave simmetrica derivata da EMV](#w2aac15c16c11c17)
+ [Crittografa i dati utilizzando una chiave RSA](#crypto-ops.encrypt-rsa)

## Crittografa i dati utilizzando la chiave simmetrica AES
<a name="w2aac15c16c11c13"></a>

**Nota**  
 Tutti gli esempi presuppongono che la chiave pertinente esista già. Le chiavi possono essere create utilizzando l'[CreateKey](create-keys.md)operazione o importate utilizzando l'[ImportKey](keys-import.md)operazione. 

**Example**  
 In questo esempio, crittograferemo i dati in chiaro utilizzando una chiave simmetrica che è stata creata utilizzando l'[CreateKey](create-keys.md)Operazione o importata utilizzando l'Operazione. [ImportKey](keys-import.md) Per questa operazione, la chiave deve essere impostata su e KeyModesOfUse impostata su. `Encrypt` KeyUsage `TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY` Per ulteriori opzioni, consulta la sezione [Chiavi per le operazioni crittografiche](crypto-ops-validkeys-ops.md).   

```
$ 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"
}
```

## Crittografa i dati utilizzando la chiave DUKPT
<a name="w2aac15c16c11c15"></a>

**Example**  
 [In questo esempio, crittograferemo i dati in chiaro utilizzando una chiave DUKPT.](terminology.md#terms.dukpt) AWS Supporti per la crittografia dei pagamenti e le chiavi DUKPT. `TDES` `AES` Per questa operazione, la chiave deve essere impostata `DeriveKey` e KeyModesOfUse KeyUsage impostata su. `TR31_B0_BASE_DERIVATION_KEY` Per ulteriori opzioni, consulta la sezione [Chiavi per le operazioni crittografiche](crypto-ops-validkeys-ops.md).   

```
$ 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"
}
```

## Crittografa i dati utilizzando una chiave simmetrica derivata da EMV
<a name="w2aac15c16c11c17"></a>

**Example**  
 In questo esempio, crittograferemo i dati di testo non crittografato utilizzando una chiave simmetrica derivata da EMV che è già stata creata. È possibile utilizzare un comando come questo per inviare dati a una scheda EMV. Per questa operazione, la chiave deve essere KeyModesOfUse impostata su `Derive` e KeyUsage impostata su `TR31_E1_EMV_MKEY_CONFIDENTIALITY` o`TR31_E6_EMV_MKEY_OTHER`. Per maggiori dettagli, consulta [Keys for Cryptographic Operations](crypto-ops-validkeys-ops.md).   

```
$ 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"
}
```

## Crittografa i dati utilizzando una chiave RSA
<a name="crypto-ops.encrypt-rsa"></a>

**Example**  
 In questo esempio, crittograferemo i dati in chiaro utilizzando una [chiave pubblica RSA](terminology.md#terms.publickey) che è stata importata utilizzando l'operazione. [ImportKey](keys-import.md) Per questa operazione, la chiave deve essere impostata su e KeyModesOfUse impostata su. `Encrypt` KeyUsage `TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION` Per ulteriori opzioni, consulta la sezione [Chiavi per le operazioni crittografiche](crypto-ops-validkeys-ops.md).   
 *Per PKCS \$17 o altri schemi di padding non attualmente supportati, richiedi prima di chiamare il servizio e seleziona no padding omettendo l'indicatore di padding '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"
}
```

# Decrittare i dati
<a name="decrypt-data"></a>

 [[L'`Decrypt Data`API viene utilizzata per decrittografare i dati utilizzando chiavi di crittografia dei dati simmetriche e asimmetriche, nonché chiavi derivate DUKPT ed EMV.](terminology.md#terms.emv)](terminology.md#terms.dukpt) Sono supportati vari algoritmi e varianti, tra cui, e. `TDES` `RSA` `AES`

 Gli input principali sono la chiave di decrittografia utilizzata per decrittografare i dati, i dati di testo cifrato in formato HexBinary da decrittografare e gli attributi di decrittografia come il vettore di inizializzazione, la modalità come i cifrari a blocchi ecc. Gli output principali includono i dati decrittografati come testo semplice in formato HexBinary e il valore di checksum per la chiave di decrittografia. [Per i dettagli su tutte le opzioni disponibili, consulta la Guida API per Decrypt.](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_DecryptData.html) 

**Topics**
+ [Decrittografa i dati utilizzando la chiave simmetrica AES](#w2aac15c16c13b9)
+ [Decrittografa i dati utilizzando la chiave DUKPT](#w2aac15c16c13c11)
+ [Decrittografa i dati utilizzando una chiave simmetrica derivata da EMV](#w2aac15c16c13c13)
+ [Decrittografa i dati utilizzando una chiave RSA](#crypto-ops.decrypt-rsa)

## Decrittografa i dati utilizzando la chiave simmetrica AES
<a name="w2aac15c16c13b9"></a>

**Example**  
 In questo esempio, decifreremo i dati di testo cifrato utilizzando una chiave simmetrica. Questo esempio mostra una `AES` chiave ma sono anche supportate. `TDES_2KEY` `TDES_3KEY` Per questa operazione, la chiave deve essere KeyModesOfUse impostata `Decrypt` e KeyUsage impostata su`TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY`. Per ulteriori opzioni, consulta la sezione [Chiavi per le operazioni crittografiche](crypto-ops-validkeys-ops.md).   

```
$ 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"
}
```

## Decrittografa i dati utilizzando la chiave DUKPT
<a name="w2aac15c16c13c11"></a>

**Nota**  
 L'utilizzo dei dati di decrittografia con DUKPT per le transazioni P2PE può restituire all'applicazione i dati PAN della carta di credito e di altri titolari di carta di credito che dovranno essere presi in considerazione per determinare l'ambito PCI DSS. 

**Example**  
 [In questo esempio, decifreremo i dati di testo cifrato utilizzando una chiave DUKPT che è stata creata utilizzando l'Operazione o importata utilizzando l'Operazione. [CreateKey[ImportKey](keys-import.md)](create-keys.md)](terminology.md#terms.dukpt) Per questa operazione, la chiave deve essere impostata e impostata su. KeyModesOfUse `DeriveKey` KeyUsage `TR31_B0_BASE_DERIVATION_KEY` Per ulteriori opzioni, consulta la sezione [Chiavi per le operazioni crittografiche](crypto-ops-validkeys-ops.md). Quando si utilizza`DUKPT`, per l'`TDES`algoritmo, la lunghezza dei dati del testo cifrato deve essere un multiplo di 16 byte. Per l'`AES`algoritmo, la lunghezza dei dati del testo cifrato deve essere un multiplo di 32 byte.   

```
$ 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"
}
```

## Decrittografa i dati utilizzando una chiave simmetrica derivata da EMV
<a name="w2aac15c16c13c13"></a>

**Example**  
 In questo esempio, decifreremo i dati di testo cifrato utilizzando una chiave simmetrica derivata da EMV che è stata creata utilizzando l'operazione o importata utilizzando l'operazione. [CreateKey[ImportKey](keys-import.md)](create-keys.md) Per questa operazione, la chiave deve essere impostata su e impostata su o. KeyModesOfUse `Derive` KeyUsage `TR31_E1_EMV_MKEY_CONFIDENTIALITY` `TR31_E6_EMV_MKEY_OTHER` Per maggiori dettagli, consulta [Keys for Cryptographic Operations](crypto-ops-validkeys-ops.md).   

```
$ 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"
}
```

## Decrittografa i dati utilizzando una chiave RSA
<a name="crypto-ops.decrypt-rsa"></a>

**Example**  
 In questo esempio, decifreremo i dati di testo cifrato utilizzando una [coppia di chiavi](terminology.md#terms.privatekey) RSA creata utilizzando l'operazione. [CreateKey](create-keys.md) Per questa operazione, la chiave deve essere impostata su enable e KeyModesOfUse impostata su. `Decrypt` KeyUsage `TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION` Per ulteriori opzioni, consulta [Keys for Cryptographic Operations](crypto-ops-validkeys-ops.md).   
 Per PKCS \$17 o altri schemi di padding non attualmente supportati, seleziona no padding omettendo l'indicatore di padding *'Asymmetric= \$1\$1* 'e rimuovi il padding dopo aver chiamato il servizio.   

```
$ 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"
}
```

# Genera e verifica i dati della carta
<a name="crypto-ops-carddata"></a>

Genera e verifica i dati delle carte incorpora i dati derivati dai dati delle carte, ad esempio CVV CVV2, CVC e DCVV.

**Topics**
+ [Genera i dati delle carte](generate-card-data.md)
+ [Verifica i dati della carta](verify-card-data.md)

# Genera i dati delle carte
<a name="generate-card-data"></a>

 L'`Generate Card Data`API viene utilizzata per generare i dati delle carte utilizzando algoritmi come CVV o Dynamic. CVV2 CVV2 Per vedere quali chiavi possono essere utilizzate per questo comando, consulta la sezione [Chiavi valide per le operazioni crittografiche](crypto-ops-validkeys-ops.md). 

Molti valori crittografici come CVV, iCVV CVV2, CAVV V7 utilizzano lo stesso algoritmo crittografico ma variano i valori di input. Ad esempio [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) ha gli input di, numero di carta e data di scadenza. ServiceCode Sebbene [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) abbia solo due di questi input, ciò è dovuto al fatto che per CVV2/CVC2, ServiceCode è fissato a 000. Analogamente, per iCVV ServiceCode è fissato a 999. Alcuni algoritmi possono riutilizzare i campi esistenti, come CAVV V8, nel qual caso sarà necessario consultare il manuale del provider per i valori di input corretti. 

**Nota**  
 La data di scadenza deve essere inserita nello stesso formato (ad esempio MMYY o YYMM) affinché la generazione e la convalida producano risultati corretti. 

# Genera CVV2
<a name="generate-cvv2"></a>

**Example**  
In questo esempio, genereremo un messaggio CVV2 per un determinato PAN con gli input `PAN` e la data di scadenza della carta. [Ciò presuppone che sia stata generata una chiave di verifica della carta.](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"
  }
```

# Genera iCVV
<a name="generate-iCVV"></a>

**Example**  
In questo esempio, genereremo un [iCVV](terminology.md#terms.icvv) per un determinato PAN con gli input di`PAN`, un codice di servizio 999 e la data di scadenza della carta. [Ciò presuppone che sia stata generata una chiave di verifica della carta.](create-keys.md#cvvkey-example)   
Per tutti i parametri disponibili, vedi [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) nella guida di riferimento dell'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"
}
```

# Verifica i dati della carta
<a name="verify-card-data"></a>

`Verify Card Data`viene utilizzato per verificare i dati che sono stati creati utilizzando algoritmi di pagamento che si basano su principi di crittografia come. `DISCOVER_DYNAMIC_CARD_VERIFICATION_CODE` 

I valori di input vengono in genere forniti come parte di una transazione in entrata a un emittente o a un partner della piattaforma di supporto. [Per verificare un crittogramma ARQC (utilizzato per le schede con chip EMV), consulta Verify ARQC.](data-operations.verifyauthrequestcryptogram.md) 

Per ulteriori informazioni, consulta la guida alle API. [VerifyCardValidationData](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html)

Se il valore è verificato, l'api restituirà http/200. Se il valore non è verificato, restituirà http/400.

# Verifica CVV2
<a name="verify-cvv2"></a>

**Example**  
In questo esempio, convalideremo un CVV/ CVV2 per un determinato PAN. In genere CVV2 viene fornito dal titolare della carta o dall'utente durante il momento della transazione per la convalida. Per convalidare i dati immessi, in fase di esecuzione verranno forniti i seguenti valori: [Key to Use for validation (CVK)](create-keys.md#cvvkey-example)`PAN`, data di scadenza della carta e immessi. CVV2 Il formato di scadenza della carta deve corrispondere a quello utilizzato nella generazione iniziale del valore.   
Per tutti i parametri disponibili, vedi [CardVerificationValue2](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue2.html) nella guida di riferimento dell'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"
  }
```

# Verifica iCVV
<a name="verify-iCVV"></a>

**Example**  
In questo esempio, verificheremo un [iCVV](terminology.md#terms.icvv) per un determinato PAN inserendo i seguenti campi: [Key to Use for validation (CVK)](create-keys.md#cvvkey-example), un codice di servizio 999`PAN`, la data di scadenza della carta e l'iCVV fornito dalla transazione per la convalida.   
iCVV non è un valore inserito dall'utente (come) ma è incorporato in una scheda EMV. CVV2 Si dovrebbe valutare se debba sempre essere convalidato quando fornito.  
Per tutti i parametri disponibili, vedere, [CardVerificationValue1](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_CardVerificationValue1.html) nella guida di riferimento dell'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"
}
```

# Generazione, traduzione e verifica dei dati PIN
<a name="data-operations.pindata"></a>

Le funzioni relative ai dati PIN consentono di generare pin casuali, valori di verifica dei pin (PVV) e convalidare i pin crittografati in entrata rispetto a PVV o PIN Offset. 

La traduzione dei pin consente di tradurre un pin da una chiave funzionante all'altra senza esporre il pin in testo non crittografato, come specificato dal requisito 1 del PCI PIN.

**Nota**  
 Poiché la generazione e la convalida del PIN sono in genere funzioni dell'emittente e la traduzione del PIN è una tipica funzione di acquisizione, si consiglia di prendere in considerazione l'accesso con privilegi minimi e di impostare politiche appropriate per il caso d'uso del sistema. 

**Topics**
+ [Traduci i dati del PIN](translate-pin-data.md)
+ [Genera dati PIN](generate-pin-data.md)
+ [Verifica i dati del PIN](verify-pin-data.md)

# Traduci i dati del PIN
<a name="translate-pin-data"></a>

Le funzioni Translate PIN data vengono utilizzate per tradurre i dati PIN crittografati da un set di chiavi a un altro senza che i dati crittografati escano dall'HSM. Viene utilizzato per la crittografia P2PE, in cui le chiavi di lavoro devono cambiare, ma il sistema di elaborazione non deve o non è autorizzato a decrittografare i dati. Gli input principali sono i dati crittografati, la chiave di crittografia utilizzata per crittografare i dati, i parametri utilizzati per generare i valori di input. L'altro set di input è costituito dai parametri di output richiesti, come la chiave da utilizzare per crittografare l'output e i parametri utilizzati per creare quell'output. Gli output principali sono un set di dati appena crittografato e i parametri utilizzati per generarlo. 

**Nota**  
Per la conformità PCI, i valori in entrata e in uscita PrimaryAccountNumber devono corrispondere. La traduzione di un PIN da un PAN a un altro non è consentita.

**Topics**
+ [PIN da PEK a DUKPT](#crypto-ops-pindata.pektodukpt)
+ [PIN da PEK a PEK](#crypto-ops-pindata.pektopek)

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

**Example**  
In questo esempio, tradurremo un PIN da un blocco AES ISO 4 PIN utilizzando la crittografia TDES da [DUKPT](terminology.md#terms.dukpt) a PEK utilizzando il blocco PIN ISO 0. Questo è comune quando un terminale di pagamento cripta un pin in ISO 4 e poi può essere ritradotto in TDES per l'elaborazione a valle se la connessione successiva non supporta ancora AES.   

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

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

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

**Example**  
In questo esempio, traduciamo un PIN crittografato con un PEK (chiave di crittografia PIN) in un altro PEK. Viene comunemente utilizzato per instradare transazioni tra diversi sistemi o partner che utilizzano chiavi di crittografia diverse, mantenendo al contempo la conformità PCI PIN mantenendo il PIN crittografato durante tutto il processo. Entrambe le chiavi utilizzano la crittografia TDES 3KEY in questo esempio, ma sono disponibili diverse opzioni, tra cui da AES ISO-4 a TDES ISO-0, DUKPT a PEK o a 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"
}
```
Il blocco PIN di uscita è ora crittografato con il secondo PEK e può essere trasmesso in sicurezza al sistema a valle che contiene la chiave corrispondente.

# Genera dati PIN
<a name="generate-pin-data"></a>

Le funzioni di generazione dei dati PIN vengono utilizzate per generare valori relativi al PIN, ad esempio gli offset [PVV](terminology.md#terms.pvv) e pin block utilizzati per convalidare l'immissione dei pin da parte degli utenti durante la transazione o il momento dell'autorizzazione. Questa API può anche generare un nuovo pin casuale utilizzando vari algoritmi.

# Genera un pin casuale e un codice Visa PVV corrispondente
<a name="generate-pvv-random"></a>

**Example**  
In questo esempio, genereremo un nuovo pin (casuale) in cui gli output saranno crittografati `PIN block` (. PinData PinBlock) e un `PVV` (PinData.offset). Gli input chiave sono`PAN`, the, the e. `Pin Verification Key` `Pin Encryption Key` `PIN block format`   
 Questo comando richiede che la chiave sia di tipo`TR31_V2_VISA_PIN_VERIFICATION_KEY`.   

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

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

# Genera un Visa PVV per un pin noto
<a name="generate-pvv-givenpin"></a>

**Example**  
In questo esempio, genereremo un PVV per un determinato pin (crittografato). Un pin crittografato può essere ricevuto a monte, ad esempio da un terminale di pagamento o dal titolare della carta, utilizzando il flusso di pin [selezionabile dall'utente](https://github.com/aws-samples/samples-for-payment-cryptography-service/tree/main/python_sdk_example/ecdh_flows). Gli input principali sono`PAN`, the`Pin Verification Key`, the e the`Pin Encryption Key`. `Encrypted Pin Block` `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"
            }
        }
```

# Genera l'offset dei IBM3624 pin per un pin
<a name="generate-ibm3624"></a>

 IBM 3624 PIN Offset è talvolta chiamato anche metodo IBM. Questo metodo genera un natural/intermediate PIN utilizzando i dati di convalida (in genere il PAN) e una chiave PIN (PVK). I pin naturali sono in effetti un valore derivato e, essendo deterministici, sono molto efficienti da gestire per l'emittente, perché non è necessario archiviare i dati relativi ai pin a livello del titolare della carta. Lo svantaggio più evidente è che questo schema non tiene conto dei pin selezionabili o casuali dal titolare della carta. Per consentire questi tipi di pin, è stato aggiunto allo schema un algoritmo di offset. L'offset rappresenta la differenza tra il pin selezionato dall'utente (o casuale) e la chiave naturale. Il valore di offset viene memorizzato dall'emittente della carta o dal processore della carta. Al momento della transazione, il servizio AWS Payment Cryptography ricalcola internamente il pin naturale e applica l'offset per trovare il pin. Quindi lo confronta con il valore fornito dall'autorizzazione della transazione. 

Esistono diverse opzioni per IBM3624:
+ `Ibm3624NaturalPin`emetterà il pin naturale e un blocco pin crittografato
+ `Ibm3624PinFromOffset`genererà un blocco pin crittografato dato un offset
+ `Ibm3624RandomPin`genererà un pin casuale e quindi l'offset corrispondente e il blocco pin crittografato.
+  `Ibm3624PinOffset`genera l'offset del pin in base a un pin selezionato dall'utente.

Internamente alla crittografia dei AWS pagamenti, vengono eseguiti i seguenti passaggi:
+ Riempi il riquadro fornito a 16 caratteri. Se vengono forniti <16, compatta sul lato destro usando il carattere di padding fornito.
+ Crittografa i dati di convalida utilizzando la chiave di generazione del PIN.
+ Decimalizza i dati crittografati utilizzando la tabella di decimalizzazione. Questo mappa le cifre esadecimali in cifre decimali, ad esempio «A» può essere mappato a 9 e 1 può essere mappato a 1.
+ Ottieni le prime 4 cifre da una rappresentazione esadecimale dell'output. Questa è la spilla naturale.
+ Se è stato generato un pin selezionato dall'utente o casuale, il modulo sottrae il pin naturale con il pin del cliente. Il risultato è l'offset del pin.

**Topics**
+ [Esempio: genera l'offset dei IBM3624 pin per un pin](#generate-ibm3624-random-example)

## Esempio: genera l'offset dei IBM3624 pin per un pin
<a name="generate-ibm3624-random-example"></a>

In questo esempio, genereremo un nuovo pin (casuale) in cui gli output saranno crittografati `PIN block` (. PinData PinBlock) e un valore di `IBM3624` offset (pinData.offset). Gli input sono i dati di convalida (in genere il pan)`PAN`, il carattere di riempimento, il, il e il. `Pin Verification Key` `Pin Encryption Key` `PIN block format`

 Questo comando richiede che la chiave di generazione del pin sia di tipo `TR31_V1_IBM3624_PIN_VERIFICATION_KEY` e che la chiave di crittografia sia di tipo `TR31_P0_PIN_ENCRYPTION_KEY` 

**Example**  
L'esempio seguente mostra la generazione di un pin casuale, quindi l'emissione del blocco pin crittografato e del valore di IBM3624 offset utilizzando 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"
              }
          }
```

# Verifica i dati del PIN
<a name="verify-pin-data"></a>

Le funzioni di verifica dei dati del PIN vengono utilizzate per verificare la correttezza di un pin. Ciò comporta in genere il confronto del valore del pin precedentemente memorizzato con quello inserito dal titolare della carta in un POI. Queste funzioni confrontano due valori senza esporre il valore sottostante di nessuna delle due fonti. 

## Convalida il PIN crittografato utilizzando il metodo PVV
<a name="verify-pin-data.pvv-example"></a>

**Example**  
In questo esempio, convalideremo un PIN per un determinato PAN. Il PIN viene in genere fornito dal titolare della carta o dall'utente durante il momento della transazione per la convalida e viene confrontato con il valore registrato (l'input del titolare della carta viene fornito come valore crittografato dal terminale o da altro provider a monte). Per convalidare questo input, in fase di esecuzione verranno forniti anche i seguenti valori: la chiave utilizzata per crittografare il pin di input (spesso si tratta di un`IWK`) `PAN` e il valore con cui eseguire la verifica (a o). `PVV` `PIN offset`   
Se AWS Payment Cryptography è in grado di convalidare il pin, viene restituito un http/200. Se il pin non è convalidato, restituirà 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",
    
        }
```

## Convalida il PIN crittografato utilizzando il metodo PVV: errore: pin errato
<a name="verify-pin-data.pvv-example.badpin"></a>

**Example**  
In questo esempio, cercheremo di convalidare un PIN per un determinato PAN, ma l'operazione fallirà perché il pin non è corretto.   
Quando viene utilizzato SDKs, appare come \$1"Message» :"Verifica del blocco PIN non riuscita». , "Motivo» :"INVALID\$1PIN "\$1  

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

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

## Convalida il PIN crittografato utilizzando il metodo PVV: errore di input errati
<a name="verify-pin-data.pvv-example.badkey"></a>

**Example**  
In questo esempio, cercheremo di convalidare un PIN per un determinato PAN, ma l'operazione avrà esito negativo a causa di input errati e i dati in ingresso non erano un PIN valido. Le cause più comuni sono: 1/chiave errata utilizzata 2/parametri di input come il formato pan o pin block sono errati 3/il blocco pin è danneggiato.   

```
$ 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.
```

# Convalida un PIN rispetto all'offset del pin precedentemente memorizzato IBM3624
<a name="verify-pin-data.ibm3624-example"></a>

In questo esempio, convalideremo il PIN fornito dal titolare della carta confrontandolo con l'offset del pin archiviato presso l'emittente/processore della carta. Gli input sono simili all'[Genera l'offset dei IBM3624 pin per un pin](generate-ibm3624.md)aggiunta del pin crittografato fornito dal terminale di pagamento (o da un altro provider a monte come Card Network). Se il pin corrisponde, l'api restituirà http 200. dove gli output saranno crittografati (. `PIN block` PinData PinBlock) e un valore di `IBM3624` offset (pinData.offset). 

 Questo comando richiede che la chiave di generazione del pin sia di tipo `TR31_V1_IBM3624_PIN_VERIFICATION_KEY` e che la chiave di crittografia sia di tipo `TR31_P0_PIN_ENCRYPTION_KEY` 

**Example**  

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

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

# Crittogramma Verify Auth Request (ARQC)
<a name="data-operations.verifyauthrequestcryptogram"></a>

 [L'API del crittogramma di verifica della richiesta di autenticazione viene utilizzata per verificare l'ARQC.](terminology.md#terms.arqc) La generazione dell'ARQC non rientra nell'ambito della crittografia dei AWS pagamenti e viene generalmente eseguita su una Chip Card EMV (o un equivalente digitale come un portafoglio mobile) durante il periodo di autorizzazione della transazione. Un ARQC è unico per ogni transazione e ha lo scopo di mostrare crittograficamente sia la validità della carta sia di garantire che i dati della transazione corrispondano esattamente alla transazione corrente (prevista). 

AWS La crittografia dei pagamenti offre una varietà di opzioni per la convalida dell'ARQC e la generazione di valori ARPC opzionali, inclusi quelli definiti in [EMV 4.4 Book](https://www.emvco.com/specifications/?post_id=80377) 2 e altri schemi utilizzati da Visa e Mastercard. [Per un elenco completo di tutte le opzioni disponibili, consulta la sezione della Guida API. VerifyCardValidationData ](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyCardValidationData.html) 

I crittogrammi ARQC richiedono in genere i seguenti input (sebbene ciò possa variare in base all'implementazione): 
+ [PAN](terminology.md#terms.pan) - Specificato nel campo PrimaryAccountNumber 
+ [Numero di sequenza PAN (PSN)](terminology.md#terms.psn) - specificato nel campo PanSequenceNumber 
+ Metodo di derivazione delle chiavi come Common Session Key (CSK) - Specificato nel SessionKeyDerivationAttributes
+ Modalità di derivazione della chiave principale (ad esempio EMV Option A) - Specificata nella MajorKeyDerivationMode
+ Dati sulle transazioni: una stringa di vari dati relativi a transazioni, terminali e carte, come Importo e Data, specificati nel campo TransactionData 
+ [Chiave principale dell'emittente](terminology.md#terms.imk): la chiave master utilizzata per derivare la chiave crittografica (AC) utilizzata per proteggere le singole transazioni e specificata nel campo KeyIdentifier 

**Topics**
+ [Creazione di dati sulle transazioni](#w2aac15c25c13)
+ [Riempimento dei dati delle transazioni](#w2aac15c25c15)
+ [Esempi](#w2aac15c25c17)

## Creazione di dati sulle transazioni
<a name="w2aac15c25c13"></a>

Il contenuto esatto (e l'ordine) del campo di dati della transazione varia in base all'implementazione e allo schema di rete, ma i campi minimi consigliati (e la sequenza di concatenazione) sono definiti nel [Libro 2 di EMV 4.4, Sezione 8.1.1](https://www.emvco.com/specifications/?post_id=80377) - Selezione dei dati. Se i primi tre campi sono importo (17,00), altro importo (0,00) e paese di acquisto, i dati della transazione inizierebbero come segue:
+ 000000001700 - importo - 12 posizioni implicavano un decimale a due cifre
+ 000000000000 - altro importo - 12 posizioni implicavano un decimale a due cifre
+ 0124 - prefisso internazionale a quattro cifre 
+  Dati di transazione (parziali) in uscita - 0000000017000000000000000124 

## Riempimento dei dati delle transazioni
<a name="w2aac15c25c15"></a>

I dati delle transazioni devono essere aggiunti prima dell'invio al servizio. La maggior parte degli schemi utilizza il padding ISO 9797 Metodo 2, in cui una stringa esadecimale viene aggiunta dall'esadecimale 80 seguito da 00 fino a quando il campo non è un multiplo della dimensione del blocco di crittografia; 8 byte o 16 caratteri per TDES e 16 byte o 32 caratteri per AES. L'alternativa (metodo 1) non è così comune, ma utilizza solo 00 come caratteri di riempimento. 

### ISO 9797 Metodo 1: Imbottitura
<a name="w2aac15c25c15b5"></a>

 Senza imbottitura: 00000000000000000008400080008000084016051700000000093800000B03011203 (74 caratteri o 37 byte) 

 **Imbottito: 0000000000000000000840008000084016051700000000093800000B03011203 000000 (80 caratteri o 40 byte)** 

### Imbottitura ISO 9797 Metodo 2
<a name="w2aac15c25c15b7"></a>

 Senza imbottitura: 00000000000000000008400080008000084016051700000000093800000B1F220103000000 (80 caratteri o 40 byte) 

 **Imbottito: 000000000000000840008000084016051700000000093800000B1F220103000000 8000000000000000 (88 caratteri o 44 byte)** 

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

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

**Example**  
In questo esempio, convalideremo un ARQC generato utilizzando Visa. CVN10   
Se AWS Payment Cryptography è in grado di convalidare l'ARQC, viene restituito un http/200. Se poi ARCQ (Authorization Request Cryptogram) non viene convalidato, restituirà una risposta 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 e Visa CVN18 CVN22
<a name="w2aac15c25c17b5"></a>

**Example**  
In questo esempio, convalideremo un ARQC generato utilizzando Visa o. CVN18 CVN22 Le operazioni crittografiche sono le stesse tra CVN18 e, CVN22 ma i dati contenuti nei dati delle transazioni variano. Rispetto a CVN10, viene generato un crittogramma completamente diverso anche con gli stessi input.  
Se AWS Payment Cryptography è in grado di convalidare l'ARQC, viene restituito un http/200. Se l'ARCQ non è convalidato, restituirà 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"
}
```

# Genera e verifica MAC
<a name="crypto-ops-mac"></a>

I codici di autenticazione dei messaggi (MAC) vengono in genere utilizzati per autenticare l'integrità di un messaggio (indipendentemente dal fatto che sia stato modificato). Gli hash crittografici come HMAC (Hash-Based Message Authentication Code), CBC-MAC e CMAC (Cipher-Based Message Authentication Code) forniscono un'ulteriore garanzia del mittente del MAC utilizzando la crittografia. HMAC si basa su funzioni hash mentre CMAC si basa su cifrari a blocchi. Il servizio supporta anche ISO9797 gli algoritmi 1 e 3, che sono tipi di CBC-. MACs 

Tutti gli algoritmi MAC di questo servizio combinano una funzione hash crittografica e una chiave segreta condivisa. Accettano un messaggio e una chiave segreta, ad esempio il materiale chiave contenuto in una chiave, e restituiscono un tag o mac univoco. Se anche solo un carattere del messaggio cambia o se la chiave segreta cambia, il tag risultante è completamente diverso. Richiedendo una chiave segreta, la crittografia garantisce MACs anche l'autenticità; è impossibile generare un mac identico senza la chiave segreta. Le firme crittografiche MACs sono talvolta chiamate firme simmetriche, perché funzionano come le firme digitali, ma utilizzano un'unica chiave sia per la firma che per la verifica. 

AWS La crittografia dei pagamenti supporta diversi tipi di: MACs

**ISO9797 ALGORITMO 1**  
Denotato con `KeyUsage` di ISO9797 \$1ALGORITHM1. Se il campo non è un multiplo della dimensione del blocco (8 byte/16 caratteri esadecimali per TDES, 16 byte/32 caratteri per AES), Payment Cryptography applica automaticamente il metodo di riempimento 1. AWS ISO9797 Se sono necessari altri metodi di riempimento, è possibile applicarli prima di chiamare il servizio.

**ISO9797 ALGORITMO 3 (RETAIL MAC)**  
Denotato con `KeyUsage` o ISO9797 \$1ALGORITHM3. Le stesse regole di riempimento si applicano all'algoritmo 1

**ISO9797 ALGORITMO 5 (CMAC)**  
Denotato da \$1M6\$1ISO\$19797\$15\$1CMAC\$1KEY `KeyUsage` TR31

**HMAC**  
Denotato con `KeyUsage` TR31 \$1M7\$1HMAC\$1KEY che include HMAC\$1, HMAC\$1, HMAC\$1 e HMAC\$1 SHA224 SHA256 SHA384 SHA512

**AS28054.4.1 MAC**  
Denotato con `KeyUsage` TR31 \$1M0\$1ISO\$116609\$1MAC\$1KEY. Per ulteriori dettagli su, vedere AS2805 [AS2805](advanced.regional.as2805.md)

**DUMP MAC**  
DUKPT MAC viene in genere utilizzato per confermare la fonte e il payload dei terminali di pagamento dei messaggi. to/from Deriva una chiave utilizzando le tecniche di derivazione DUKPT e quindi esegue il MAC. Le chiavi utilizzate con questa opzione sono contrassegnate da \$1B0\$1BASE\$1DERIVATION\$1KEY. `KeyUsage` TR31 

**EMV MAC**  
EMV MAC viene generalmente definito come una chiave di integrità nella documentazione EMV. Deriva una chiave utilizzando tecniche di derivazione EMV e quindi utilizza \$1 internamente. ISO9797 ALGORITHM3 In genere viene utilizzato per inviare gli script dell'emittente a una chip card per la riprogrammazione. Le chiavi utilizzate con questa opzione sono contrassegnate da \$1E2\$1EMV\$1MKEY\$1INTEGRITY. `KeyUsage` TR31 Se state inviando uno script e aggiornando un pin offline, verificate che esegua entrambe queste operazioni. [GenerateMacEmvPinChange](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMacEmvPinChange) 

**Topics**
+ [Genera un MAC](generate-mac.md)
+ [Verifica MAC](verify-mac.md)

# Genera un MAC
<a name="generate-mac"></a>

L'API Generate MAC viene utilizzata per autenticare i dati relativi alle carte, come tenere traccia dei dati provenienti dalla banda magnetica di una scheda, utilizzando chiavi crittografiche note per generare un MAC (Message Authentication Code) per la convalida dei dati tra le parti che inviano e ricevono. I dati utilizzati per generare un MAC includono i dati dei messaggi, la chiave di crittografia MAC segreta e l'algoritmo MAC per generare un valore MAC univoco per la trasmissione. La parte ricevente del MAC utilizzerà gli stessi dati dei messaggi MAC, la stessa chiave di crittografia MAC e lo stesso algoritmo per riprodurre un altro valore MAC per il confronto e l'autenticazione dei dati. Anche se un carattere del messaggio cambia o la chiave MAC utilizzata per la verifica non è identica, il valore MAC risultante è diverso. L'API supporta ISO 9797-1 Algorithm 1 e ISO 9797-1 Algorithm 3 MAC (utilizzando una chiave MAC statica e una chiave DUKPT derivata), chiavi di crittografia MAC HMAC ed EMV MAC per questa operazione.

Il `message-data` valore di input per deve essere un dato HexBinary.

Per ulteriori informazioni su tutte le opzioni di questa API, consulta [GenerateMac](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_GenerateMac.html)e [VerifyMac](https://docs.aws.amazon.com/payment-cryptography/latest/DataAPIReference/API_VerifyMac.html).

Il parametro opzionale mac-length consente di troncare il valore di output (sebbene ciò possa essere fatto anche all'interno del codice). Una lunghezza di 8 si riferisce a 8 byte o 16 caratteri esadecimali.

Le chiavi MAC possono essere create con AWS Payment Cryptography chiamando [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)o importate chiamando. [ImportKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html) 

**Nota**  
Gli algoritmi CMAC e HMAC non richiedono il padding. Tutti gli altri richiedono che i dati vengano sommati alla dimensione del blocco dell'algoritmo, ovvero multipli di 8 byte (16 caratteri esadecimali) per TDES e 16 byte (32 caratteri esadecimali) per AES. 

**Topics**
+ [Genera HMAC](#generate-mac-hmac)
+ [Genera MAC usando l'algoritmo ISO 9797-1 3](#generate-mac-iso9797-alg3)
+ [Genera MAC usando CMAC](#generate-mac-cmac)
+ [Genera MAC usando DUKPT CMAC](#generate-mac-dukpt-cmac)

## Genera HMAC
<a name="generate-mac-hmac"></a>

In questo esempio, genereremo un HMAC (Hash-Based Message Authentication Code) per l'autenticazione dei dati delle carte utilizzando l'algoritmo `HMAC_SHA256` HMAC e la chiave di crittografia HMAC. La chiave deve essere KeyUsage impostata su e su. `TR31_M7_HMAC_KEY` KeyModesOfUse `Generate` La lunghezza dell'hash (ad esempio 256) viene definita al momento della creazione della chiave e non può essere modificata. 

Il parametro opzionale mac-length taglierà l'output MAC, sebbene ciò possa essere eseguito anche all'esterno del servizio. Questo valore è in byte, quindi un valore di 16 si aspetterà una stringa esadecimale di lunghezza 32.

**Example**  

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

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

## Genera MAC usando l'algoritmo ISO 9797-1 3
<a name="generate-mac-iso9797-alg3"></a>

In questo esempio, genereremo un MAC utilizzando l'algoritmo 3 ISO 9797-1 (Retail MAC) per l'autenticazione dei dati delle carte. La chiave deve essere KeyUsage impostata su e su. `TR31_M3_ISO_9797_3_MAC_KEY` KeyModesOfUse `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"
}
```

## Genera MAC usando CMAC
<a name="generate-mac-cmac"></a>

CMAC è più comunemente usato quando le chiavi sono AES, ma supporta anche TDES. In questo esempio, genereremo un MAC utilizzando CMAC (ISO 9797-1 Algorithm 5) per l'autenticazione dei dati delle carte con una chiave AES. La chiave deve essere KeyUsage impostata su e su. `TR31_M6_ISO_9797_5_CMAC_KEY` KeyModesOfUse `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"
}
```

## Genera MAC usando DUKPT CMAC
<a name="generate-mac-dukpt-cmac"></a>

In questo esempio, genereremo un MAC utilizzando DUKPT (Derived Unique Key Per Transaction) con CMAC per l'autenticazione dei dati delle carte. La chiave deve essere impostata su `TR31_B0_BASE_DERIVATION_KEY` e KeyUsage KeyModesOfUse `DeriveKey` impostata su true. Le chiavi DUKPT derivano una chiave unica per ogni transazione utilizzando una Base Derivation Key (BDK) e un Key Serial Number (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"
}
```

# Verifica MAC
<a name="verify-mac"></a>

L'API Verify MAC viene utilizzata per verificare il MAC (Message Authentication Code) per l'autenticazione dei dati relativi alla carta. Deve utilizzare la stessa chiave di crittografia utilizzata durante la generazione del MAC per riprodurre il valore MAC per l'autenticazione. La chiave di crittografia MAC può essere creata con AWS Payment Cryptography chiamando [CreateKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)o importata chiamando. [ImportKey](https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html) L'API supporta le chiavi di crittografia DUKPT MAC, HMAC ed EMV MAC per questa operazione.

Se il valore è verificato, `MacDataVerificationSuccessful` verrà restituito il parametro di risposta`Http/200`, altrimenti `Http/400` con un messaggio che lo indica. `Mac verification failed`

**Topics**
+ [Verifica HMAC](#verify-mac-hmac)
+ [Verifica il MAC utilizzando DUKPT CMAC](#verify-mac-dukpt-cmac)

## Verifica HMAC
<a name="verify-mac-hmac"></a>

In questo esempio, verificheremo un HMAC (Hash-Based Message Authentication Code) per l'autenticazione dei dati delle carte utilizzando l'algoritmo `HMAC_SHA256` HMAC e la chiave di crittografia HMAC. La chiave deve essere impostata su `TR31_M7_HMAC_KEY` e KeyUsage KeyModesOfUse `Verify` impostata su 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"
}
```

## Verifica il MAC utilizzando DUKPT CMAC
<a name="verify-mac-dukpt-cmac"></a>

In questo esempio, verificheremo un MAC utilizzando DUKPT (Derived Unique Key Per Transaction) con CMAC per l'autenticazione dei dati delle carte. La chiave deve essere impostata su `TR31_B0_BASE_DERIVATION_KEY` e KeyUsage KeyModesOfUse `DeriveKey` impostata su true. Le chiavi DUKPT derivano una chiave unica per ogni transazione utilizzando una Base Derivation Key (BDK) e un Key Serial Number (KSN). Il valore di DukptKeyVariant deve corrispondere tra mittente e destinatario. REQUEST verrà in genere utilizzato da terminale a backend, VERIFY da backend a terminale e BIDIRECTIONAL quando viene utilizzata una singola chiave in entrambe le direzioni. 

**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"
}
```

# Chiavi valide per operazioni crittografiche
<a name="crypto-ops-validkeys-ops"></a>

Alcune chiavi possono essere utilizzate solo per determinate operazioni. Inoltre, alcune operazioni possono limitare le modalità di utilizzo dei tasti. Consulta la tabella seguente per le combinazioni consentite. 

**Nota**  
Alcune combinazioni, sebbene consentite, possono creare situazioni inutilizzabili, come la generazione di codici CVV, `(generate)` ma non possono quindi essere verificate. `(verify)` 

**Topics**
+ [GenerateCardData](#w2aac15c31b9)
+ [VerifyCardData](#w2aac15c31c11)
+ [GeneratePinData (per VISA/ABA schemi)](#w2aac15c31c15)
+ [GeneratePinData (per`IBM3624`)](#w2aac15c31c17)
+ [VerifyPinData (per VISA/ABA schemi)](#w2aac15c31c21)
+ [VerifyPinData (per`IBM3624`)](#w2aac15c31c23)
+ [Decrittografia dei dati](#w2aac15c31c27)
+ [Encrypt Data (Crittografa dati)](#w2aac15c31c33)
+ [Traduci PIN Data](#w2aac15c31c39)
+ [Genera/verifica MAC](#crypto-ops-validkeys.generatemac)
+ [GenerateMacEmvPinChange](#crypto-ops-validkeys.generatemacemvpinchange)
+ [VerifyAuthRequestCryptogram](#w2aac15c31c51)
+ [Chiave Import/Export](#crypto-ops-validkeys.importexport)
+ [Tipi di chiavi non utilizzati](#w2aac15c31c57)

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


| Endpoint API | Operazione o algoritmo crittografico | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | --- | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CHIAVE\$1CARD\$1VERIFICA\$1DI\$1CARD |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Generate = true\$1, \$1Generate = true, Verify = true\$1 | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CHIAVE\$1DI\$1CARD\$1VERIFICA\$1DI\$1CARD |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Generate = true\$1, \$1Generate = true, Verify = true\$1 | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1ALTRO |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1= vero\$1 DeriveKey  | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E4\$1EMV\$1MKEY\$1NUMERI\$1DINAMICI |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1= vero\$1 DeriveKey  | 
| GenerateCardData |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1ALTRO |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1= vero\$1 DeriveKey  | 

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


| Operazione o algoritmo crittografico | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CHIAVE\$1CARD\$1VERIFICA\$1DI\$1CARD |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Generate = true\$1, \$1Generate = true, Verify = true\$1 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1C0\$1CHIAVE\$1DI\$1CARD\$1VERIFICA\$1DI\$1CARD |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1Generate = true\$1, \$1Generate = true, Verify = true\$1 | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1ALTRO |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1= vero\$1 DeriveKey  | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E4\$1EMV\$1MKEY\$1NUMERI\$1DINAMICI |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1= vero\$1 DeriveKey  | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | TR31\$1E6\$1EMV\$1MKEY\$1ALTRO |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | \$1= vero\$1 DeriveKey  | 

## GeneratePinData (per VISA/ABA schemi)
<a name="w2aac15c31c15"></a>

`VISA_PIN or VISA_PIN_VERIFICATION_VALUE`


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave di crittografia PIN  |  TR31\$1P0\$1PIN\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave di generazione del PIN  |  TR31\$1V2\$1VISA\$1PIN\$1VERIFICATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

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

`IBM3624_PIN_OFFSET,IBM3624_NATURAL_PIN,IBM3624_RANDOM_PIN, IBM3624_PIN_FROM_OFFSET)`


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave di crittografia PIN  |  TR31\$1P0\$1PIN\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  Per IBM3624 \$1NATURAL\$1PIN, \$1RANDOM\$1PIN, \$1PIN\$1FROM\$1OFFSET IBM3624 IBM3624 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) Per IBM3624 \$1PIN\$1OFFSET [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  Chiave di generazione del PIN  |  TR31\$1V1\$1 \$1CHIAVE\$1PIN\$1VERIFICA IBM3624  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## VerifyPinData (per VISA/ABA schemi)
<a name="w2aac15c31c21"></a>

`VISA_PIN`


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave di crittografia PIN  |  TR31\$1P0\$1PIN\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave di generazione del PIN  |  TR31\$1V2\$1VISA\$1PIN\$1VERIFICATION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

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

`IBM3624_PIN_OFFSET,IBM3624_NATURAL_PIN,IBM3624_RANDOM_PIN, IBM3624_PIN_FROM_OFFSET)`


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave di crittografia PIN  |  TR31\$1P0\$1PIN\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  Per IBM3624 \$1NATURAL\$1PIN, \$1RANDOM\$1PIN, \$1PIN\$1FROM\$1OFFSET IBM3624 IBM3624 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  Chiave di verifica del PIN  |  TR31\$1V1\$1 \$1CHIAVE\$1PIN\$1VERIFICA IBM3624  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Decrittografia dei dati
<a name="w2aac15c31c27"></a>


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  DISCARICA  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY\$1  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  EMV  |  TR31\$1E1\$1EMV\$1MKEY\$1RISERVATEZZA TR31\$1E6\$1EMV\$1MKEY\$1ALTRO  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  RSA  |  TR31\$1D1\$1CHIAVE\$1ASIMMETRICA PER LA CRITTOGRAFIA DEI DATI  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiavi simmetriche  |  TR31\$1D0\$1SYMMETRIC\$1DATA\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Encrypt Data (Crittografa dati)
<a name="w2aac15c31c33"></a>


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  DISCARICA  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY\$1  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  EMV  |  TR31\$1E1\$1EMV\$1MKEY\$1RISERVATEZZA TR31\$1E6\$1EMV\$1MKEY\$1ALTRO  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  | 
|  RSA  |  TR31\$1D1\$1CHIAVE\$1ASIMMETRICA PER LA CRITTOGRAFIA DEI DATI  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiavi simmetriche  |  TR31\$1D0\$1SYMMETRIC\$1DATA\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Traduci PIN Data
<a name="w2aac15c31c39"></a>


| Direzione | Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | --- | 
|  Fonte di dati in entrata  |  DUMPT  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY\$1  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Fonte di dati in entrata  |  Non DUPPT (PEK, AWK, IWK, ecc.)  |  TR31CHIAVE\$1CRITTO\$1P0\$1PIN\$1ENCRYPTION\$1  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Target dati in uscita  |  DUPPT  |  TR31\$1B0\$1BASE\$1DERIVATION\$1KEY\$1  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Target dati in uscita  |  Non DUPPT (PEK, IWK, AWK, ecc.)  |  TR31CHIAVE\$1CRITTO\$1P0\$1PIN\$1ENCRYPTION\$1  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Genera/verifica MAC
<a name="crypto-ops-validkeys.generatemac"></a>

 Le chiavi MAC vengono utilizzate per creare hash crittografici di un gruppo di dati. message/body Non è consigliabile creare una chiave con modalità di utilizzo limitate in quanto non sarà possibile eseguire l'operazione di abbinamento. Tuttavia, è possibile import/export utilizzare una chiave con una sola operazione se l'altro sistema è destinato a eseguire l'altra metà della coppia di operazioni. 


| Utilizzo delle chiavi consentito | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave MAC   |  TR31\$1M1\$1ISO\$19797\$11\$1MAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave MAC (MAC per la vendita al dettaglio)   |  TR31\$1M1\$1ISO\$19797\$13\$1MAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave MAC (CMAC)   |  TR31\$1M6\$1ISO\$19797\$15\$1CMAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave MAC (HMAC)   |  TR31CHIAVE\$1M7 HMAC  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave MAC (AS2805)   |  TR31\$1M0\$1ISO\$116609\$1MAC\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

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

 GenerateMacEmvPinChange combina la generazione di MAC e la crittografia del PIN per le operazioni di modifica del PIN offline EMV. Questa operazione richiede due diversi tipi di chiave: una chiave di integrità per la generazione di MAC e una chiave di riservatezza per la crittografia del PIN. 


| Tipo di chiavi | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave di integrità della messaggistica sicura   |  TR31\$1E2\$1EMV\$1MKEY\$1INTEGRITY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave di riservatezza della messaggistica sicura   |  TR31\$1E1\$1EMV\$1MKEY\$1RISERVATEZZA  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  PIN PEK attuale (chiave di crittografia PIN)   |  TR31\$1P0\$1PIN\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Nuovo PIN PEK (chiave di crittografia PIN)   |  TR31\$1P0\$1PIN\$1ENCRYPTION\$1KEY  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave ARQC   Si applica solo agli schemi di derivazione Visa e Amex.   |  TR31\$1E0\$1EMV\$1MKEY\$1APP\$1CRYPTOGRAMS  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

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


| Utilizzo delle chiavi consentito | Opzione EMV | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  TR31\$1E0\$1EMV\$1MKEY\$1APP\$1CRYPTOGRAMS  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Chiave Import/Export
<a name="crypto-ops-validkeys.importexport"></a>


| Tipo di operazione | Utilizzo delle chiavi consentito | Algoritmo a chiave consentito | Combinazione consentita delle principali modalità di utilizzo | 
| --- | --- | --- | --- | 
|  Chiave avvolgente TR-31  |  TR31CHIAVE\$1BLOCK\$1PROTEZIONE\$1K1\$1CHIAVE\$1BLOCK\$1PROTEZIONE\$1 TR31CHIAVE\$1CHIAVE\$1K0\$1CRITTOGRAFIE  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Importazione di CA attendibili  |  TR31\$1S0\$1CHIAVE\$1ASIMMETRICA PER FIRMA\$1DIGITALE  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Importazione di un certificato a chiave pubblica per la crittografia asimmetrica  |  TR31\$1D1\$1KEY\$1ASYMMETRIC\$1FOR\$1DATA\$1ENCRYPTION  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 
|  Chiave utilizzata per algoritmi di accordo chiave come ECDH  |  TR31\$1K3\$1CHIAVE\$1ASIMMETRICA\$1FOR\$1KEY\$1AGREEMENT  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html) | 

## Tipi di chiavi non utilizzati
<a name="w2aac15c31c57"></a>

I seguenti tipi di chiave non sono attualmente utilizzati da AWS Payment Cryptography
+  TR31\$1P1\$1PIN\$1GENERATION\$1KEY