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à.
# Esegui operazioni offline con chiavi pubbliche
In una chiave KMS asimmetrica, la chiave privata viene creata e non viene mai crittografata. AWS KMS AWS KMS Per utilizzare la chiave privata, è necessario chiamare. AWS KMSÈ possibile utilizzare la chiave pubblica interna AWS KMS chiamando le operazioni AWS KMS API. In alternativa, puoi [scaricare la chiave pubblica](download-public-key.md) e condividerla per utilizzarla all'esterno di AWS KMS.
Potresti condividere una chiave pubblica per consentire ad altri di AWS KMS crittografare i dati, ma puoi decrittografarla solo con la tua chiave privata. Oppure per consentire ad altri di verificare esternamente a AWS KMS una firma digitale generata con la chiave privata. Oppure, per condividere la tua chiave pubblica con un altro utente per ricavare un segreto condiviso.
Quando utilizzate la chiave pubblica contenuta nella vostra chiave KMS asimmetrica all'interno AWS KMS, beneficiate dell'autenticazione, dell'autorizzazione e della registrazione che fanno parte di ogni operazione. AWS KMS Si riduce anche il rischio di crittografare dati che non possono essere decrittati. Queste funzionalità non sono efficaci al di fuori di. AWS KMS Per informazioni dettagliate, vedi [Considerazioni speciali per il download delle chiavi pubbliche](#download-public-key-considerations).
**Suggerimento**
Ti interessano le chiavi di dati o le chiavi SSH? In questo argomento viene descritto come gestire le chiavi asimmetriche in AWS Key Management Service, dove la chiave privata non è esportabile. Per le coppie di chiavi di dati esportabili in cui la chiave privata è protetta da una chiave KMS con crittografia simmetrica, vedere. [GenerateDataKeyPair](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPair.html) [Per informazioni su come scaricare la chiave pubblica associata a un'istanza Amazon EC2, consulta *Recupero della chiave pubblica nella Guida per l'utente* di Amazon EC2 [e nella Guida per l'utente di 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**
+ [Considerazioni speciali per il download delle chiavi pubbliche](#download-public-key-considerations)
+ [Scarica la chiave pubblica](download-public-key.md)
+ [Esempi di operazioni offline](offline-operations.md)
## Considerazioni speciali per il download delle chiavi pubbliche
Per proteggere le chiavi KMS, AWS KMS fornisce controlli di accesso, crittografia autenticata e registri dettagliati di ogni operazione. AWS KMS consente inoltre di impedire l'uso delle chiavi KMS, temporaneamente o permanentemente. Infine, AWS KMS le operazioni sono progettate per ridurre al minimo il rischio di crittografia dei dati che non possono essere decrittografati. Queste funzionalità non sono disponibili quando si utilizzano chiavi pubbliche scaricate all'esterno di. AWS KMS
**Autorizzazione**
[Le policy chiave](key-policies.md) e [le policy IAM](iam-policies.md) che controllano l'accesso alla chiave KMS interna non AWS KMS hanno alcun effetto sulle operazioni eseguite all'esterno di AWS. Qualsiasi utente in grado di ottenere la chiave pubblica può utilizzarla all'esterno di, AWS KMS anche se non dispone dell'autorizzazione per crittografare i dati o verificare le firme con la chiave KMS.
**Limitazioni d'uso delle chiavi**
Le restrizioni sull'utilizzo delle chiavi non sono efficaci al di fuori di. AWS KMS Se si richiama l'operazione [Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) con una chiave KMS con un `KeyUsage` of`SIGN_VERIFY`, l' AWS KMS operazione ha esito negativo. Tuttavia, se si crittografano i dati all'esterno AWS KMS con una chiave pubblica proveniente da una chiave KMS con un `KeyUsage` of `SIGN_VERIFY` o`KEY_AGREEMENT`, i dati non possono essere decrittografati.
**Restrizioni sugli algoritmi**
Le restrizioni sugli algoritmi di crittografia e firma supportati non sono efficaci al di AWS KMS fuori di. AWS KMS Se si crittografano i dati con la chiave pubblica proveniente da una chiave KMS esterna a e si utilizza un algoritmo di AWS KMS crittografia che non supporta, i dati AWS KMS non possono essere decrittografati.
**Disattivazione ed eliminazione di chiavi KMS**
Le azioni che puoi intraprendere per impedire l'uso della chiave KMS in un'operazione crittografica interna non impediscono a nessuno di utilizzare la chiave pubblica all' AWS KMS esterno. AWS KMS Ad esempio, la disattivazione di una chiave KMS, la pianificazione dell'eliminazione di una chiave KMS, l'eliminazione di una chiave KMS o l'eliminazione del materiale di chiave da una chiave KMS non hanno alcun effetto su una chiave pubblica esterna a AWS KMS. Se elimini una chiave KMS asimmetrica o elimini o perdi il relativo materiale chiave, i dati crittografati con una chiave pubblica esterna non sono recuperabili. AWS KMS
**Registrazione dei log**
AWS CloudTrail i registri che registrano ogni AWS KMS operazione, inclusa la richiesta, la risposta, la data, l'ora e l'utente autorizzato, non registrano l'uso della chiave pubblica all'esterno di. AWS KMS
**Verifica offline con coppie di SM2 chiavi (solo regioni della Cina)**
Per verificare una firma all'esterno AWS KMS con una chiave SM2 pubblica, devi specificare l'ID distintivo. Per impostazione predefinita, AWS KMS viene utilizzato `1234567812345678` come ID distintivo. Per ulteriori informazioni, consulta [Verifica offline con coppie di SM2 chiavi (solo regioni della Cina).](offline-operations.md#key-spec-sm-offline-verification)
# Scarica la chiave pubblica
È possibile scaricare la chiave pubblica da una coppia di chiavi KMS asimmetrica nella console o AWS KMS utilizzando l'operazione. [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) Per scaricare la chiave pubblica, è necessario disporre dell'`kms:GetPublicKey`autorizzazione sulla chiave KMS asimmetrica.
[La chiave pubblica AWS KMS restituita è una chiave pubblica X.509 con codifica DER, nota anche come `SubjectPublicKeyInfo` (SPKI), come definita in RFC 5280.](https://datatracker.ietf.org/doc/html/rfc5280) Quando si utilizza l'API HTTP o, il valore è codificato in Base64. AWS CLI Altrimenti, non è codificato in Base64.
Per scaricare la chiave pubblica da una coppia di chiavi KMS asimmetrica, sono necessarie le autorizzazioni. `kms:GetPublicKey` Per ulteriori informazioni sulle AWS KMS autorizzazioni, consulta. [Riferimento per le autorizzazioni](kms-api-permissions-reference.md)
## Utilizzo della console AWS KMS
Puoi utilizzare il Console di gestione AWS per visualizzare, copiare e scaricare la chiave pubblica da una chiave KMS asimmetrica del tuo. Account AWS Per scaricare la chiave pubblica da una chiave KMS asimmetrica in diversi modi, utilizza l'API. Account AWS AWS KMS
1. [Accedi a Console di gestione AWS e apri la console AWS Key Management Service (AWS KMS) su /kms. https://console.aws.amazon.com](https://console.aws.amazon.com/kms)
1. Per modificare il Regione AWS, usa il selettore della regione nell'angolo in alto a destra della pagina.
1. Nel riquadro di navigazione, scegli **Chiavi gestite dal cliente**.
1. Scegli l'alias o l'ID chiave di una chiave KMS asimmetrica.
1. Scegli la tab **Configurazione crittografica**. Registra i valori dei campi **Specifica della chiave**, **Utilizzo della chiave** e **Algoritmi di crittografia** o **Algoritmi di firma**. Dovrai utilizzare questi valori per utilizzare la chiave pubblica all'esterno di. AWS KMS Assicurarsi di condividere queste informazioni quando si condivide la chiave pubblica.
1. Scegliere la scheda **Public key (Chiave pubblica)**.
1. Per copiare la chiave pubblica negli Appunti, scegliere **Copy (Copia)**. Per scaricare la chiave pubblica in un file, scegliere **Download (Scarica)**.
## Utilizzando l' AWS KMS API
L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)operazione restituisce la chiave pubblica in una chiave KMS asimmetrica. Restituisce inoltre informazioni critiche necessarie per utilizzare correttamente la chiave pubblica all'esterno AWS KMS, inclusi gli algoritmi di utilizzo della chiave e di crittografia. Assicurati di salvare questi valori e di condividerli ogni volta che condividi la chiave pubblica.
Gli esempi in questa sezione utilizzano [AWS Command Line Interface (AWS CLI)](https://aws.amazon.com/cli/), ma puoi usare anche qualsiasi linguaggio di programmazione supportato.
Per specificare una chiave KMS, utilizza l'[ID chiave](concepts.md#key-id-key-id), l'[ARN di chiave](concepts.md#key-id-key-ARN), il [nome dell'alias](concepts.md#key-id-alias-name) o l'[ARN di alias](concepts.md#key-id-alias-ARN). Quando utilizzi un nome alias, aggiungi il prefisso **alias/**. Per specificare una chiave KMS in un'altra chiave Account AWS, è necessario utilizzare la relativa chiave ARN o l'alias ARN.
Prima di eseguire questo comando, sostituisci il nome alias di esempio con un identificatore valido per la chiave KMS. Per eseguire questo comando, è necessario disporre delle autorizzazioni `kms:GetPublicKey` per la chiave 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..."
}
```
# Esempi di operazioni offline
Dopo aver [scaricato la chiave pubblica](download-public-key.md) della tua coppia di chiavi KMS asimmetrica, puoi condividerla con altri e utilizzarla per eseguire operazioni offline.
AWS CloudTrail i registri che registrano ogni AWS KMS operazione, inclusa la richiesta, la risposta, la data, l'ora e l'utente autorizzato, non registrano l'uso della chiave pubblica all'esterno di. AWS KMS
Questo argomento fornisce esempi di operazioni offline e dettagli sugli strumenti AWS KMS forniti per semplificare le operazioni offline.
**Topics**
+ [Ricevere segreti condivisi offline](#key-spec-ecc-offline)
+ [Verifica offline con coppie di chiavi ML-DSA](#mldsa-offline-verification)
+ [Verifica offline con coppie di SM2 chiavi (solo regioni della Cina)](#key-spec-sm-offline-verification)
## Ricevere segreti condivisi offline
È possibile [scaricare la chiave pubblica](download-public-key.md) della coppia di chiavi ECC per utilizzarla in operazioni offline, ovvero operazioni esterne a AWS KMS.
La seguente procedura dettagliata di [OpenSSL](https://openssl.org/) illustra un metodo per derivare un segreto condiviso oltre all'utilizzo della chiave pubblica di una coppia AWS KMS di chiavi ECC KMS e di una chiave privata creata con OpenSSL.
1. Crea una coppia di chiavi ECC in OpenSSL e preparala per l'uso con. 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. Crea una coppia di chiavi ECC Key Agreement AWS KMS e preparala per l'uso con 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. Deriva un segreto condiviso in OpenSSL utilizzando la chiave privata in OpenSSL e la chiave KMS pubblica.
```
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}
```
## Verifica offline con coppie di chiavi ML-DSA
AWS KMS supporta una variante con copertura della firma ML-DSA, come descritto nella sezione 3.4 dello [standard Federal Information Processing Standards (FIPS) 204](https://csrc.nist.gov/pubs/fips/204/final) per messaggi fino a 4 KB di byte.
Per firmare messaggi di dimensioni superiori a 4 KB, si esegue la fase di preelaborazione dei messaggi all'esterno di. AWS KMS Questo passaggio di hashing crea un messaggio a 64 byte rappresentativo μ, come definito in NIST FIPS 204, sezione 6.2.
AWS KMS ha un tipo di messaggio chiamato `EXTERNAL_MU` per messaggi di dimensioni superiori a 4 KB. Quando lo usi al posto del tipo di `RAW` messaggio, AWS KMS:
+ Presuppone che tu abbia già eseguito la fase di hashing
+ Salta il processo di hashing interno
+ Funziona con messaggi di qualsiasi dimensione
Quando si verifica un messaggio, il metodo utilizzato dipende dalla limitazione delle dimensioni del sistema o della libreria esterna e dal fatto che supporti il messaggio rappresentativo a 64 byte μ:
+ Se il messaggio è più piccolo del limite di dimensione, utilizza il tipo di messaggio. `RAW`
+ Se il messaggio è più grande del limite di dimensione, utilizzate il simbolo μ nel sistema esterno.
Le sezioni seguenti mostrano come firmare i messaggi utilizzando AWS KMS e verificare i messaggi utilizzando OpenSSL. Forniamo esempi per messaggi inferiori e superiori al limite di 4 KB di dimensione dei messaggi imposto da. AWS KMS OpenSSL non impone limiti alla dimensione dei messaggi per la verifica.
Per entrambi gli esempi, per prima cosa ottieni la chiave pubblica da. AWS KMS Utilizzando il seguente comando AWS CLI :
```
aws kms get-public-key \
--key-id _<1234abcd-12ab-34cd-56ef-1234567890ab>_ \
--output text \
--query PublicKey | base64 --decode > public_key.der
```
### Dimensione del messaggio inferiore a 4 KB
Per messaggi inferiori a 4 KB, utilizza il tipo di `RAW` messaggio con AWS KMS. Sebbene sia possibile utilizzarlo`EXTERNAL_MU`, non è necessario per i messaggi entro il limite di dimensione.
Usa il seguente AWS CLI comando per firmare il messaggio:
```
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
```
Per verificare questo messaggio utilizzando OpenSSL, usa il seguente comando:
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
### Dimensione del messaggio superiore a 4 KB
Per firmare messaggi di dimensioni superiori a 4 KB, utilizza il tipo di `EXTERNAL_MU` messaggio. Quando lo utilizzate`EXTERNAL_MU`, preimpostate l'hash del messaggio esternamente su un file rappresentativo di 64 byte μ, come definito nella sezione 6.2 del NIST FIPS 204, e lo passate alle operazioni di firma o verifica. Si noti che questo è diverso dal «MLDSA pre-hash» o HashML-DSA definito nella sezione 5.4 del NIST FIPS 204.
1. Innanzitutto, costruisci un prefisso per il messaggio. Il prefisso contiene un separatore di dominio, la lunghezza di qualsiasi contesto e il contesto. L'impostazione predefinita per il separatore di dominio e la lunghezza del contesto è zero.
1. Antepone il prefisso del messaggio al messaggio.
1. Utilizzare SHAKE256 per eseguire l'hash della chiave pubblica e anteporla al risultato del passaggio 2.
1. Infine, esegui l'hash del risultato del passaggio 3 per produrre un file da 64 byte. `EXTERNAL_MU`
L'esempio seguente utilizza OpenSSL 3.5 per costruire: `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
```
Dopo aver creato il `mu.bin` file, chiama l' AWS KMS API con il seguente comando per firmare il messaggio:
```
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 firma risultante è la stessa del messaggio originale. `RAW` Puoi usare lo stesso comando OpenSSL 3.5 per verificare il messaggio:
```
echo -n 'your message' | ./openssl dgst -verify public_key.der -signature ExampleSignature.bin
```
## Verifica offline con coppie di SM2 chiavi (solo regioni della Cina)
Per verificare una firma all'esterno AWS KMS con una chiave SM2 pubblica, devi specificare l'ID distintivo. Quando si passa un messaggio non elaborato [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), all'API [Sign](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html), AWS KMS utilizza l'ID distintivo predefinito`1234567812345678`, definito da OSCA nel 0009-2012. GM/T Non puoi specificare il tuo ID distintivo all’interno di AWS KMS.
Tuttavia, se stai generando un digest del messaggio all'esterno di AWS, puoi specificare il tuo ID distintivo, quindi passare il digest del messaggio,, a to sign. [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 A tale scopo, modifica il valore `DEFAULT_DISTINGUISHING_ID` in classe `SM2OfflineOperationHelper`. L'ID distintivo specificato può essere qualsiasi stringa lunga fino a 8.192 caratteri. Dopo aver AWS KMS firmato il digest del messaggio, è necessario il message digest o il messaggio e l'ID distintivo utilizzati per calcolare il digest per verificarlo offline.
**Importante**
Il codice di riferimento `SM2OfflineOperationHelper` è progettato per essere compatibile con [Bouncy Castle](https://www.bouncycastle.org/documentation/documentation-java/) versione 1.68. Per assistenza con altre versioni, contatta [bouncycastle.org](https://www.bouncycastle.org).
### Classe `SM2OfflineOperationHelper`
Per aiutarvi con le operazioni offline con le SM2 chiavi, la `SM2OfflineOperationHelper` classe per Java dispone di metodi che eseguono le attività al posto vostro. È possibile utilizzare questa classe helper come modello per altri fornitori di crittografia.
All'interno AWS KMS, le conversioni di testo cifrato non elaborato e i calcoli del SM2 DSA Message Digest avvengono automaticamente. Non tutti i provider di crittografia implementano allo stesso modo. SM2 Alcune librerie, come [OpenSSL](https://openssl.org/) versione 1.1.1 e successive, eseguono queste azioni automaticamente. AWS KMS ha confermato questo comportamento durante i test con OpenSSL versione 3.0. Utilizza la seguente classe `SM2OfflineOperationHelper` con librerie, come [Bouncy Castle](https://www.bouncycastle.org/java.html), che richiedono di eseguire manualmente queste conversioni e calcoli.
La classe `SM2OfflineOperationHelper` fornisce metodi per le seguenti operazioni offline:
+
**Calcolo del digest del messaggio**
Per generare un riepilogo dei messaggi offline da utilizzare per la verifica offline o da trasferire AWS KMS per firmare, utilizza questo metodo. `calculateSM2Digest` Il `calculateSM2Digest` metodo genera un digest dei messaggi con l'algoritmo di SM3 hashing. L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API restituisce la chiave pubblica in formato binario. È necessario analizzare la chiave binaria in un file Java PublicKey. Fornisci il messaggio alla chiave pubblica analizzata. Il metodo combina automaticamente il tuo messaggio con l'ID distintivo predefinito, `1234567812345678`, ma è possibile impostare il proprio ID distintivo modificando il valore `DEFAULT_DISTINGUISHING_ID`.
+
**Verify**
Per verificare la firma offline, usa il metodo `offlineSM2DSAVerify`. Il metodo `offlineSM2DSAVerify` utilizza il digest del messaggio calcolato dall'ID distintivo specificato e il messaggio originale fornito per verificare la firma digitale. L'[GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)API restituisce la chiave pubblica in formato binario. È necessario analizzare la chiave binaria in un file Java PublicKey. Fornisci alla chiave pubblica analizzata il messaggio originale e la firma che desideri verificare. Per maggiori dettagli, consulta [Verifica offline con coppie di SM2 chiavi](#key-spec-sm-offline-verification).
+
**Encrypt**
Per crittografare il testo normale offline utilizza il metodo `offlineSM2PKEEncrypt`. Questo metodo garantisce che il testo cifrato sia in un formato AWS KMS decifrabile. Il `offlineSM2PKEEncrypt` metodo cripta il testo non crittografato e quindi converte il testo cifrato non elaborato prodotto da PKE nel formato ASN.1. SM2 L'API restituisce la chiave pubblica in formato binario. [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) È necessario analizzare la chiave binaria in un file Java PublicKey. Fornisci alla chiave pubblica analizzata il testo normale che desideri crittografare.
Se non sei sicuro di dover eseguire la conversione, usa la seguente operazione OpenSSL per testare il formato del tuo testo criptato. Se l'operazione non riesce, è necessario convertire il testo criptato nel formato ASN.1.
```
openssl asn1parse -inform DER -in ciphertext.der
```
Per impostazione predefinita, la `SM2OfflineOperationHelper` classe utilizza l'ID distintivo predefinito quando genera i `1234567812345678` digest dei messaggi per SM2 le operazioni DSA.
```
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");
}
}
```