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.
# Effectuez des opérations hors ligne avec des clés publiques
Dans une clé KMS asymétrique, la clé privée est créée AWS KMS et ne sort jamais AWS KMS non chiffrée. Pour utiliser la clé privée, vous devez appeler AWS KMS. Vous pouvez utiliser la clé publique qu'elle contient AWS KMS en appelant les opérations de l' AWS KMS API. Vous pouvez également [télécharger la clé publique](download-public-key.md) et la partager pour une utilisation en dehors de AWS KMS.
Vous pouvez partager une clé publique pour permettre à d'autres personnes de AWS KMS chiffrer des données. Vous ne pouvez déchiffrer des données qu'avec votre clé privée. Ou pour permettre à d'autres personnes de vérifier une signature numérique en dehors de AWS KMS que vous avez générée avec votre clé privée. Ou encore, pour partager votre clé publique avec un pair afin d'en déduire un secret partagé.
Lorsque vous utilisez la clé publique contenue dans votre clé KMS asymétrique AWS KMS, vous bénéficiez de l'authentification, de l'autorisation et de la journalisation qui font partie de chaque AWS KMS opération. Vous réduisez également le risque de chiffrement des données qui ne peuvent pas être déchiffrées. Ces fonctionnalités ne sont pas efficaces en dehors de AWS KMS. Pour en savoir plus, consultez [Considérations particulières pour le téléchargement de clés publiques](#download-public-key-considerations).
**Astuce**
Vous recherchez des clés de données ou des clés SSH ? Cette rubrique explique comment gérer les clés asymétriques dans AWS Key Management Service, où la clé privée n'est pas exportable. Pour les paires de clés de données exportables dans lesquelles la clé privée est protégée par une clé KMS de chiffrement symétrique, voir. [GenerateDataKeyPair](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPair.html) [Pour obtenir de l'aide sur le téléchargement de la clé publique associée à une instance Amazon EC2, consultez la section *Extraction de la clé publique dans le guide* de l'utilisateur [Amazon EC2 et le guide de l'utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/describe-keys.html#retrieving-the-public-key).](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/describe-keys.html#retrieving-the-public-key)
**Topics**
+ [Considérations particulières pour le téléchargement de clés publiques](#download-public-key-considerations)
+ [Télécharger la clé publique](download-public-key.md)
+ [Exemples d'opérations hors ligne](offline-operations.md)
## Considérations particulières pour le téléchargement de clés publiques
Pour protéger vos clés KMS, AWS KMS fournit des contrôles d'accès, un chiffrement authentifié et des journaux détaillés de chaque opération. AWS KMS vous permet également d'empêcher l'utilisation des clés KMS, temporairement ou définitivement. Enfin, les AWS KMS opérations sont conçues pour minimiser le risque de chiffrer des données qui ne peuvent pas être déchiffrées. Ces fonctionnalités ne sont pas disponibles lorsque vous utilisez des clés publiques téléchargées en dehors de AWS KMS.
**Autorisation**
[Les politiques clés et les](key-policies.md) [politiques IAM](iam-policies.md) qui contrôlent l'accès à la clé KMS interne n' AWS KMS ont aucun effet sur les opérations effectuées en dehors de AWS. Tout utilisateur qui peut obtenir la clé publique peut l'utiliser en dehors de l'UE, AWS KMS même s'il n'est pas autorisé à chiffrer les données ou à vérifier les signatures avec la clé KMS.
**Restrictions liées à l'utilisation de la clé**
Les principales restrictions d'utilisation ne sont pas applicables en dehors de AWS KMS. Si vous appelez l'opération [Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) avec une clé KMS comportant le caractère `KeyUsage` de`SIGN_VERIFY`, l' AWS KMS opération échoue. Mais si vous chiffrez des données en dehors de l'extérieur AWS KMS avec une clé publique à partir d'une clé KMS avec un `KeyUsage` `SIGN_VERIFY` ou`KEY_AGREEMENT`, les données ne peuvent pas être déchiffrées.
**Restrictions de l'algorithme**
Les restrictions relatives aux algorithmes de chiffrement et de signature pris AWS KMS en charge ne sont pas efficaces en dehors de AWS KMS. Si vous chiffrez des données avec la clé publique à partir d'une clé KMS extérieure et que AWS KMS vous utilisez un algorithme de AWS KMS chiffrement non compatible, les données ne peuvent pas être déchiffrées.
**Désactivation et suppression des clés KMS**
Les mesures que vous pouvez prendre pour empêcher l'utilisation de la clé KMS dans le cadre d'une opération cryptographique AWS KMS interne n'empêchent personne d'utiliser la clé publique en dehors de AWS KMS. Par exemple, la désactivation d'une clé KMS, la planification de la suppression d'une clé KMS, la suppression d'une clé KMS ou la suppression des éléments d'une clé KMS n'ont aucun effet sur une clé publique en dehors de AWS KMS. Si vous supprimez une clé KMS asymétrique ou si vous supprimez ou perdez son contenu clé, les données que vous chiffrez avec une clé publique extérieure AWS KMS sont irrécupérables.
**Logging**
AWS CloudTrail les journaux qui enregistrent chaque AWS KMS opération, y compris la demande, la réponse, la date, l'heure et l'utilisateur autorisé, n'enregistrent pas l'utilisation de la clé publique en dehors de AWS KMS.
**Vérification hors ligne à l'aide de paires de SM2 clés (régions de Chine uniquement)**
Pour vérifier une signature extérieure à l' AWS KMS aide d'une clé SM2 publique, vous devez spécifier l'identifiant distinctif. Par défaut, AWS KMS utilise `1234567812345678` comme identifiant distinctif. Pour plus d'informations, consultez la section [Vérification hors ligne à l'aide de paires de SM2 clés (régions de Chine uniquement).](offline-operations.md#key-spec-sm-offline-verification)
# Télécharger la clé publique
Vous pouvez télécharger la clé publique à partir d'une paire de clés KMS asymétriques dans la AWS KMS console ou en utilisant l'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)opération. Pour télécharger la clé publique, vous devez disposer d'une `kms:GetPublicKey` autorisation sur la clé KMS asymétrique.
[La clé publique AWS KMS renvoyée est une clé publique X.509 codée DER, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://datatracker.ietf.org/doc/html/rfc5280) Lorsque vous utilisez l'API HTTP ou le AWS CLI, la valeur est codée en Base64. Dans le cas contraire, il n'est pas codé en Base64.
Pour télécharger la clé publique à partir d'une paire de clés KMS asymétriques, vous devez `kms:GetPublicKey` disposer d'autorisations. Pour plus d'informations sur AWS KMS les autorisations, consultez le[Référence des autorisations ](kms-api-permissions-reference.md).
## Utilisation de la AWS KMS console
Vous pouvez utiliser le AWS Management Console pour afficher, copier et télécharger la clé publique à partir d'une clé KMS asymétrique présente dans votre Compte AWS. Pour télécharger la clé publique à partir d'une clé KMS asymétrique dans un autre format Compte AWS, utilisez l' AWS KMS API.
1. Connectez-vous à la console AWS Key Management Service (AWS KMS) AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/kms.](https://console.aws.amazon.com/kms)
1. Pour modifier le Région AWS, utilisez le sélecteur de région dans le coin supérieur droit de la page.
1. Dans le panneau de navigation, choisissez **Clés gérées par le client**.
1. Choisissez l'alias ou l'ID de clé d'une clé KMS asymétrique.
1. Choisissez l'onglet **Cryptographic configuration (Configuration de chiffrement)**. Enregistrez les valeurs des champs **Spécifications de la clé**, **Utilisation de la clé** et **Algorithmes de chiffrement** ou **Algorithmes de signature**. Vous devez utiliser ces valeurs pour utiliser la clé publique en dehors de AWS KMS. Assurez-vous de partager ces informations lorsque vous partagez la clé publique.
1. Choisissez l'onglet **Clé publique**.
1. Pour copier la clé publique dans le presse-papiers, choisissez **Copier**. Pour télécharger la clé publique dans un fichier, choisissez **Télécharger**.
## Utilisation de l' AWS KMS API
L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)opération renvoie la clé publique sous forme de clé KMS asymétrique. Il renvoie également des informations critiques dont vous avez besoin pour utiliser correctement la clé publique en dehors de celles-ci AWS KMS, notamment l'utilisation des clés et les algorithmes de chiffrement. Veillez à enregistrer ces valeurs et à les partager chaque fois que vous partagez la clé publique.
Les exemples de cette section utilisent la [AWS Command Line Interface (AWS CLI)](https://aws.amazon.com/cli/), mais vous pouvez utiliser n'importe quel langage de programmation pris en charge.
Pour identifier une clé KMS, utilisez son [ID de clé](concepts.md#key-id-key-id), son [ARN de clé](concepts.md#key-id-key-ARN), son [nom d'alias](concepts.md#key-id-alias-name) ou son [ARN d'alias](concepts.md#key-id-alias-ARN). Lorsque vous utilisez un nom d'alias, préfixez-le avec **alias/**. Pour spécifier une clé KMS dans une autre Compte AWS, vous devez utiliser son ARN de clé ou son alias ARN.
Avant d'exécuter cette commande, remplacez l'exemple de nom d'alias par un identifiant valide pour la clé KMS. Pour exécuter cette commande, vous devez disposer `kms:GetPublicKey` d'autorisations sur la clé KMS.
```
$ aws kms get-public-key --key-id alias/example_RSA_3072
{
"KeySpec": "RSA_3072",
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyUsage": "ENCRYPT_DECRYPT",
"EncryptionAlgorithms": [
"RSAES_OAEP_SHA_1",
"RSAES_OAEP_SHA_256"
],
"PublicKey": "MIIBojANBgkqhkiG..."
}
```
# Exemples d'opérations hors ligne
Après avoir [téléchargé la clé publique](download-public-key.md) de votre paire de clés KMS asymétriques, vous pouvez la partager avec d'autres utilisateurs et l'utiliser pour effectuer des opérations hors ligne.
AWS CloudTrail les journaux qui enregistrent chaque AWS KMS opération, y compris la demande, la réponse, la date, l'heure et l'utilisateur autorisé, n'enregistrent pas l'utilisation de la clé publique en dehors de AWS KMS.
Cette rubrique fournit des exemples d'opérations hors ligne et des détails fournis par les outils AWS KMS pour faciliter les opérations hors ligne.
**Topics**
+ [Découverte de secrets partagés hors ligne](#key-spec-ecc-offline)
+ [Vérification hors ligne avec des paires de clés ML-DSA](#mldsa-offline-verification)
+ [Vérification hors ligne à l'aide de paires de SM2 clés (régions de Chine uniquement)](#key-spec-sm-offline-verification)
## Découverte de secrets partagés hors ligne
Vous pouvez [télécharger la clé publique](download-public-key.md) de votre paire de clés ECC pour l'utiliser dans des opérations hors ligne, c'est-à-dire des opérations en dehors de AWS KMS.
La procédure pas à pas suivante montre une méthode permettant de dériver un secret partagé en dehors de l'utilisation de la clé publique d'une paire AWS KMS de clés ECC KMS et d'une clé privée créée avec [OpenSSL](https://openssl.org/).
1. Créez une paire de clés ECC dans OpenSSL et préparez-la pour une utilisation avec. AWS KMS
```
// Create an ECC key pair in OpenSSL and save the private key in openssl_ecc_key_priv.pem
export OPENSSL_CURVE_NAME="P-256"
export KMS_CURVE_NAME="ECC_NIST_P256"
export OPENSSL_KEY1_PRIV_PEM="openssl_ecc_key1_priv.pem"
openssl ecparam -name ${OPENSSL_CURVE_NAME} -genkey -out ${OPENSSL_KEY1_PRIV_PEM}
// Derive the public key from the private key
export OPENSSL_KEY1_PUB_PEM="openssl_ecc_key1_pub.pem"
openssl ec -in ${OPENSSL_KEY1_PRIV_PEM} -pubout -outform pem \
-out ${OPENSSL_KEY1_PUB_PEM}
// View the PEM file containing the public key and extract the public key as a
// Base64 encoded string into OPENSSL_KEY1_PUB_BASE64 for use with AWS KMS
export OPENSSL_KEY1_PUB_BASE64=`cat ${OPENSSL_KEY1_PUB_PEM} | \
tee /dev/stderr | grep -v "PUBLIC KEY" | tr -d "\n"`
```
1. Créez une paire de clés d'accord de clés ECC AWS KMS et préparez-la pour une utilisation avec OpenSSL.
```
// Create a KMS key on the same curve as the key pair from step 1
// with a key usage of KEY_AGREEMENT
// Save its ARN in KMS_KEY1_ARN.
export KMS_KEY1_ARN=`aws kms create-key --key-spec ${KMS_CURVE_NAME} \
--key-usage KEY_AGREEMENT | tee /dev/stderr | jq -r .KeyMetadata.Arn`
// Download the public key and save the Base64-encoded version in KMS_KEY1_PUB_BASE64
export KMS_KEY1_PUB_BASE64=`aws kms get-public-key --key-id ${KMS_KEY1_ARN} | \
tee /dev/stderr | jq -r .PublicKey`
// Create a PEM file for the public KMS key for use with OpenSSL
export KMS_KEY1_PUB_PEM="aws_kms_ecdh_key1_pub.pem"
echo "-----BEGIN PUBLIC KEY-----" > ${KMS_KEY1_PUB_PEM}
echo ${KMS_KEY1_PUB_BASE64} | fold -w 64 >> ${KMS_KEY1_PUB_PEM}
echo "-----END PUBLIC KEY-----" >> ${KMS_KEY1_PUB_PEM}
```
1. Déterminez le secret partagé dans OpenSSL à l'aide de la clé privée d'OpenSSL et de la clé KMS publique.
```
export OPENSSL_SHARED_SECRET1_BIN="openssl_shared_secret1.bin"
openssl pkeyutl -derive -inkey ${OPENSSL_KEY1_PRIV_PEM} \
-peerkey ${KMS_KEY1_PUB_PEM} -out ${OPENSSL_SHARED_SECRET1_BIN}
```
## Vérification hors ligne avec des paires de clés ML-DSA
AWS KMS prend en charge une variante couverte de la signature ML-DSA, telle que décrite dans la section 3.4 de la [norme Federal Information Processing Standards (FIPS) 204](https://csrc.nist.gov/pubs/fips/204/final) pour les messages d'une taille maximale de 4 Ko d'octets.
Pour signer des messages d'une taille supérieure à 4 Ko, vous devez effectuer l'étape de prétraitement des messages en dehors de AWS KMS. Cette étape de hachage crée un message de 64 octets représentatif de μ, tel que défini dans le NIST FIPS 204, section 6.2.
AWS KMS possède un type de message appelé `EXTERNAL_MU` pour les messages supérieurs à 4 Ko. Lorsque vous l'utilisez au lieu du type de `RAW` message, AWS KMS :
+ Suppose que vous avez déjà effectué l'étape de hachage
+ Ignore son processus de hachage interne
+ Fonctionne avec des messages de toutes tailles
Lorsque vous vérifiez un message, la méthode que vous utilisez dépend de la restriction de taille du système ou de la bibliothèque externe et de la prise en charge du message de 64 octets représentant μ :
+ Si le message est inférieur à la limite de taille, utilisez le type de `RAW` message.
+ Si le message est supérieur à la limite de taille, utilisez le μ représentatif dans le système externe.
Les sections suivantes montrent comment signer AWS KMS et vérifier des messages à l'aide d'OpenSSL. Nous fournissons des exemples de messages inférieurs ou supérieurs à la limite de 4 Ko imposée par AWS KMS. OpenSSL n'impose pas de limite à la taille des messages à des fins de vérification.
Pour les deux exemples, vous devez d'abord obtenir la clé publique auprès de AWS KMS. Utilisez la commande AWS CLI suivante :
```
aws kms get-public-key \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--output text \
--query PublicKey | base64 --decode > public_key.der
```
### Taille du message inférieure à 4 Ko
Pour les messages de moins de 4 Ko, utilisez le type de `RAW` message avec AWS KMS. Bien que vous puissiez l'utiliser`EXTERNAL_MU`, cela n'est pas nécessaire pour les messages dont la taille est limitée.
Utilisez la AWS CLI commande suivante pour signer le message :
```
aws kms sign \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--message 'your message' \
--message-type RAW \
--signing-algorithm ML_DSA_SHAKE_256 \
--output text \
--query Signature | base64 --decode > ExampleSignature.bin
```
Pour vérifier ce message à l'aide d'OpenSSL, utilisez la commande suivante :
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
### Taille du message supérieure à 4 Ko
Pour signer des messages de plus de 4 Ko, utilisez le type de `EXTERNAL_MU` message. Lorsque vous l'utilisez`EXTERNAL_MU`, vous pré-hachez le message en externe en un μ représentatif de 64 octets, tel que défini dans la section 6.2 du NIST FIPS 204, et vous le transmettez aux opérations de signature ou de vérification. Notez que cela est différent du « MLDSA pré-hachage » ou du HashML-DSA définis dans la section 5.4 du NIST FIPS 204.
1. Commencez par créer un préfixe de message. Le préfixe contient un séparateur de domaine, la longueur de tout contexte et le contexte. La valeur par défaut pour le séparateur de domaine et la longueur du contexte est zéro.
1. Ajoutez le préfixe du message au message.
1. SHAKE256 À utiliser pour hacher la clé publique et l'ajouter au résultat de l'étape 2.
1. Enfin, hachez le résultat de l'étape 3 pour produire un 64 `EXTERNAL_MU` octets.
L'exemple suivant utilise OpenSSL 3.5 pour créer : `EXTERNAL_MU`
```
{
openssl asn1parse -inform DER -in public_key.der -strparse 17 -noout -out - 2>/dev/null |
openssl dgst -provider default -shake256 -xoflen 64 -binary;
printf '\x00\x00';
echo -n "your message"
} | openssl dgst -provider default -shake256 -xoflen 64 -binary > mu.bin
```
Après avoir créé le `mu.bin` fichier, appelez l' AWS KMS API avec la commande suivante pour signer le message :
```
aws kms sign \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--message fileb://mu.bin \
--message-type EXTERNAL_MU \
--signing-algorithm ML_DSA_SHAKE_256 \
--output text \
--query Signature | base64 --decode > ExampleSignature.bin
```
La signature qui en résulte est identique à `RAW` celle du message d'origine. Vous pouvez utiliser la même commande OpenSSL 3.5 pour vérifier le message :
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
## Vérification hors ligne à l'aide de paires de SM2 clés (régions de Chine uniquement)
Pour vérifier une signature extérieure à l' AWS KMS aide d'une clé SM2 publique, vous devez spécifier l'identifiant distinctif. Lorsque vous transmettez un message brut à l'API [Sign](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html), il AWS KMS utilise l'identifiant distinctif par défaut`1234567812345678`, défini par l'OSCA en 0009-2012. [https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#KMS-Sign-request-MessageType](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#KMS-Sign-request-MessageType) GM/T Vous ne pouvez pas spécifier votre propre ID distinctif dans AWS KMS.
Toutefois, si vous générez un résumé de message en dehors de AWS, vous pouvez spécifier votre propre identifiant distinctif, puis transmettre le résumé du message, AWS KMS à [https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#API_Sign_RequestSyntax](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#API_Sign_RequestSyntax), pour le signer. Pour ce faire, modifiez le paramètre `DEFAULT_DISTINGUISHING_ID` valeur dans la clé `SM2OfflineOperationHelper` classe. L'ID distinctif que vous spécifiez peut être n'importe quelle chaîne de 8 192 caractères maximum. Après avoir AWS KMS signé le résumé du message, vous avez besoin soit du résumé du message, soit du message et de l'ID distinctif utilisés pour calculer le résumé afin de le vérifier hors ligne.
**Important**
Le `SM2OfflineOperationHelper` code de référence est conçu pour être compatible avec [Bouncy Castle](https://www.bouncycastle.org/documentation/documentation-java/) version 1.68. Pour obtenir de l'aide sur les autres versions, contactez[bouncycastle.org](https://www.bouncycastle.org).
### classe `SM2OfflineOperationHelper`
Pour vous aider à effectuer des opérations hors ligne avec des SM2 clés, la `SM2OfflineOperationHelper` classe pour Java possède des méthodes qui exécutent les tâches à votre place. Vous pouvez utiliser cette classe d'assistance comme modèle pour d'autres fournisseurs de cryptographie.
Dans AWS KMS ce cadre, les conversions de texte chiffré brut et les calculs du résumé des messages SM2 DSA sont effectués automatiquement. Tous les fournisseurs de cryptographie ne mettent pas SM2 en œuvre de la même manière. Certaines bibliothèques, comme les versions 1.1.1 et ultérieures d'[OpenSSL](https://openssl.org/), exécutent ces actions automatiquement. AWS KMS a confirmé ce comportement lors de tests avec la version 3.0 d'OpenSSL. Utilisez les classes `SM2OfflineOperationHelper` avec des bibliothèques, comme [Bouncy Castle](https://www.bouncycastle.org/java.html), qui vous obligent à effectuer ces conversions et ces calculs manuellement.
La classe `SM2OfflineOperationHelper` fournit des méthodes pour les opérations hors ligne suivantes :
+
**Calcul de l'algorithme Message Digest**
Pour générer un résumé de message hors ligne que vous pouvez utiliser pour la vérification hors ligne ou que vous pouvez transmettre AWS KMS pour le signer, utilisez `calculateSM2Digest` cette méthode. Le `calculateSM2Digest` procédé génère un condensé de message à l'aide de l'algorithme SM3 de hachage. L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API renvoie votre clé publique au format binaire. Vous devez analyser la clé binaire dans un Java PublicKey. Fournissez la clé publique analysée avec le message. La méthode combine automatiquement votre message avec l'identifiant distinctif par défaut, `1234567812345678`, mais vous pouvez définir votre propre ID distinctif en modifiant la valeur `DEFAULT_DISTINGUISHING_ID`.
+
**Vérification**
Pour vérifier une signature hors ligne, utilisez la méthode `offlineSM2DSAVerify`. La méthode `offlineSM2DSAVerify` utilise le résumé du message calculé à partir de l'ID distinctif spécifié et du message d'origine que vous avez fourni pour vérifier la signature numérique. L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API renvoie votre clé publique au format binaire. Vous devez analyser la clé binaire dans un Java PublicKey. Fournissez la clé publique analysée avec le message d'origine et la signature que vous souhaitez vérifier. Pour plus de détails, consultez la section [Vérification hors ligne à l'aide de paires de SM2 clés](#key-spec-sm-offline-verification).
+
**Chiffrement**
Pour chiffrer du texte en clair hors ligne, utilisez la méthode `offlineSM2PKEEncrypt`. Cette méthode garantit que le texte chiffré est dans un format AWS KMS déchiffrable. Le `offlineSM2PKEEncrypt` procédé chiffre le texte en clair, puis convertit le texte chiffré brut produit par SM2 PKE au format ASN.1. L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API renvoie votre clé publique au format binaire. Vous devez analyser la clé binaire dans un Java PublicKey. Fournissez la clé publique analysée avec le texte brut que vous souhaitez chiffrer.
Si vous n'êtes pas sûr(e) de devoir effectuer la conversion, utilisez l'opération OpenSSL suivante pour tester le format de votre texte chiffré. Si l'opération échoue, vous devez convertir le texte chiffré au format ASN.1.
```
openssl asn1parse -inform DER -in ciphertext.der
```
Par défaut, la `SM2OfflineOperationHelper` classe utilise l'ID distinctif par défaut lors de la génération de résumés de messages pour les opérations SM2 DSA. `1234567812345678`
```
package com.amazon.kms.utils;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.jce.interfaces.ECPublicKey;
import java.util.Arrays;
import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.DEROctetString;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.params.ParametersWithID;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.crypto.signers.SM2Signer;
import org.bouncycastle.jcajce.provider.asymmetric.util.ECUtil;
public class SM2OfflineOperationHelper {
// You can change the DEFAULT_DISTINGUISHING_ID value to set your own distinguishing ID,
// the DEFAULT_DISTINGUISHING_ID can be any string up to 8,192 characters long.
private static final byte[] DEFAULT_DISTINGUISHING_ID = "1234567812345678".getBytes(StandardCharsets.UTF_8);
private static final X9ECParameters SM2_X9EC_PARAMETERS = GMNamedCurves.getByName("sm2p256v1");
// ***calculateSM2Digest***
// Calculate message digest
public static byte[] calculateSM2Digest(final PublicKey publicKey, final byte[] message) throws
NoSuchProviderException, NoSuchAlgorithmException {
final ECPublicKey ecPublicKey = (ECPublicKey) publicKey;
// Generate SM3 hash of default distinguishing ID, 1234567812345678
final int entlenA = DEFAULT_DISTINGUISHING_ID.length * 8;
final byte [] entla = new byte[] { (byte) (entlenA & 0xFF00), (byte) (entlenA & 0x00FF) };
final byte [] a = SM2_X9EC_PARAMETERS.getCurve().getA().getEncoded();
final byte [] b = SM2_X9EC_PARAMETERS.getCurve().getB().getEncoded();
final byte [] xg = SM2_X9EC_PARAMETERS.getG().getXCoord().getEncoded();
final byte [] yg = SM2_X9EC_PARAMETERS.getG().getYCoord().getEncoded();
final byte[] xa = ecPublicKey.getQ().getXCoord().getEncoded();
final byte[] ya = ecPublicKey.getQ().getYCoord().getEncoded();
final byte[] za = MessageDigest.getInstance("SM3", "BC")
.digest(ByteBuffer.allocate(entla.length + DEFAULT_DISTINGUISHING_ID.length + a.length + b.length + xg.length + yg.length +
xa.length + ya.length).put(entla).put(DEFAULT_DISTINGUISHING_ID).put(a).put(b).put(xg).put(yg).put(xa).put(ya)
.array());
// Combine hashed distinguishing ID with original message to generate final digest
return MessageDigest.getInstance("SM3", "BC")
.digest(ByteBuffer.allocate(za.length + message.length).put(za).put(message)
.array());
}
// ***offlineSM2DSAVerify***
// Verify digital signature with SM2 public key
public static boolean offlineSM2DSAVerify(final PublicKey publicKey, final byte [] message,
final byte [] signature) throws InvalidKeyException {
final SM2Signer signer = new SM2Signer();
CipherParameters cipherParameters = ECUtil.generatePublicKeyParameter(publicKey);
cipherParameters = new ParametersWithID(cipherParameters, DEFAULT_DISTINGUISHING_ID);
signer.init(false, cipherParameters);
signer.update(message, 0, message.length);
return signer.verifySignature(signature);
}
// ***offlineSM2PKEEncrypt***
// Encrypt data with SM2 public key
public static byte[] offlineSM2PKEEncrypt(final PublicKey publicKey, final byte [] plaintext) throws
NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException,
BadPaddingException, IllegalBlockSizeException, IOException {
final Cipher sm2Cipher = Cipher.getInstance("SM2", "BC");
sm2Cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// By default, Bouncy Castle returns raw ciphertext in the c1c2c3 format
final byte [] cipherText = sm2Cipher.doFinal(plaintext);
// Convert the raw ciphertext to the ASN.1 format before passing it to AWS KMS
final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector();
final int coordinateLength = (SM2_X9EC_PARAMETERS.getCurve().getFieldSize() + 7) / 8 * 2 + 1;
final int sm3HashLength = 32;
final int xCoordinateInCipherText = 33;
final int yCoordinateInCipherText = 65;
byte[] coords = new byte[coordinateLength];
byte[] sm3Hash = new byte[sm3HashLength];
byte[] remainingCipherText = new byte[cipherText.length - coordinateLength - sm3HashLength];
// Split components out of the ciphertext
System.arraycopy(cipherText, 0, coords, 0, coordinateLength);
System.arraycopy(cipherText, cipherText.length - sm3HashLength, sm3Hash, 0, sm3HashLength);
System.arraycopy(cipherText, coordinateLength, remainingCipherText, 0,cipherText.length - coordinateLength - sm3HashLength);
// Build standard SM2PKE ASN.1 ciphertext vector
asn1EncodableVector.add(new ASN1Integer(new BigInteger(1, Arrays.copyOfRange(coords, 1, xCoordinateInCipherText))));
asn1EncodableVector.add(new ASN1Integer(new BigInteger(1, Arrays.copyOfRange(coords, xCoordinateInCipherText, yCoordinateInCipherText))));
asn1EncodableVector.add(new DEROctetString(sm3Hash));
asn1EncodableVector.add(new DEROctetString(remainingCipherText));
return new DERSequence(asn1EncodableVector).getEncoded("DER");
}
}
```