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à. # Calcolo delle firme per l'intestazione di autorizzazione: trasferimento del payload in un unico blocco (AWS Signature (versione 4) Quando si utilizza l'`Authorization`intestazione per autenticare le richieste, il valore dell'intestazione include, tra le altre cose, una firma. I calcoli della firma variano a seconda della scelta effettuata per il trasferimento del payload (). [Panoramica di](sigv4-auth-using-authorization-header.md#sigv4-auth-header-overview) Questa sezione spiega i calcoli delle firme quando si sceglie di trasferire il payload in un unico blocco. La sezione di esempio (vedi[Esempi: Calcoli delle firme](#example-signature-calculations)) mostra i calcoli delle firme e le `Authorization` intestazioni risultanti che puoi utilizzare come suite di test per verificare il codice. **Importante** Quando trasferisci il payload in un unico blocco, puoi opzionalmente scegliere di includere l'hash del payload nei calcoli della firma, denominato payload * firmato * (se non lo includi, il payload è considerato non firmato). * * La procedura di firma illustrata nella sezione seguente si applica a entrambi, ma notate le seguenti differenze: **Opzione di payload firmato**: includi l'hash del payload quando crei la richiesta canonica (che poi ne diventa parte integrante StringToSign, come spiegato nella sezione sul calcolo della firma). Inoltre, specificate lo stesso valore dell'`x-amz-content-sha256`intestazione quando inviate la richiesta a S3. **Opzione di payload non firmato**: includi la stringa letterale `UNSIGNED-PAYLOAD` quando crei una richiesta canonica e imposti lo stesso valore dell'`x-amz-content-sha256`intestazione quando invii la richiesta ad Amazon S3. Quando invii la tua richiesta ad Amazon S3, il valore dell'`x-amz-content-sha256`intestazione indica ad Amazon S3 se il payload è firmato o meno. Amazon S3 può quindi creare la firma di conseguenza per la verifica. In entrambi i casi, poiché il valore dell'`x-amz-content-sha256`intestazione fa già parte dell'intestazione`HashedPayload`, non è necessario includerla come `x-amz-content-sha256` intestazione canonica. ## Calcolo di una firma Per calcolare una firma, occorre una stringa da firmare. Quindi si calcola un `HMAC-SHA256` hash della stringa da firmare utilizzando una chiave di firma. Il diagramma seguente illustra il processo, inclusi i vari componenti della stringa creata per la firma Quando Amazon S3 riceve una richiesta autenticata, calcola la firma e la confronta con la firma fornita nella richiesta. Per questo motivo, è necessario calcolare la firma utilizzando lo stesso metodo utilizzato da Amazon S3. Il processo di invio di una richiesta in un modulo concordato per la firma è chiamato canonicalizzazione. ![AWS4-HMAC-SHA256 diagramma del processo di firma che mostra la richiesta canonica e le fasi di firma. StringToSign](https://docs.aws.amazon.com/it_it/AmazonS3/latest/developerguide/images/sigV4-using-auth-header.png) La tabella seguente descrive le funzioni mostrate nel diagramma. Per queste funzioni devi implementare il codice. | Funzione | Description | | --- | --- | | Lowercase() | Converte la stringa in minuscolo. | | Hex() | Codifica in base 16 minuscola. | | SHA256Hash() | Funzione hash crittografica Secure Hash Algorithm (SHA). | | HMAC-SHA256() | Calcola HMAC utilizzando l'algoritmo SHA256 con la chiave di firma fornita. Questa è la firma definitiva. | | Trim() | Rimuove eventuali spazi bianchi all'inizio o alla fine della stringa. | | UriEncode() | L'URI codifica ogni byte. UriEncode() deve applicare le seguenti regole:+ L'URI codifica ogni byte tranne i caratteri senza riserve: 'A'-'Z', 'a'-'z', '0'-'9', '-', ' . ','\_' e '\~'.
+ Il carattere di spazio è un carattere riservato e deve essere codificato come "%20" (e non come "\+").
+ Ogni byte codificato in URI è formato da una '%' e dal valore esadecimale a due cifre del byte.
+ Le lettere nel valore esadecimale devono essere maiuscole, ad esempio "%1A".
+ Codifica la barra, '/', ovunque tranne nel nome della chiave dell'oggetto. Ad esempio, se il nome della chiave dell'oggetto è `photos/Jan/sample.jpg`, la barra nel nome della chiave non è codificata. Le UriEncode funzioni standard fornite dalla piattaforma di sviluppo potrebbero non funzionare a causa delle differenze di implementazione e della relativa ambiguità nelle RFC sottostanti. Ti consigliamo di scrivere una UriEncode funzione personalizzata per assicurarti che la codifica funzioni.
Di seguito è riportata una funzione example UriEncode () in Java.
public static String UriEncode(CharSequence input, boolean encodeSlash) {
          StringBuilder result = new StringBuilder();
          for (int i = 0; i < input.length(); i++) {
              char ch = input.charAt(i);
              if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '-' || ch == '~' || ch == '.') {
                  result.append(ch);
              } else if (ch == '/') {
                  result.append(encodeSlash ? "%2F" : ch);
              } else {
                  result.append(toHexUTF8(ch));
              }
          }
          return result.toString();
      }
