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à.
# Calcoli delle firme per le intestazioni finali (caricamenti in blocchi) (AWS Signature (versione 4)
Quando autentichi le richieste utilizzando l'`Authorization`intestazione, puoi anche caricare il payload in blocchi. Quando invii i dati per l'oggetto in blocchi, hai anche la possibilità di includere le intestazioni finali. Per ulteriori informazioni, consulta [Calcoli della firma per l'intestazione dell'autorizzazione: trasferimento del payload in più blocchi (caricamento in blocchi) (AWS Signature (versione 4)](sigv4-streaming.md). Questa sezione descrive i passaggi da eseguire per includere un'intestazione finale alla fine del caricamento di più blocchi.
**Importante**
Quando includi le intestazioni finali, devi inviare quanto segue nell'intestazione iniziale:
È necessario `x-amz-content-sha256` impostare un valore appropriato che indichi che verrà incluso un trailer. Per vedere i valori accettabili per`x-amz-content-sha256`, consulta[Autenticazione delle richieste: utilizzo dell'intestazione di autorizzazione (AWS Signature (versione 4)](sigv4-auth-using-authorization-header.md).
Devi `x-amz-trailer` impostarlo in modo da indicare i contenuti che includi nell'intestazione finale.
Le intestazioni finali vengono inviate solo dopo che i blocchi sono stati caricati. I blocchi precedenti vengono inviati normalmente e firmati come descritto nelle sezioni precedenti, incluso l'invio del blocco finale con un payload di 0 byte. Le intestazioni finali vengono incluse come blocco a sé stante e inviate dopo il blocco finale con un payload di 0 byte. Ad esempio, se i tuoi dati terminano con un blocco di 100 KB, invierai quanto segue:
+ Blocchi di dati precedenti
+ Parte finale dell'oggetto da 100 KB
+ Blocco da 0 byte che indica la fine dell'oggetto
+ Blocco di intestazioni finali
## Esempi: controllo dei calcoli delle firme
È possibile utilizzare gli esempi in questa sezione come riferimento per controllare i calcoli delle firme nel codice. Prima di esaminare gli esempi, tenete presente quanto segue:
+ I calcoli delle firme in questi esempi utilizzano le seguenti credenziali di sicurezza di esempio.
Parametro
Valore
AWSAccessKeyId
AKIAIOSFODNN7EXAMPLE
AWSSecretAccessKey
wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+ Tutti gli esempi utilizzano il timestamp della richiesta 20130524T000000Z (). `Fri, 24 May 2013 00:00:00 GMT`
+ Tutti `examplebucket` gli esempi utilizzano come nome del bucket.
+ Si presume che il bucket si trovi nella regione Stati Uniti orientali (Virginia settentrionale) e le credenziali `Scope` e i `Signing Key` calcoli vengono utilizzati `us-east-1` come identificatore della regione. Per ulteriori informazioni, consulta la pagina relativa a [regioni ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) nei *Riferimenti generali di Amazon Web Services*.
+ Puoi utilizzare lo stile del percorso o le richieste di stile ospitate virtualmente. Gli esempi seguenti utilizzano richieste di stile ospitate virtualmente, ad esempio:
```
https://examplebucket.s3.amazonaws.com/photos/photo1.jpg
```
Per ulteriori informazioni, consulta [ Virtual Hosting of Buckets ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html) nella * Amazon Simple Storage Service User Guide. *
L'esempio seguente invia una `PUT` richiesta per caricare un oggetto. I calcoli delle firme presuppongono quanto segue:
+ Stai caricando un file di testo da 65 KB e il contenuto del file è una stringa di un carattere composta dalla lettera «a».
+ La dimensione del blocco è 64 KB. Di conseguenza, il payload viene caricato in tre blocchi, 64 KB, 1 KB e l'ultimo blocco con 0 byte di dati in blocco.
+ L'oggetto risultante ha il nome della chiave. `chunkObject.txt`
+ La richiesta viene effettuata `REDUCED_REDUNDANCY` come classe di archiviazione aggiungendo l'intestazione della `x-amz-storage-class` richiesta.
+ Il trasferimento include un valore di checksum CRC32C come intestazione finale.
Per informazioni sull'azione API, consulta. [ PutObject ](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) La sintassi generale della richiesta è la seguente:
```
PUT /examplebucket/chunkObject.txt HTTP/1.1
Host: s3.amazonaws.com
x-amz-date: 20130524T000000Z
x-amz-storage-class: REDUCED_REDUNDANCY
Authorization: {{SignatureToBeCalculated}}
x-amz-content-sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
Content-Encoding: aws-chunked
x-amz-decoded-content-length: 66560
x-amz-trailer: x-amz-checksum-crc32c
Content-Length: 66946
{{}}
```
I passaggi seguenti mostrano i calcoli delle firme.
1.
**Firma iniziale: crea una stringa da firmare**
1.
**CanonicalRequest**
```
PUT
/examplebucket/chunkObject.txt
content-encoding:aws-chunked
host:s3.amazonaws.com
x-amz-content-sha256:STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
x-amz-date:20130524T000000Z
x-amz-decoded-content-length:66560
x-amz-storage-class:REDUCED_REDUNDANCY
x-amz-trailer:x-amz-checksum-crc32c
content-encoding;host;x-amz-content-sha256;x-amz-date;x-amz-decoded-content-length;x-amz-storage-class;x-amz-trailer
STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
```
Nella richiesta canonica, la terza riga è vuota perché nella richiesta non sono presenti parametri di interrogazione. L'ultima riga è la stringa costante fornita come valore del Payload con hash, che deve essere uguale al valore di. `x-amz-content-sha256 header`
1.
**StringToSign**
```
AWS4-HMAC-SHA256
20130524T000000Z
20130524/us-east-1/s3/aws4_request
44d48b8c2f70eae815a0198cc73d7a546a73a93359c070abbaa5e6c7de112559
```
**Nota**
Per informazioni su ciascuna riga della stringa da firmare, consulta il diagramma che spiega il calcolo della firma iniziale.
1.
**SigningKey**
```
signing key = HMAC-SHA256(HMAC-SHA256(HMAC-SHA256(HMAC-SHA256("AWS4" + "{{}}","20130524"),"us-east-1"),"s3"),"aws4_request")
```
1.
**Firma del seme**
```
106e2a8a18243abcf37539882f36619c00e2dfc72633413f02d3b74544bfeb8e
```
1.
**Intestazione di autorizzazione**
L'intestazione di autorizzazione risultante è la seguente:
```
AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=content-encoding;content-length;host;x-amz-content-sha256;x-amz-date;x-amz-decoded-content-length;x-amz-storage-class,Signature=106e2a8a18243abcf37539882f36619c00e2dfc72633413f02d3b74544bfeb8e
```
1.
**Blocco 1: (65536 byte, con valore 97 per la lettera «a»)**
1. Stringa in blocchi da firmare:
```
AWS4-HMAC-SHA256-PAYLOAD
20130524T000000Z
20130524/us-east-1/s3/aws4_request
106e2a8a18243abcf37539882f36619c00e2dfc72633413f02d3b74544bfeb8e
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
bf718b6f653bebc184e1479f1935b8da974d701b893afcf49e701f3e2f9f9c5a
```
**Nota**
Per informazioni su ogni riga della stringa da firmare, vedete il diagramma nell'argomento precedente ([Calcolo della firma iniziale](sigv4-streaming.md#sigv4-chunked-upload-sig-calculation-chunk0)) che mostra i vari componenti della stringa da firmare. Ad esempio, le ultime tre righe sono costituite da quanto segue:
{{previous-signature}}
`hash("")`
`hash({{current-chunk-data}})`
1. Firma in blocco:
```
b474d8862b1487a5145d686f57f013e54db672cee1c953b3010fb58501ef5aa2
```
1. Dati in blocco inviati:
```
10000;chunk-signature=b474d8862b1487a5145d686f57f013e54db672cee1c953b3010fb58501ef5aa2
<65536-bytes>
```
1.
**Blocco 2: (1024 byte, con valore 97 per la lettera «a»)**
1. Stringa in blocchi da firmare:
```
AWS4-HMAC-SHA256-PAYLOAD
20130524T000000Z
20130524/us-east-1/s3/aws4_request
b474d8862b1487a5145d686f57f013e54db672cee1c953b3010fb58501ef5aa2
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
2edc986847e209b4016e141a6dc8716d3207350f416969382d431539bf292e4a
```
1. Firma in blocco:
```
1c1344b170168f8e65b41376b44b20fe354e373826ccbbe2c1d40a8cae51e5c7
```
1. Dati in blocco inviati:
```
400;chunk-signature=1c1344b170168f8e65b41376b44b20fe354e373826ccbbe2c1d40a8cae51e5c7
<1024-bytes>
```
1.
**Blocco 3: (dati a 0 byte)**
1. Stringa in blocchi da firmare:
```
AWS4-HMAC-SHA256-PAYLOAD
20130524T000000Z
20130524/us-east-1/s3/aws4_request
1c1344b170168f8e65b41376b44b20fe354e373826ccbbe2c1d40a8cae51e5c7
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
```
1. Firma in blocco:
```
2ca2aba2005185cf7159c6277faf83795951dd77a3a99e6e65d5c9f85863f992
```
1. Dati in blocco inviati:
```
0;chunk-signature=2ca2aba2005185cf7159c6277faf83795951dd77a3a99e6e65d5c9f85863f992
```
1.
**Parte 4: intestazioni finali**
1. Stringa del trailer da firmare:
```
AWS4-HMAC-SHA256-TRAILER
20130524T000000Z
20130524/us-east-1/s3/aws4_request
2ca2aba2005185cf7159c6277faf83795951dd77a3a99e6e65d5c9f85863f992
1e376db7e1a34a8ef1c4bcee131a2d60a1cb62503747488624e10995f448d774
```
**Nota**
Le ultime due righe sono `previous-signature` (la firma del blocco di dati da 0 byte), `hash` ({{trailing-checksum-header-name}}: {{base64-encoded-trailing-checksum-value}}\\n).
L'hash viene calcolato come segue senza spazi bianchi:
Il nome dell'intestazione del checksum finale
I due punti () `:`
Il valore di checksum finale codificato in base64
Un carattere di nuova riga (). `\n`
In questo esempio, in cui si utilizza l'algoritmo `crc32c` hash, con il valore di checksum codificato in base64`sOO8/Q==`, è possibile rappresentare il calcolo come segue:. `hash('x-amz-checksum-crc32c:sOO8/Q==\n')`
1. Firma in blocchi:
```
d81f82fc3505edab99d459891051a732e8730629a2e4a59689829ca17fe2e435
```
1. Dati in blocco inviati:
```
x-amz-checksum-crc32c:sOO8/Q==
x-amz-trailer-signature:d81f82fc3505edab99d459891051a732e8730629a2e4a59689829ca17fe2e435
```