Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Führen Sie Offline-Operationen mit öffentlichen Schlüsseln durch
Bei einem asymmetrischen KMS-Schlüssel wird der private Schlüssel erstellt AWS KMS und verlässt AWS KMS ihn nie unverschlüsselt. Um den privaten Schlüssel zu verwenden, müssen Sie anrufen. AWS KMS Sie können den öffentlichen Schlüssel darin verwenden, AWS KMS indem Sie die AWS KMS API-Operationen aufrufen. Oder Sie können [den öffentlichen Schlüssel herunterladen](download-public-key.md) und für die Verwendung außerhalb von freigeben AWS KMS.
Sie können einen öffentlichen Schlüssel teilen, damit andere Daten verschlüsseln können AWS KMS , die Sie nur mit Ihrem privaten Schlüssel entschlüsseln können. Oder, um anderen zu erlauben, eine digitale Signatur, die Sie mit Ihrem privaten Schlüssel generiert haben, außerhalb von AWS KMS zu überprüfen. Oder um Ihren öffentlichen Schlüssel mit einem Peer zu teilen, um daraus ein gemeinsames Geheimnis abzuleiten.
Wenn Sie den öffentlichen Schlüssel in Ihrem internen asymmetrischen KMS-Schlüssel verwenden AWS KMS, profitieren Sie von der Authentifizierung, Autorisierung und Protokollierung, die Teil jedes AWS KMS Vorgangs sind. Außerdem reduzieren Sie das Risiko, Daten zu verschlüsseln, die nicht entschlüsselt werden können. Diese Funktionen sind außerhalb von AWS KMS nicht wirksam. Details hierzu finden Sie unter [Besondere Überlegungen zum Herunterladen öffentlicher Schlüssel](#download-public-key-considerations).
**Tipp**
Suchen Sie nach Datenschlüsseln oder SSH-Schlüsseln? In diesem Thema wird erläutert, wie Sie asymmetrische Schlüssel in AWS Key Management Service verwalten, bei denen der private Schlüssel nicht exportierbar ist. Informationen zu exportierbaren Datenschlüsselpaaren, bei denen der private Schlüssel durch einen KMS-Schlüssel mit symmetrischer Verschlüsselung geschützt ist, finden Sie unter. [GenerateDataKeyPair](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPair.html) Hilfe zum Herunterladen des öffentlichen Schlüssels, der einer Amazon EC2 EC2-Instance zugeordnet ist, finden Sie unter *Abrufen des öffentlichen Schlüssels* im [Amazon EC2 EC2-Benutzerhandbuch und im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/describe-keys.html#retrieving-the-public-key)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/describe-keys.html#retrieving-the-public-key).
**Topics**
+ [Besondere Überlegungen zum Herunterladen öffentlicher Schlüssel](#download-public-key-considerations)
+ [Laden Sie den öffentlichen Schlüssel herunter](download-public-key.md)
+ [Beispiel für Offline-Operationen](offline-operations.md)
## Besondere Überlegungen zum Herunterladen öffentlicher Schlüssel
Zum Schutz Ihrer KMS-Schlüssel AWS KMS bietet es Zugriffskontrollen, authentifizierte Verschlüsselung und detaillierte Protokolle aller Vorgänge. AWS KMS ermöglicht es Ihnen auch, die Verwendung von KMS-Schlüsseln vorübergehend oder dauerhaft zu verhindern. Schließlich sind die AWS KMS Operationen darauf ausgelegt, das Risiko der Verschlüsselung von Daten, die nicht entschlüsselt werden können, zu minimieren. Diese Funktionen sind nicht verfügbar, wenn Sie heruntergeladene öffentliche Schlüssel außerhalb von verwenden. AWS KMS
**Autorisierung**
[Wichtige Richtlinien](key-policies.md) und [IAM-Richtlinien](iam-policies.md), die den Zugriff auf den internen KMS-Schlüssel steuern, AWS KMS haben keine Auswirkungen auf Vorgänge, die außerhalb von AWS ausgeführt werden. Jeder Benutzer, der Zugriff auf den öffentlichen Schlüssel hat, kann ihn außerhalb von verwenden, AWS KMS auch wenn er nicht berechtigt ist, Daten zu verschlüsseln oder Signaturen mit dem KMS-Schlüssel zu überprüfen.
**Nutzungsbeschränkungen für Schlüssel**
Einschränkungen bei der Verwendung von Schlüsseln sind außerhalb von AWS KMS nicht wirksam. Wenn Sie den [Verschlüsselungsvorgang](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) mit einem KMS-Schlüssel aufrufen, der den Wert `KeyUsage` von hat`SIGN_VERIFY`, schlägt der AWS KMS Vorgang fehl. Wenn Sie Daten jedoch außerhalb oder AWS KMS mit einem öffentlichen Schlüssel aus einem KMS-Schlüssel mit einem `KeyUsage` von `SIGN_VERIFY` oder verschlüsseln`KEY_AGREEMENT`, können die Daten nicht entschlüsselt werden.
**Algorithmusbeschränkungen**
Einschränkungen der AWS KMS unterstützten Verschlüsselungs- und Signaturalgorithmen sind außerhalb von nicht wirksam. AWS KMS Wenn Sie Daten mit dem öffentlichen Schlüssel eines externen KMS-Schlüssels verschlüsseln und einen Verschlüsselungsalgorithmus verwenden AWS KMS, der AWS KMS dies nicht unterstützt, können die Daten nicht entschlüsselt werden.
**Deaktivieren und Löschen von KMS-Schlüsseln**
Maßnahmen, die Sie ergreifen können, um die Verwendung des KMS-Schlüssels bei einem kryptografischen Vorgang innerhalb von zu verhindern, verhindern AWS KMS nicht, dass jemand den öffentlichen Schlüssel außerhalb von verwendet. AWS KMS Beispielsweise hat das Deaktivieren eines KMS-Schlüssels, das Planen des Löschens eines KMS-Schlüssels, das Löschen eines KMS-Schlüssels oder das Löschen des Schlüsselmaterials aus einem KMS-Schlüssel keine Auswirkungen auf einen öffentlichen Schlüssel außerhalb von AWS KMS. Wenn Sie einen asymmetrischen KMS-Schlüssel löschen oder sein Schlüsselmaterial löschen oder verlieren, können Daten, die Sie mit einem externen öffentlichen Schlüssel verschlüsseln, nicht wiederhergestellt werden. AWS KMS
**Protokollierung**
AWS CloudTrail Protokolle, die jeden AWS KMS Vorgang aufzeichnen, einschließlich der Anfrage, der Antwort, des Datums, der Uhrzeit und des autorisierten Benutzers, zeichnen nicht die Verwendung des öffentlichen Schlüssels außerhalb von auf. AWS KMS
**Offline-Überprüfung mit SM2 Schlüsselpaaren (nur Regionen China)**
Um eine Signatur außerhalb oder AWS KMS mit einem SM2 öffentlichen Schlüssel zu verifizieren, müssen Sie die identifizierende ID angeben. Wird standardmäßig `1234567812345678` als Unterscheidungs-ID AWS KMS verwendet. Weitere Informationen finden Sie unter [Offline-Überprüfung mit SM2 Schlüsselpaaren (nur Regionen China).](offline-operations.md#key-spec-sm-offline-verification)
# Laden Sie den öffentlichen Schlüssel herunter
Sie können den öffentlichen Schlüssel von einem asymmetrischen KMS-Schlüsselpaar in der AWS KMS Konsole oder mithilfe des [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)Vorgangs herunterladen. Um den öffentlichen Schlüssel herunterzuladen, benötigen Sie die entsprechenden `kms:GetPublicKey` Berechtigungen für den asymmetrischen KMS-Schlüssel.
[Der AWS KMS zurückgegebene öffentliche Schlüssel ist ein DER-codierter öffentlicher X.509-Schlüssel, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert.](https://datatracker.ietf.org/doc/html/rfc5280) Wenn Sie die HTTP-API oder die verwenden, ist der Wert Base64-codiert AWS CLI. Andernfalls ist er nicht Base64-codiert.
Um den öffentlichen Schlüssel von einem asymmetrischen KMS-Schlüsselpaar herunterzuladen, benötigen Sie `kms:GetPublicKey` Berechtigungen. Weitere Informationen zu AWS KMS Berechtigungen finden Sie unter[Berechtigungsreferenz](kms-api-permissions-reference.md).
## Verwenden der AWS KMS Konsole
Mit dem können Sie AWS-Managementkonsole den öffentlichen Schlüssel von einem asymmetrischen KMS-Schlüssel in Ihrem AWS-Konto anzeigen, kopieren und herunterladen. Verwenden Sie die API, um den öffentlichen Schlüssel von einem asymmetrischen KMS-Schlüssel in einem anderen AWS-Konto Format herunterzuladen. AWS KMS
1. Melden Sie sich bei der AWS Key Management Service (AWS KMS) -Konsole an AWS-Managementkonsole und öffnen Sie sie unter [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms).
1. Um das zu ändern AWS-Region, verwenden Sie die Regionsauswahl in der oberen rechten Ecke der Seite.
1. Klicken Sie im Navigationsbereich auf **Kundenverwaltete Schlüssel**.
1. Wählen Sie den Alias oder die Schlüssel-ID eines asymmetrischen KMS-Schlüssels aus.
1. Wählen Sie die Registerkarte **Cryptographic configuration (kryptografische Konfiguration)** aus. Notieren Sie sich die Werte der Felder **Key spec (Schlüsselspezifikation)**, **Key usage (Schlüsselnutzung)** und **Encryption algorithms (Verschlüsselungsalgorithmen)** oder **Signing Algorithms (Signaturalgorithmen)**. Sie müssen diese Werte verwenden, um den öffentlichen Schlüssel außerhalb von zu verwenden. AWS KMS Stellen Sie sicher, dass Sie diese Informationen freigeben, wenn Sie den öffentlichen Schlüssel freigeben.
1. Wählen Sie die Registerkarte **Public key (Öffentlicher Schlüssel)**.
1. Um den öffentlichen Schlüssel in die Zwischenablage zu kopieren, wählen Sie **Copy (Kopieren)**. Um den öffentlichen Schlüssel in eine Datei herunterzuladen, wählen Sie **Download (Herunterladen)**.
## Verwenden der AWS KMS API
Der [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)Vorgang gibt den öffentlichen Schlüssel in einem asymmetrischen KMS-Schlüssel zurück. Außerdem werden wichtige Informationen zurückgegeben, die Sie benötigen, um den öffentlichen Schlüssel außerhalb korrekt zu verwenden AWS KMS, einschließlich der Schlüsselverwendung und der Verschlüsselungsalgorithmen. Achten Sie darauf, diese Werte zu speichern und sie freizugeben, wenn Sie den öffentlichen Schlüssel freigeben.
Für diese Beispiele wird die [AWS Command Line Interface (AWS CLI)](https://aws.amazon.com/cli/) verwendet. Sie können aber jede unterstützte Programmiersprache nutzen.
Um einen KMS-Schlüssel anzugeben, verwenden Sie seine [Schlüssel-ID](concepts.md#key-id-key-id), seinen [Schlüssel-ARN](concepts.md#key-id-key-ARN), seinen [Aliasnamen](concepts.md#key-id-alias-name) oder seinen [Alias-ARN](concepts.md#key-id-alias-ARN). Wenn Sie einen Aliasnamen verwenden, stellen Sie ihm **alias/** voran. Um einen KMS-Schlüssel in einem anderen anzugeben AWS-Konto, müssen Sie dessen Schlüssel-ARN oder Alias-ARN verwenden.
Bevor Sie diesen Befehl ausführen, ersetzen Sie den Beispiel-Aliasnamen durch einen gültigen Bezeichner für den KMS-Schlüssel. Um diesen Befehl auszuführen, müssen Sie über `kms:GetPublicKey`-Berechtigungen für den KMS-Schlüssel verfügen.
```
$ 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..."
}
```
# Beispiel für Offline-Operationen
Nachdem [Sie den öffentlichen Schlüssel Ihres asymmetrischen KMS-Schlüsselpaars heruntergeladen](download-public-key.md) haben, können Sie ihn mit anderen teilen und für Offline-Operationen verwenden.
AWS CloudTrail Protokolle, die jeden AWS KMS Vorgang aufzeichnen, einschließlich der Anfrage, der Antwort, des Datums, der Uhrzeit und des autorisierten Benutzers, zeichnen nicht die Verwendung des öffentlichen Schlüssels außerhalb von AWS KMS auf.
Dieses Thema enthält Beispiele für Offline-Operationen und Einzelheiten, die die Tools AWS KMS bereitstellen, um Offline-Operationen zu vereinfachen.
**Topics**
+ [Offline-Ableitung gemeinsam genutzter Geheimnisse](#key-spec-ecc-offline)
+ [Offline-Überprüfung mit ML-DSA-Schlüsselpaaren](#mldsa-offline-verification)
+ [Offline-Überprüfung mit SM2 Schlüsselpaaren (nur Regionen China)](#key-spec-sm-offline-verification)
## Offline-Ableitung gemeinsam genutzter Geheimnisse
Sie können [den öffentlichen Schlüssel Ihres ECC-Schlüsselpaars herunterladen](download-public-key.md), um ihn im Offline-Betrieb zu verwenden, d. h. bei Vorgängen außerhalb von AWS KMS.
Die folgende [OpenSSL-Komplettlösung](https://openssl.org/) zeigt eine Methode zum Ableiten eines gemeinsamen geheimen Schlüssels außerhalb der AWS KMS Verwendung des öffentlichen Schlüssels eines ECC-KMS-Schlüsselpaars und eines mit OpenSSL erstellten privaten Schlüssels.
1. Erstellen Sie ein ECC-Schlüsselpaar in OpenSSL und bereiten Sie es für die Verwendung mit vor. 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. Erstellen Sie ein key pair für die ECC-Schlüsselvereinbarung AWS KMS und bereiten Sie es für die Verwendung mit OpenSSL vor.
```
// 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. Leiten Sie Shared Secret in OpenSSL mithilfe des privaten Schlüssels in OpenSSL und des öffentlichen KMS-Schlüssels ab.
```
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}
```
## Offline-Überprüfung mit ML-DSA-Schlüsselpaaren
AWS KMS unterstützt eine abgesicherte Variante der ML-DSA-Signatur, wie in Abschnitt 3.4 der [Federal Information Processing Standards (FIPS) 204 (Federal Information Processing Standards)](https://csrc.nist.gov/pubs/fips/204/final) beschrieben, für Nachrichten mit bis zu 4 KB Byte.
Um Nachrichten zu signieren, die größer als 4 KB sind, führen Sie den Schritt zur Nachrichtenvorverarbeitung außerhalb von aus. AWS KMS Dieser Hashing-Schritt erstellt eine 64-Byte-Nachricht, die für μ steht, wie in NIST FIPS 204, Abschnitt 6.2 definiert.
AWS KMS hat einen Nachrichtentyp, der `EXTERNAL_MU` für Nachrichten mit mehr als 4 KB aufgerufen wird. Wenn Sie diesen anstelle des `RAW` Nachrichtentyps verwenden, gilt Folgendes AWS KMS:
+ Geht davon aus, dass Sie den Hashing-Schritt bereits ausgeführt haben
+ Überspringt den internen Hashing-Prozess
+ Funktioniert mit Nachrichten beliebiger Größe
Wenn Sie eine Nachricht verifizieren, hängt die Methode, die Sie verwenden, von der Größenbeschränkung des externen Systems oder der Bibliothek ab und davon, ob sie den 64-Byte-Nachrichtenrepräsentanten μ unterstützt:
+ Wenn die Nachricht kleiner als die Größenbeschränkung ist, verwenden Sie den `RAW` Nachrichtentyp.
+ Wenn die Nachricht größer als die Größenbeschränkung ist, verwenden Sie den repräsentativen Wert μ im externen System.
In den folgenden Abschnitten wird gezeigt, wie Nachrichten mit OpenSSL signiert AWS KMS und überprüft werden. Wir bieten Beispiele für Nachrichten, die unter und über der Nachrichtengrößenbeschränkung von AWS KMS 4 KB liegen. OpenSSL legt keine Beschränkung der Nachrichtengröße für die Überprüfung fest.
Holen Sie sich für beide Beispiele zuerst den öffentlichen Schlüssel von AWS KMS. Verwenden Sie den folgenden AWS CLI -Befehl:
```
aws kms get-public-key \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--output text \
--query PublicKey | base64 --decode > public_key.der
```
### Nachrichtengröße weniger als 4 KB
Verwenden Sie für Nachrichten unter 4 KB den `RAW` Nachrichtentyp mit AWS KMS. Sie können dies zwar verwenden`EXTERNAL_MU`, für Nachrichten innerhalb der Größenbeschränkung ist dies jedoch nicht erforderlich.
Verwenden Sie den folgenden AWS CLI Befehl, um die Nachricht zu signieren:
```
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
```
Verwenden Sie den folgenden Befehl, um diese Nachricht mit OpenSSL zu überprüfen:
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
### Nachrichtengröße mehr als 4 KB
Verwenden Sie den `EXTERNAL_MU` Nachrichtentyp, um Nachrichten zu signieren, die größer als 4 KB sind. Bei der Verwendung `EXTERNAL_MU` wird die Nachricht extern an einen 64-Byte-Repräsentanten μ vorgehasht, wie in NIST FIPS 204 Abschnitt 6.2 definiert, und sie an die Signier- oder Verifizierungsvorgänge übergeben. Beachten Sie, dass sich dies von dem in NIST FIPS 204 Abschnitt 5.4 definierten „Pre-Hash MLDSA“ oder HashML-DSA unterscheidet.
1. Konstruieren Sie zunächst ein Nachrichtenpräfix. Das Präfix enthält ein Domänentrennzeichen, die Länge eines beliebigen Kontextes und den Kontext. Die Standardeinstellung für das Domänentrennzeichen und die Kontextlänge ist Null.
1. Stellen Sie der Nachricht das Nachrichtenpräfix voran.
1. Verwenden Sie diese Option SHAKE256 , um den öffentlichen Schlüssel zu hashen und ihn dem Ergebnis von Schritt 2 voranzustellen.
1. Hashen Sie abschließend das Ergebnis von Schritt 3, um ein `EXTERNAL_MU` 64-Byte-Ergebnis zu erhalten.
Das folgende Beispiel verwendet OpenSSL 3.5, um das `EXTERNAL_MU` zu erstellen:
```
{
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
```
Nachdem Sie die `mu.bin` Datei erstellt haben, rufen Sie die AWS KMS API mit dem folgenden Befehl auf, um die Nachricht zu signieren:
```
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
```
Die resultierende Signatur entspricht der `RAW` Signatur der Originalnachricht. Sie können denselben OpenSSL 3.5-Befehl verwenden, um die Nachricht zu überprüfen:
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
## Offline-Überprüfung mit SM2 Schlüsselpaaren (nur Regionen China)
Um eine Signatur außerhalb oder AWS KMS mit einem SM2 öffentlichen Schlüssel zu verifizieren, müssen Sie die identifizierende ID angeben. Wenn Sie eine Rohnachricht an die [Sign-API](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html) übergeben [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), AWS KMS verwendet sie die standardmäßige Unterscheidungs-ID`1234567812345678`, die von OSCCA in 0009-2012 definiert wurde. GM/T Sie können nicht Ihre eigene unterscheidende ID in AWS KMS angeben.
Wenn Sie jedoch einen Nachrichtenüberblick außerhalb von generieren AWS, können Sie Ihre eigene Unterscheidungs-ID angeben und dann den Nachrichtenüberblick,, zum Signieren an übergeben. [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) AWS KMS Dafür ändern Sie den `DEFAULT_DISTINGUISHING_ID`-Wert in der `SM2OfflineOperationHelper`-Klasse. Die von Ihnen angegebene Unterscheidungs-ID kann eine beliebige Zeichenfolge mit einer Länge von bis zu 8.192 Zeichen sein. Nachdem Sie den Message Digest AWS KMS signiert haben, benötigen Sie entweder den Message Digest oder die Nachricht und die Unterscheidungs-ID, mit der der Digest berechnet wurde, um ihn offline zu verifizieren.
**Wichtig**
Der `SM2OfflineOperationHelper`-Referenzcode ist so konzipiert, dass er kompatibel mit [Bouncy Castle](https://www.bouncycastle.org/documentation/documentation-java/)Version 1.68 ist. Für Hilfe zu anderen Versionen wenden Sie sich an [bouncycastle.org](https://www.bouncycastle.org).
### `SM2OfflineOperationHelper`-Klasse
Um Ihnen bei Offline-Operationen mit SM2 Schlüsseln zu helfen, verfügt die `SM2OfflineOperationHelper` Klasse für Java über Methoden, die die Aufgaben für Sie ausführen. Sie können diese Hilfsklasse als Modell für andere kryptografische Anbieter verwenden.
Darin werden die AWS KMS unformatierten Chiffretext-Konvertierungen und die SM2 DSA-Message-Digest-Berechnungen automatisch durchgeführt. Nicht alle Kryptografieanbieter implementieren SM2 sie auf die gleiche Weise. Einige Bibliotheken, wie [OpenSSL-Versionen](https://openssl.org/) 1.1.1 und höher, führen diese Aktionen automatisch aus. AWS KMS bestätigte dieses Verhalten beim Testen mit OpenSSL Version 3.0. Verwenden Sie die folgende `SM2OfflineOperationHelper`-Klasse mit Bibliotheken, wie [Bouncy Castle](https://www.bouncycastle.org/java.html), bei denen Sie diese Konvertierungen und Berechnungen manuell durchführen müssen.
Die `SM2OfflineOperationHelper`-Klasse bietet Methoden für die folgenden Offline-Vorgänge:
+
**Message-Digest-Berechnung**
Verwenden Sie die Methode, um offline einen Nachrichtenüberblick zu generieren, den Sie für die Offline-Überprüfung verwenden oder an den `calculateSM2Digest` Sie AWS KMS zum Signieren übergeben können. Die `calculateSM2Digest` Methode generiert mithilfe des SM3 Hashing-Algorithmus einen Nachrichten-Digest. Die [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API gibt Ihren öffentlichen Schlüssel im Binärformat zurück. Sie müssen den Binärschlüssel in ein PublicKey Java-Format parsen. Stellen Sie den geparsten öffentlichen Schlüssel mit der Nachricht bereit. Die Methode kombiniert Ihre Nachricht automatisch mit der standardmäßigen Unterscheidungs-ID, `1234567812345678`, aber Sie können Ihre eigene Unterscheidungs-ID festlegen, indem Sie den `DEFAULT_DISTINGUISHING_ID`-Wert ändern.
+
**Verify**
Um eine Signatur offline zu prüfen, verwenden Sie die `offlineSM2DSAVerify`-Methode. Die `offlineSM2DSAVerify`-Methode verwendet den Message Difest, der anhand der angegebenen unterscheidenden ID berechnet wurde, und die ursprüngliche Nachricht, die Sie zur Überprüfung der digitalen Signatur bereitstellen. Die [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API gibt Ihren öffentlichen Schlüssel im Binärformat zurück. Sie müssen den Binärschlüssel in ein PublicKey Java-Format parsen. Stellen Sie den geparsten öffentlichen Schlüssel mit der ursprünglichen Nachricht und der Signatur, die Sie überprüfen möchten, bereit. Weitere Informationen finden Sie unter [Offline-Überprüfung mit SM2 Schlüsselpaaren](#key-spec-sm-offline-verification).
+
**Encrypt**
Um Klartext offline zu verschlüsseln, verwenden Sie die `offlineSM2PKEEncrypt`-Methode. Diese Methode stellt sicher, dass der Chiffretext in einem Format vorliegt, das entschlüsselt AWS KMS werden kann. Die `offlineSM2PKEEncrypt` Methode verschlüsselt den Klartext und konvertiert dann den von PKE erzeugten Rohchiffretext in das ASN.1-Format. SM2 Die [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API gibt Ihren öffentlichen Schlüssel im Binärformat zurück. Sie müssen den Binärschlüssel in ein PublicKey Java-Format parsen. Versehen Sie den geparsten öffentlichen Schlüssel mit dem Klartext, den Sie verschlüsseln möchten.
Wenn Sie sich nicht sicher sind, ob Sie die Konvertierung durchführen müssen, verwenden Sie den folgenden OpenSSL-Vorgang, um das Format Ihres Geheimtextes zu testen. Wenn der Vorgang fehlschlägt, müssen Sie den Geheimtext in das ASN.1-Format konvertieren.
```
openssl asn1parse -inform DER -in ciphertext.der
```
Standardmäßig verwendet die `SM2OfflineOperationHelper` Klasse beim Generieren von Nachrichtenübersichten für `1234567812345678` DSA-Operationen die standardmäßige Unterscheidungs-ID. SM2
```
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");
}
}
```