| ### Fase 1. Creazione di una richiesta canonica Questa sezione fornisce una panoramica sulla creazione di una richiesta canonica. Di seguito è riportato il formato di richiesta canonico utilizzato da Amazon S3 per calcolare una firma. Affinché le firme corrispondano, devi creare una richiesta canonica in questo formato: ``` {{}}\n {{}}\n {{}}\n {{}}\n {{}}\n {{}} ``` Dove: + {{HTTPMethod}}è uno dei metodi HTTP, ad esempio GET, PUT, HEAD e DELETE. + {{CanonicalURI}}è la URI-encoded versione del componente di percorso assoluto dell'URI: tutto ciò che inizia con «/» che segue il nome di dominio e arriva alla fine della stringa o al carattere del punto interrogativo ('?') se disponi di parametri della stringa di interrogazione. L'URI nell'esempio seguente, `/examplebucket/myphoto.jpg`, è il percorso assoluto e non devi codificare "/" nel percorso assoluto: ``` http://s3.amazonaws.com/examplebucket/myphoto.jpg ``` **Nota** Non si normalizzano i percorsi URI per le richieste ad Amazon S3. Ad esempio, potresti avere un bucket con un oggetto chiamato «my-object//example//photo.user». La normalizzazione del percorso modifica il nome dell'oggetto nella richiesta in «my- /photo.user». object/example Questo è un percorso errato per quell'oggetto. + {{CanonicalQueryString}}specifica i parametri della stringa di URI-encoded interrogazione. I URI-encode nomi e i valori vengono assegnati singolarmente. È inoltre necessario ordinare i parametri nella stringa di query canonica in ordine alfabetico in base al nome della chiave. L'ordinamento avviene dopo la codifica. La stringa di query nel seguente esempio di URI è`prefix=somePrefix&marker=someMarker&max-keys=20`: ``` http://s3.amazonaws.com/examplebucket?prefix=somePrefix&marker=someMarker&max-keys=20 ``` La stringa di query canonica è la seguente (le interruzioni di riga vengono aggiunte a questo esempio a fini di leggibilità): ``` UriEncode("marker")+"="+UriEncode("someMarker")+"&"+ UriEncode("max-keys")+"="+UriEncode("20") + "&" + UriEncode("prefix")+"="+UriEncode("somePrefix") ``` Quando una richiesta ha come target una sottorisorsa, il valore del parametro di query corrispondente sarà una stringa vuota (""). Ad esempio, il seguente URI identifica la sottorisorsa `ACL` sul bucket `examplebucket`: ``` http://s3.amazonaws.com/examplebucket?acl ``` CanonicalQueryString In questo caso è la seguente: ``` UriEncode("acl") + "=" + "" ``` Se l'URI non include un '?', la richiesta non contiene una stringa di query e occorre impostare la stringa di query canonica su una stringa vuota (""). Dovrai comunque includere "\\n". + {{CanonicalHeaders}}è un elenco di intestazioni delle richieste con i relativi valori. Le singole coppie di nome e valore dell'intestazione sono separate dal carattere di nuova riga ("\\n"). I nomi delle intestazioni devono essere in minuscolo. È necessario ordinare alfabeticamente i nomi delle intestazioni per creare la stringa, come mostrato nell'esempio seguente: ``` Lowercase({{}})+":"+Trim({{}})+"\n" Lowercase({{}})+":"+Trim({{}})+"\n" ... Lowercase({{}})+":"+Trim({{}})+"\n" ``` Le funzioni `Lowercase()` e `Trim()` utilizzate in questo esempio sono descritte nella sezione precedente. L'{{CanonicalHeaders}}elenco deve includere quanto segue: + Intestazione `host` HTTP. + Se l'`Content-MD5`intestazione è presente nella richiesta, è necessario aggiungerla all'{{CanonicalHeaders}}elenco. + Devi aggiungere anche qualsiasi intestazione `x-amz-*` che desideri includere nella richiesta. Ad esempio, se utilizzi credenziali di sicurezza temporanee, nella tua richiesta devi includere `x-amz-security-token`. È necessario aggiungere questa intestazione nell'elenco di. {{CanonicalHeaders}} **Nota** L'`x-amz-content-sha256`intestazione è obbligatoria per tutte le richieste di AWS Signature Version 4. Fornisce un hash del payload di richiesta. Tuttavia, non è necessario includerla `x-amz-content-sha256` come intestazione canonica perché S3 utilizzerà automaticamente il suo valore nel calcolo dell'hash del payload inviato nella richiesta. Se non è presente alcun payload, devi indicare l'hash di una stringa vuota. Se non vuoi che S3 controlli l'hash della richiesta, puoi invece utilizzare la stringa letterale. `"UNSIGNED-PAYLOAD"` Le seguenti sono stringhe di esempio. `CanonicalHeaders` I nomi di intestazione sono in caratteri minuscoli e in ordine alfabetico. **Example Esempio 1** ``` host:s3.amazonaws.com x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 x-amz-date:20130708T220855Z ``` **Example Esempio 2** ``` host:s3.amazonaws.com x-amz-content-sha256:UNSIGNED-PAYLOAD x-amz-date:20130708T220855Z ``` **Example Esempio 3** ``` host:s3.amazonaws.com x-amz-date:20130708T220855Z ``` **Nota** Ai fini del calcolo di una firma di autorizzazione, sono obbligatori l'intestazione dell'host e tutte le `x-amz-*` intestazioni, escluse`x-amz-content-sha256`. Tuttavia, per prevenire la manomissione dei dati, dovresti considerare di includere tutte le intestazioni nel calcolo della firma. La firma dell'`x-amz-content-sha256`intestazione è facoltativa perché S3 utilizzerà il suo valore per calcolare l'hash del payload della richiesta ricevuta. + {{SignedHeaders}}è un elenco in ordine alfabetico e separato da punto e virgola di nomi di intestazione delle richieste in lettere minuscole. Le intestazioni della richiesta nell'elenco sono le stesse che hai incluso nella stringa `CanonicalHeaders`. Negli esempi precedenti, il valore di sarebbe il seguente: {{SignedHeaders}} **Example Esempi 1 e 2** ``` host;x-amz-content-sha256;x-amz-date ``` **Example Esempio 3** ``` host;x-amz-date ``` + {{HashedPayload}}è il valore esadecimale dell'hash SHA256 del payload della richiesta. ``` Hex(SHA256Hash({{}}) ``` Se non è presente alcun payload nella richiesta, calcola un hash della stringa vuota come segue: ``` Hex(SHA256Hash("")) ``` L’hash restituisce i seguenti valori: ``` e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Ad esempio, quando carichi un oggetto utilizzando una richiesta PUT, fornisci i dati dell'oggetto nel corpo. Quando si recupera un oggetto utilizzando una richiesta GET, si calcola l'hash della stringa vuota. ### Fase 2: creazione di una stringa di firma Questa sezione fornisce una panoramica sulla creazione di una stringa da firmare. Per istruzioni dettagliate, vedi [ Attività 2: Creare una stringa per accedere ](https://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html) al. *Riferimenti generali di AWS* La stringa da firmare è una concatenazione delle seguenti stringhe: ``` "AWS4-HMAC-SHA256" + "\n" + timeStampISO8601Format + "\n" + {{}} + "\n" + Hex(SHA256Hash({{}})) ``` La stringa costante `AWS4-HMAC-SHA256` specifica l'algoritmo hash che stai utilizzando,. HMAC-SHA256 `timeStamp`È l'ora UTC corrente nel formato ISO 8601 (ad esempio,). `20130524T000000Z` `Scope`lega la firma risultante a una data, una data e un servizio Regione AWS specifici. Pertanto, la firma risultante funzionerà solo nella regione specifica e per un servizio specifico. La firma è valida per sette giorni dopo la data specificata. ``` date.Format({{}}) + "/" + {{}} + "/" + {{}} + "/aws4_request" ``` Per Amazon S3, la stringa di servizio è`s3`. Per un elenco di {{region}} stringhe, consulta [ Regioni ed endpoint ](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in. *Riferimenti generali di AWS* La colonna Regione in questa tabella fornisce l'elenco delle stringhe Region valide. L'ambito seguente limita la firma risultante alla `us-east-1` regione e ad Amazon S3. ``` 20130606/us-east-1/s3/aws4_request ``` **Nota** `Scope`deve utilizzare la stessa data utilizzata per calcolare la chiave di firma, come illustrato nella sezione seguente. ### Attività 3: Calcolare la firma Nella versione 4 di AWS Signature, invece di utilizzare le chiavi di AWS accesso per firmare una richiesta, è necessario creare innanzitutto una chiave di firma con ambito per una regione e un servizio specifici.  Per ulteriori informazioni sulla firma delle chiavi, consulta[Introduzione alla firma delle richieste](sig-v4-authenticating-requests.md#signing-request-intro). ``` DateKey = HMAC-SHA256("AWS4"+"{{}}", "{{}}") DateRegionKey = HMAC-SHA256({{}}, "{{}}") DateRegionServiceKey = HMAC-SHA256({{}}, "{{}}") SigningKey = HMAC-SHA256({{}}, "aws4_request") ``` **Nota** Alcuni casi d'uso possono elaborare le chiavi di firma per un massimo di 7 giorni. Per ulteriori informazioni, consulta [ Condividere un oggetto con altri](https://docs.aws.amazon.com/AmazonS3/latest/dev/ShareObjectPreSignedURL.html). Per un elenco delle stringhe di regione, vedi [ Regioni ed endpoint ](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in. *Riferimenti generali di AWS* L'utilizzo di una chiave di firma consente di conservare le AWS credenziali in un unico posto sicuro. Ad esempio, se hai più server che comunicano con Amazon S3, condividi la chiave di firma con quei server; non devi conservare una copia della tua chiave di accesso segreta su ogni server. La chiave di firma è valida per un massimo di sette giorni. Quindi, ogni volta che calcoli la chiave di firma, dovrai condividerla con i tuoi server. Per ulteriori informazioni, consulta [Autenticazione delle richieste (AWS Signature (versione 4)](sig-v4-authenticating-requests.md). La firma finale è l' HMAC-SHA256 hash della stringa da firmare, utilizzando la chiave di firma come chiave. ``` HMAC-SHA256(SigningKey, StringToSign) ``` Per istruzioni dettagliate sulla creazione di una firma, vedi [ Attività 3: Creare una firma in. ](https://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html) *Riferimenti generali di AWS* ### Esempi: Calcoli delle firme È possibile utilizzare gli esempi in questa sezione come riferimento per controllare i calcoli delle firme nel codice. I calcoli mostrati negli esempi utilizzano i seguenti dati: + Esempi di chiavi di accesso. [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/AmazonS3/latest/developerguide/sig-v4-header-based-auth.html) + Richiedi il timestamp di 20130524T000000Z (). `Fri, 24 May 2013 00:00:00 GMT` + Nome `examplebucket` del secchio. + Si presume che il bucket si trovi nella regione degli Stati Uniti orientali (Virginia settentrionale). La credenziale `Scope` e i `Signing Key` calcoli vengono utilizzati `us-east-1` come identificatore della regione. Per informazioni su altre regioni, vedere [ Regioni ed endpoint ](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) nel *Riferimenti generali di AWS*. + È possibile utilizzare richieste in stile path o in stile host virtuale. Gli esempi seguenti mostrano come firmare una richiesta in stile host virtuale, 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. * #### Esempio: GET Object L'esempio seguente ottiene i primi 10 byte di un oggetto (test.txt) da`examplebucket`. Per ulteriori informazioni sull'azione API, consulta [ GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html). ``` GET /test.txt HTTP/1.1 Host: examplebucket.s3.amazonaws.com Authorization: {{SignatureToBeCalculated}} Range: bytes=0-9 x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 x-amz-date: 20130524T000000Z ``` Poiché questa richiesta GET non fornisce alcun contenuto, il `x-amz-content-sha256` valore può essere l'hash del corpo della richiesta vuoto o la stringa letterale. `"UNSIGNED-PAYLOAD"` I passaggi seguenti mostrano i calcoli delle firme e la costruzione dell'`Authorization`intestazione utilizzando l'hash di una stringa vuota. 1. **StringToSign** 1. **CanonicalRequest** ``` GET /test.txt host:examplebucket.s3.amazonaws.com range:bytes=0-9 x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 x-amz-date:20130524T000000Z host;range;x-amz-content-sha256;x-amz-date e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Nella stringa di richiesta canonica, l'ultima riga è l'hash del corpo vuoto della richiesta. La terza riga è vuota perché non ci sono parametri di interrogazione nella richiesta. 1. **StringToSign** ``` AWS4-HMAC-SHA256 20130524T000000Z 20130524/us-east-1/s3/aws4_request 7344ae5b7ee6c3e7e6b0fe0640412a37625d1fbfff95c48bbb2dc43964946972 ``` 1. **SigningKey** ``` signing key = HMAC-SHA256(HMAC-SHA256(HMAC-SHA256(HMAC-SHA256("AWS4" + "{{}}","20130524"),"us-east-1"),"s3"),"aws4_request") ``` 1. **Firma** ``` f0e8bdb87c964420e857bd35b5d6ed310bd44f0170aba48dd91039c6036bdb41 ``` 1. **Intestazione di autorizzazione** L'`Authorization`intestazione risultante è la seguente: ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=host;range;x-amz-content-sha256;x-amz-date,Signature=f0e8bdb87c964420e857bd35b5d6ed310bd44f0170aba48dd91039c6036bdb41 ``` #### Esempio: oggetto PUT Questo esempio di richiesta PUT crea un oggetto (`test$file.text`) in`examplebucket`. L'esempio presuppone quanto segue: + Stai richiedendo `REDUCED_REDUNDANCY` come classe di archiviazione aggiungendo l'intestazione della `x-amz-storage-class` richiesta. Per informazioni sulle classi di storage, consulta [ Storage Classes ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html#storage-class-intro) nella * Amazon Simple Storage Service User Guide. * + Il contenuto del file caricato è una stringa. `"Welcome to Amazon S3."` Il valore di `x-amz-content-sha256` nella richiesta si basa su questa stringa. Per informazioni sull'azione API, consulta [ PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html). ``` PUT test$file.text HTTP/1.1 Host: examplebucket.s3.amazonaws.com Date: Fri, 24 May 2013 00:00:00 GMT Authorization: {{SignatureToBeCalculated}} x-amz-date: 20130524T000000Z x-amz-storage-class: REDUCED_REDUNDANCY x-amz-content-sha256: 44ce7dd67c959e0d3524ffac1771dfbba87d2b6b4b4e99e42034a8b803f8b072 {{}} ``` I passaggi seguenti mostrano i calcoli delle firme. 1. **StringToSign** 1. **CanonicalRequest** ``` PUT /test%24file.text date:Fri, 24 May 2013 00:00:00 GMT host:examplebucket.s3.amazonaws.com x-amz-content-sha256:44ce7dd67c959e0d3524ffac1771dfbba87d2b6b4b4e99e42034a8b803f8b072 x-amz-date:20130524T000000Z x-amz-storage-class:REDUCED_REDUNDANCY date;host;x-amz-content-sha256;x-amz-date;x-amz-storage-class 44ce7dd67c959e0d3524ffac1771dfbba87d2b6b4b4e99e42034a8b803f8b072 ``` Nella richiesta canonica, la terza riga è vuota perché nella richiesta non sono presenti parametri di interrogazione. L'intestazione `x-amz-content-sha256` canonica può essere firmata facoltativamente poiché l'hash del payload è già fornito nella parte inferiore della richiesta. L'ultima riga è l'hash del corpo, che deve essere uguale al `x-amz-content-sha256 header` valore inviato a S3 nella richiesta HTTP. 1. **StringToSign** ``` AWS4-HMAC-SHA256 20130524T000000Z 20130524/us-east-1/s3/aws4_request 9e0e90d9c76de8fa5b200d8c849cd5b8dc7a3be3951ddb7f6a76b4158342019d ``` 1. **SigningKey** ``` signing key = HMAC-SHA256(HMAC-SHA256(HMAC-SHA256(HMAC-SHA256("AWS4" + "{{}}","20130524"),"us-east-1"),"s3"),"aws4_request") ``` 1. **Firma** ``` 98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd ``` 1. **Intestazione di autorizzazione** L'`Authorization`intestazione risultante è la seguente: ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=date;host;x-amz-content-sha256;x-amz-date;x-amz-storage-class,Signature=98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd ``` #### Esempio: GET Bucket Lifecycle La seguente richiesta GET recupera la configurazione del ciclo di vita di. `examplebucket` Per informazioni sull'azione API, consulta. [ GetBucketLifecycleConfiguration ](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html) ``` GET ?lifecycle HTTP/1.1 Host: examplebucket.s3.amazonaws.com Authorization: {{SignatureToBeCalculated}} x-amz-date: 20130524T000000Z x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Poiché la richiesta non fornisce alcun contenuto del corpo, il valore dell'`x-amz-content-sha256`intestazione è l'hash del corpo della richiesta vuoto. I passaggi seguenti mostrano i calcoli delle firme. 1. **StringToSign** 1. **CanonicalRequest** ``` GET / lifecycle= host:examplebucket.s3.amazonaws.com x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 x-amz-date:20130524T000000Z host;x-amz-content-sha256;x-amz-date e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Nella richiesta canonica, l'ultima riga è l'hash del corpo della richiesta vuoto. 1. **StringToSign** ``` AWS4-HMAC-SHA256 20130524T000000Z 20130524/us-east-1/s3/aws4_request 9766c798316ff2757b517bc739a67f6213b4ab36dd5da2f94eaebf79c77395ca ``` 1. **SigningKey** ``` signing key = HMAC-SHA256(HMAC-SHA256(HMAC-SHA256(HMAC-SHA256("AWS4" + "{{}}","20130524"),"us-east-1"),"s3"),"aws4_request") ``` 1. **Firma** ``` fea454ca298b7da1c68078a5d1bdbfbbe0d65c699e0f91ac7a200a0136783543 ``` 1. **Intestazione di autorizzazione** L'`Authorization`intestazione risultante è la seguente: ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=host;x-amz-content-sha256;x-amz-date,Signature=fea454ca298b7da1c68078a5d1bdbfbbe0d65c699e0f91ac7a200a0136783543 ``` #### Esempio: Get Bucket (List Objects) L'esempio seguente recupera un elenco di oggetti dal `examplebucket` bucket. Per informazioni sull'azione API, consulta. [ ListObjects ](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html) ``` GET ?max-keys=2&prefix=J HTTP/1.1 Host: examplebucket.s3.amazonaws.com Authorization: {{SignatureToBeCalculated}} x-amz-date: 20130524T000000Z x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Poiché la richiesta non fornisce un corpo, il valore di `x-amz-content-sha256` è l'hash del corpo della richiesta vuoto. I passaggi seguenti mostrano i calcoli delle firme. 1. **StringToSign** 1. **CanonicalRequest** ``` GET / max-keys=2&prefix=J host:examplebucket.s3.amazonaws.com x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 x-amz-date:20130524T000000Z host;x-amz-content-sha256;x-amz-date e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Nella stringa canonica, l'ultima riga è l'hash del corpo vuoto della richiesta. 1. **StringToSign** ``` AWS4-HMAC-SHA256 20130524T000000Z 20130524/us-east-1/s3/aws4_request df57d21db20da04d7fa30298dd4488ba3a2b47ca3a489c74750e0f1e7df1b9b7 ``` 1. **SigningKey** ``` signing key = HMAC-SHA256(HMAC-SHA256(HMAC-SHA256(HMAC-SHA256("AWS4" + "{{}}","20130524"),"us-east-1"),"s3"),"aws4_request") ``` 1. **Firma** ``` 34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7 ``` 1. **Intestazione di autorizzazione** L'`Authorization`intestazione risultante è la seguente: ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=host;x-amz-content-sha256;x-amz-date,Signature=34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7 ```