Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Calculs de signature pour l'en-tête d'autorisation : transfert de la charge utile en un seul bloc (AWS Signature (version 4) Lorsque vous utilisez l'`Authorization`en-tête pour authentifier des demandes, la valeur de l'en-tête inclut, entre autres, une signature. Les calculs de signature varient en fonction du choix que vous faites pour transférer la charge utile ([Vue d’ensemble](sigv4-auth-using-authorization-header.md#sigv4-auth-header-overview)). Cette section explique les calculs de signature lorsque vous choisissez de transférer la charge utile en un seul bloc. La section d'exemple (voir[Exemples : calculs de signature](#example-signature-calculations)) présente les calculs de signature et `Authorization` les en-têtes qui en résultent, que vous pouvez utiliser comme suite de tests pour vérifier votre code. **Important** Lorsque vous transférez une charge utile en un seul bloc, vous pouvez éventuellement choisir d'inclure le hachage de la charge utile dans les calculs de signature, appelé charge utile * signée * (si vous ne l'incluez pas, la charge utile est considérée comme non signée). * * La procédure de signature décrite dans la section suivante s'applique aux deux, mais notez les différences suivantes : **Option de charge utile signée ** : vous incluez le hachage de la charge utile lors de la création de la demande canonique (qui en fait ensuite partie intégrante StringToSign, comme expliqué dans la section sur le calcul de signature). Vous spécifiez également la même valeur que la valeur `x-amz-content-sha256` d'en-tête lors de l'envoi de la demande à S3. **Option de charge utile non signée ** : vous incluez la chaîne littérale `UNSIGNED-PAYLOAD` lors de la création d'une demande canonique et vous définissez la même valeur que la valeur d'`x-amz-content-sha256`en-tête lors de l'envoi de la demande à Amazon S3. Lorsque vous envoyez votre demande à Amazon S3, la valeur `x-amz-content-sha256` d'en-tête indique à Amazon S3 si la charge utile est signée ou non. Amazon S3 peut ensuite créer la signature en conséquence à des fins de vérification. Dans les deux cas, étant donné que la valeur de l'`x-amz-content-sha256`en-tête fait déjà partie de votre contenu`HashedPayload`, vous n'êtes pas obligé de l'inclure en tant qu'`x-amz-content-sha256`en-tête canonique. ## Calculer une signature Pour calculer une signature, vous avez d'abord besoin d'une chaîne à signer. Vous calculez ensuite le `HMAC-SHA256` hachage de la chaîne à signer à l'aide d'une clé de signature. Le schéma suivant illustre le processus, y compris les différents composants de la chaîne que vous créez pour la signature Lorsqu'Amazon S3 reçoit une demande authentifiée, il calcule la signature, puis la compare à la signature que vous avez fournie dans la demande. C'est pourquoi vous devez calculer la signature en utilisant la même méthode que celle utilisée par Amazon S3. Le processus qui consiste à présenter une demande sous une forme convenue pour la signature est appelé canonisation. ![AWS4-HMAC-SHA256 schéma du processus de signature montrant la demande canonique et StringToSign les étapes de signature.](https://docs.aws.amazon.com/fr_fr/AmazonS3/latest/developerguide/images/sigV4-using-auth-header.png) Le tableau suivant décrit les fonctions présentées dans le schéma. Vous devez implémenter du code pour ces fonctions. | Fonction | Description | | --- | --- | | Lowercase() | Convertit la chaîne en minuscules. | | Hex() | Encodage en minuscules en base 16. | | SHA256Hash() | Fonction de hachage cryptographique Secure Hash Algorithm (SHA, algorithme de hachage sécurisé). | | HMAC-SHA256() | Calcule HMAC à l'aide de l'algorithme SHA256 avec la clé de signature fournie. Il s'agit de la signature finale. | | Trim() | Supprimez tous les espaces blancs de début ou de fin. | | UriEncode() | L'URI code chaque octet. UriEncode() doit appliquer les règles suivantes :+ L'URI encode tous les octets sauf les caractères non réservés : A-Z, a-z, 0-9, -, ., \_ et \~.
+ Le caractère d'espace est un caractère réservé qui doit être codé sous la forme « %20 » (et non sous la forme « \+ »).
+ Chaque octet encodé par URI est formé par un « % » et la valeur hexadécimale à deux chiffres de l'octet.
+ Les lettres de la valeur hexadécimale doivent être en majuscules, par exemple « %1A ».
+ Encodez la barre oblique « / » partout sauf dans le nom de la clé de l'objet. Par exemple, si le nom de clé de l'objet est `photos/Jan/sample.jpg`, la barre oblique du nom de la clé n'est pas encodée. Les UriEncode fonctions standard fournies par votre plateforme de développement peuvent ne pas fonctionner en raison de différences d'implémentation et de l'ambiguïté associée dans les RFC sous-jacents. Nous vous recommandons d'écrire votre propre UriEncode fonction personnalisée pour garantir le bon fonctionnement de votre encodage.
Voici un exemple de fonction UriEncode () en 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();
      }
| ### Tâche 1 : créer une demande canonique Cette section fournit une vue d'ensemble de la création d'une demande canonique. Voici le format de demande canonique qu'Amazon S3 utilise pour calculer une signature. Pour que les signatures soient identiques, vous devez créer une requête canonique au format suivant : ``` {{}}\n {{}}\n {{}}\n {{}}\n {{}}\n {{}} ``` Où : + {{HTTPMethod}}est l'une des méthodes HTTP, par exemple GET, PUT, HEAD et DELETE. + {{CanonicalURI}}est la URI-encoded version du composant de chemin absolu de l'URI : tout ce qui commence par le «/» qui suit le nom de domaine et jusqu'à la fin de la chaîne ou jusqu'au point d'interrogation (« ? ») si vous avez des paramètres de chaîne de requête. L'URI de l'exemple suivant, `/examplebucket/myphoto.jpg`, est le chemin absolu et vous n'encodez pas la « / » dans le chemin absolu : ``` http://s3.amazonaws.com/examplebucket/myphoto.jpg ``` **Note** Vous ne normalisez pas les chemins d'URI pour les requêtes adressées à Amazon S3. Par exemple, vous pouvez avoir un compartiment contenant un objet nommé « my-object//example//photo.user ». La normalisation du chemin change le nom de l'objet dans la requête en « my- object/example /photo.user ». Il s'agit d'un chemin incorrect pour cet objet. + {{CanonicalQueryString}}spécifie les paramètres URI-encoded de chaîne de requête. Vous URI-encode nommez et valorisez individuellement. Vous devez également trier les paramètres de la chaîne de requête canonique par ordre alphabétique par nom de clé. Le tri s'effectue après l'encodage. La chaîne de requête dans l'exemple d'URI suivant est `prefix=somePrefix&marker=someMarker&max-keys=20` : ``` http://s3.amazonaws.com/examplebucket?prefix=somePrefix&marker=someMarker&max-keys=20 ``` La chaîne de requête canonique est la suivante (des sauts de ligne sont ajoutés à cet exemple pour faciliter la lecture) : ``` UriEncode("marker")+"="+UriEncode("someMarker")+"&"+ UriEncode("max-keys")+"="+UriEncode("20") + "&" + UriEncode("prefix")+"="+UriEncode("somePrefix") ``` Lorsqu'une requête cible une sous-ressource, la valeur du paramètre de requête correspondant est une chaîne vide (« »). Par exemple, l'URI suivant identifie la sous-ressource `ACL` sur le compartiment `examplebucket` : ``` http://s3.amazonaws.com/examplebucket?acl ``` CanonicalQueryString Dans ce cas, c'est le suivant : ``` UriEncode("acl") + "=" + "" ``` Si l'URI ne contient pas de « ? » , la demande ne contient aucune chaîne de requête et vous définissez la chaîne de requête canonique sur une chaîne vide (« »). Vous devrez tout de même inclure le « \\n ». + {{CanonicalHeaders}}est une liste d'en-têtes de requête avec leurs valeurs. Les paires de nom et de valeur d'en-tête individuelles sont séparées par le caractère de saut de ligne (« \\n »). Les noms d'en-tête doivent être en minuscules. Vous devez trier les noms d'en-tête par ordre alphabétique pour construire la chaîne, comme indiqué dans l'exemple suivant : ``` Lowercase({{}})+":"+Trim({{}})+"\n" Lowercase({{}})+":"+Trim({{}})+"\n" ... Lowercase({{}})+":"+Trim({{}})+"\n" ``` Les fonctions `Lowercase()` et `Trim()` utilisées dans cet exemple sont décrites dans la section précédente. La {{CanonicalHeaders}} liste doit inclure les éléments suivants : + En-tête `host` HTTP. + Si l'`Content-MD5`en-tête est présent dans la demande, vous devez l'ajouter à la {{CanonicalHeaders}} liste. + Les en-têtes `x-amz-*` que vous prévoyez d'inclure dans votre demande doivent également être ajoutés. Par exemple, si vous utilisez des informations d'identification de sécurité temporaires, vous devez inclure `x-amz-security-token` dans votre demande. Vous devez ajouter cet en-tête dans la liste des{{CanonicalHeaders}}. **Note** L'`x-amz-content-sha256`en-tête est obligatoire pour toutes les demandes AWS Signature Version 4. Il fournit un hachage de la charge utile de la requête. Cependant, vous n'êtes pas obligé d'inclure le `x-amz-content-sha256` en tant qu'en-tête canonique car S3 utilisera automatiquement sa valeur lors du calcul du hachage de la charge utile envoyé dans la demande. S'il n'y a pas de charge utile, vous devez fournir le hachage d'une chaîne vide. Si vous ne souhaitez pas que S3 vérifie le hachage de la demande, vous pouvez utiliser la chaîne littérale à la `"UNSIGNED-PAYLOAD"` place. Voici des exemples de `CanonicalHeaders` chaînes. Les noms d'en-tête sont en minuscules et sont triés. **Example Exemple 1** ``` host:s3.amazonaws.com x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 x-amz-date:20130708T220855Z ``` **Example Exemple 2** ``` host:s3.amazonaws.com x-amz-content-sha256:UNSIGNED-PAYLOAD x-amz-date:20130708T220855Z ``` **Example Exemple 3** ``` host:s3.amazonaws.com x-amz-date:20130708T220855Z ``` **Note** Aux fins du calcul d'une signature d'autorisation, l'en-tête de l'hôte et tous les `x-amz-*` en-têtes, à l'exception des en-têtes`x-amz-content-sha256`, sont requis. Toutefois, afin d'éviter toute falsification des données, vous devriez envisager d'inclure tous les en-têtes dans le calcul de la signature. La signature de l'`x-amz-content-sha256`en-tête est facultative car S3 utilisera sa valeur lors du calcul du hachage de la charge utile de la demande reçue. + {{SignedHeaders}}est une liste alphabétique de noms d'en-têtes de demande séparés par des points-virgules et séparés par des points-virgules. Les en-têtes de demande de la liste sont les mêmes que ceux que vous avez inclus dans la chaîne `CanonicalHeaders`. Dans les exemples précédents, la valeur de {{SignedHeaders}} serait la suivante : **Example Exemples 1 et 2** ``` host;x-amz-content-sha256;x-amz-date ``` **Example Exemple 3** ``` host;x-amz-date ``` + {{HashedPayload}}est la valeur hexadécimale du hachage SHA256 de la charge utile de la demande. ``` Hex(SHA256Hash({{}}) ``` Si la demande ne contient aucune charge utile, vous calculez un hachage de la chaîne vide comme suit : ``` Hex(SHA256Hash("")) ``` Le hachage renvoie la valeur suivante : ``` e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ``` Par exemple, lorsque vous chargez un objet à l'aide d'une demande PUT, vous fournissez les données de l'objet dans le corps du message. Lorsque vous récupérez un objet à l'aide d'une requête GET, vous calculez le hachage de chaîne vide. ### Tâche 2 : créer une chaîne de connexion Cette section fournit une vue d'ensemble de la création d'une chaîne à signer. Pour obtenir des instructions détaillées, voir [ Tâche 2 : Création d'une chaîne de caractères pour ](https://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html) se connecter *Références générales AWS*. La chaîne à signer est une concaténation des chaînes suivantes : ``` "AWS4-HMAC-SHA256" + "\n" + timeStampISO8601Format + "\n" + {{}} + "\n" + Hex(SHA256Hash({{}})) ``` La chaîne constante `AWS4-HMAC-SHA256` spécifie l'algorithme de hachage que vous utilisez, HMAC-SHA256. `timeStamp`Il s'agit de l'heure UTC actuelle au format ISO 8601 (par exemple,`20130524T000000Z`). `Scope`lie la signature obtenue à une date Région AWS, un et un service spécifiques. Ainsi, la signature qui en résultera ne fonctionnera que dans la région et pour un service spécifique. La signature est valide pendant sept jours après la date spécifiée. ``` date.Format({{}}) + "/" + {{}} + "/" + {{}} + "/aws4_request" ``` Pour Amazon S3, la chaîne de service est`s3`. Pour une liste de {{region}} chaînes, voir [ Régions et points de terminaison ](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le *Références générales AWS*. La colonne Région de ce tableau fournit la liste des chaînes de région valides. La portée suivante limite la signature résultante à la `us-east-1` région et à Amazon S3. ``` 20130606/us-east-1/s3/aws4_request ``` **Note** `Scope`doit utiliser la même date que celle que vous utilisez pour calculer la clé de signature, comme indiqué dans la section suivante. ### Tâche 3 : Calculer la signature Dans la version 4 de AWS Signature, au lieu d'utiliser vos clés d' AWS accès pour signer une demande, vous créez d'abord une clé de signature limitée à une région et à un service spécifiques.  Pour plus d'informations sur les clés de signature, consultez[Présentation des demandes de signature](sig-v4-authenticating-requests.md#signing-request-intro). ``` DateKey = HMAC-SHA256("AWS4"+"{{}}", "{{}}") DateRegionKey = HMAC-SHA256({{}}, "{{}}") DateRegionServiceKey = HMAC-SHA256({{}}, "{{}}") SigningKey = HMAC-SHA256({{}}, "aws4_request") ``` **Note** Dans certains cas d'utilisation, les clés de signature peuvent être traitées pendant une durée maximale de 7 jours. Pour plus d'informations, voir [ Partager un objet avec d'autres personnes](https://docs.aws.amazon.com/AmazonS3/latest/dev/ShareObjectPreSignedURL.html). Pour une liste des chaînes de régions, voir [ Régions et points de terminaison ](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le *Références générales AWS*. L'utilisation d'une clé de signature vous permet de conserver vos AWS informations d'identification en un seul endroit sûr. Par exemple, si plusieurs serveurs communiquent avec Amazon S3, vous partagez la clé de signature avec ces serveurs ; vous n'êtes pas obligé de conserver une copie de votre clé d'accès secrète sur chaque serveur. La clé de signature est valide pendant sept jours au maximum. Ainsi, chaque fois que vous calculez la clé de signature, vous devrez partager la clé de signature avec vos serveurs. Pour de plus amples informations, veuillez consulter [Demandes d'authentification (AWS Signature (version 4)](sig-v4-authenticating-requests.md). La signature finale est le HMAC-SHA256 hachage de la chaîne à signer, en utilisant la clé de signature comme clé. ``` HMAC-SHA256(SigningKey, StringToSign) ``` Pour obtenir des instructions détaillées sur la création d'une signature, voir [ Tâche 3 : Créer une signature ](https://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html) dans le *Références générales AWS*. ### Exemples : calculs de signature Vous pouvez utiliser les exemples de cette section comme référence pour vérifier les calculs de signature dans votre code. Les calculs présentés dans les exemples utilisent les données suivantes : + Exemples de clés d'accès. [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/AmazonS3/latest/developerguide/sig-v4-header-based-auth.html) + Horodatage de la demande 20130524T000000Z (). `Fri, 24 May 2013 00:00:00 GMT` + Nom du bucket`examplebucket`. + Le compartiment est supposé se trouver dans la région de l'Est des États-Unis (Virginie du Nord). Les informations d'identification `Scope` et les `Signing Key` calculs sont utilisés `us-east-1` comme spécificateur de région. Pour plus d'informations sur les autres régions, voir [ Régions et points de terminaison ](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le *Références générales AWS*. + Vous pouvez utiliser des requêtes de type chemin ou des requêtes de type hébergement virtuel. Les exemples suivants montrent comment signer une demande de type hébergement virtuel, par exemple : ``` https://examplebucket.s3.amazonaws.com/photos/photo1.jpg ``` Pour plus d'informations, consultez la section Hébergement [ virtuel de compartiments ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html) dans le guide * de l'utilisateur d'*Amazon Simple Storage Service. #### Exemple : objet GET L'exemple suivant extrait les 10 premiers octets d'un objet (test.txt) depuis`examplebucket`. Pour plus d'informations sur l'action d'API, consultez [ 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 ``` Comme cette requête GET ne fournit aucun contenu de corps, la `x-amz-content-sha256` valeur peut être soit le hachage du corps de requête vide, soit la chaîne `"UNSIGNED-PAYLOAD"` littérale. Les étapes suivantes montrent les calculs de signature et la construction de l'`Authorization`en-tête à l'aide du hachage d'une chaîne vide. 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 ``` Dans la chaîne de requête canonique, la dernière ligne est le hachage du corps de requête vide. La troisième ligne est vide car elle ne contient aucun paramètre de requête. 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. **Signature** ``` f0e8bdb87c964420e857bd35b5d6ed310bd44f0170aba48dd91039c6036bdb41 ``` 1. **En-tête Authorization** L'`Authorization`en-tête qui en résulte est le suivant : ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=host;range;x-amz-content-sha256;x-amz-date,Signature=f0e8bdb87c964420e857bd35b5d6ed310bd44f0170aba48dd91039c6036bdb41 ``` #### Exemple : objet PUT Cet exemple de requête PUT crée un objet (`test$file.text`) dans`examplebucket`. Dans cet exemple il est supposé que : + Vous faites une demande `REDUCED_REDUNDANCY` en tant que classe de stockage en ajoutant l'en-tête de `x-amz-storage-class` demande. Pour plus d'informations sur les classes de stockage, consultez la section Classes [ de stockage ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html#storage-class-intro) dans le guide de l'utilisateur d'*Amazon Simple Storage Service*. + Le contenu du fichier téléchargé est une chaîne. `"Welcome to Amazon S3."` La valeur de `x-amz-content-sha256` dans la demande est basée sur cette chaîne. Pour plus d'informations sur l'action d'API, consultez [ 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 {{}} ``` Les étapes suivantes présentent les calculs de signature. 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 ``` Dans la requête canonique, la troisième ligne est vide car elle ne contient aucun paramètre de requête. L'en-tête `x-amz-content-sha256` canonique peut éventuellement être signé puisque son hachage de charge utile est déjà fourni au bas de la demande. La dernière ligne est le hachage du corps, qui doit être identique à la `x-amz-content-sha256 header` valeur envoyée à S3 dans la requête 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. **Signature** ``` 98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd ``` 1. **En-tête Authorization** L'`Authorization`en-tête qui en résulte est le suivant : ``` 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 ``` #### Exemple : GET Bucket Lifecycle La requête GET suivante récupère la configuration du cycle de vie de. `examplebucket` Pour plus d'informations sur l'action d'API, consultez [ 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 ``` Étant donné que la demande ne fournit aucun contenu de corps, la valeur `x-amz-content-sha256` d'en-tête est le hachage du corps de demande vide. Les étapes suivantes présentent les calculs de signature. 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 ``` Dans la requête canonique, la dernière ligne est le hash du corps vide de la requête. 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. **Signature** ``` fea454ca298b7da1c68078a5d1bdbfbbe0d65c699e0f91ac7a200a0136783543 ``` 1. **En-tête Authorization** L'`Authorization`en-tête qui en résulte est le suivant : ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=host;x-amz-content-sha256;x-amz-date,Signature=fea454ca298b7da1c68078a5d1bdbfbbe0d65c699e0f91ac7a200a0136783543 ``` #### Exemple : Get Bucket (List Objects) L'exemple suivant récupère une liste d'objets à partir d'un `examplebucket` bucket. Pour plus d'informations sur l'action d'API, consultez [ 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 ``` Étant donné que la demande ne fournit pas de corps, la valeur de `x-amz-content-sha256` est le hachage du corps de demande vide. Les étapes suivantes présentent les calculs de signature. 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 ``` Dans la chaîne canonique, la dernière ligne est le hachage du corps de requête vide. 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. **Signature** ``` 34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7 ``` 1. **En-tête Authorization** L'`Authorization`en-tête qui en résulte est le suivant : ``` AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=host;x-amz-content-sha256;x-amz-date,Signature=34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7 ```