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à.

SDK di crittografia AWS per Java

In questo argomento viene descritto come installare e utilizzare SDK di crittografia AWS per Java. Per dettagli sulla programmazione conSDK di crittografia AWS per Java, consulta il aws-encryption-sdk-javarepository su GitHub. Per la documentazione sulle API, consulta Javadoc per il SDK di crittografia AWS per Java.

Prerequisiti

Prima di installare SDK di crittografia AWS per Java, verifica che siano soddisfatti i prerequisiti indicati di seguito.

Installazione

Installa la versione più recente diSDK di crittografia AWS per Java.

Puoi installare il SDK di crittografia AWS per Java in uno dei seguenti modi:

Dopo aver installato l'SDK, inizia a guardare il codice Java di esempio in questa guida e Javadoc attivo. GitHub

AWS KMSportachiavi in SDK di crittografia AWS per Java

Versione 3. x of the SDK di crittografia AWS per Java utilizza i portachiavi per eseguire la crittografia delle buste. I AWS KMS portachiavi di base del KMS SDK di crittografia AWS per Java accettano solo una chiave KMS. Richiedono anche un AWS KMS client, che ti dà l'opportunità di configurare il client per la chiave Regione AWS KMS.

Per creare un AWS KMS portachiavi con una o più chiavi avvolgenti, usa un portachiavi multiplo. SDK di crittografia AWS per JavaHa uno speciale portachiavi multiplo che accetta una o più AWS KMS chiavi e un portachiavi multiplo standard che accetta uno o più portachiavi di qualsiasi tipo supportato. Alcuni programmatori preferiscono utilizzare un metodo con più portachiavi per creare tutti i loro portachiavi e supportano questa strategia. SDK di crittografia AWS per Java

SDK di crittografia AWS per JavaFornisce portachiavi di base a chiave singola e portachiavi multipla per tutti i casi d'uso tipici, comprese le chiavi multiregionali. AWS KMS

Ad esempio, per creare un AWS KMS portachiavi con una sola AWS KMS chiave, è possibile utilizzare il metodo]. CreateAwsKmsKeyring()

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

// Create the keyring
CreateAwsKmsKeyringInput kmsKeyringInput = CreateAwsKmsKeyringInput.builder()
        .kmsKeyId(keyArn)
        .kmsClient(KmsClient.create())
        .build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(kmsKeyringInput);

Per creare un portachiavi con una o più AWS KMS chiavi, utilizzate il CreateAwsKmsMultiKeyring() metodo. Questo esempio utilizza due chiavi KMS. Per specificare una chiave KMS, usa solo il generator parametro. Il msKeyIds parametro che specifica le chiavi KMS aggiuntive è facoltativo.

L'input per questo portachiavi non richiede un client. AWS KMS AWS Encryption SDKUtilizza invece il AWS KMS client predefinito per ogni regione rappresentato da una chiave KMS nel portachiavi. Ad esempio, se la chiave KMS identificata dal valore del Generator parametro si trova nella regione degli Stati Uniti occidentali (Oregon) (us-west-2), AWS Encryption SDK crea un AWS KMS client predefinito per la regione. us-west-2 Se è necessario personalizzare il AWS KMS client, utilizzare il CreateAwsKmsKeyring() metodo.

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
            .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
            .build();

String generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<String> additionalKey = Collections.singletonList("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the keyring
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
        .generator(generatorKey)
        .kmsKeyIds(additionalKey)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMultiKeyring(keyringInput);

SDK di crittografia AWS per Javasupporta AWS KMS portachiavi che utilizzano la crittografia simmetrica (SYMMETRIC_DEFAULT) o le chiavi RSA KMS asimmetriche. AWS KMSi portachiavi creati con chiavi RSA KMS asimmetriche possono contenere solo una coppia di chiavi.

Per crittografare con un AWS KMS portachiavi RSA asimmetrico, non hai bisogno di kms: GenerateDataKey o KMS:Encrypt perché devi specificare il materiale della chiave pubblica che desideri utilizzare per la crittografia quando crei il portachiavi. Non vengono effettuate chiamate durante la crittografia con questo portachiavi. AWS KMS Per decrittografare con un portachiavi AWS KMS RSA asimmetrico, è necessaria l'autorizzazione KMS:Decrypt.

Per creare un AWS KMS portachiavi RSA asimmetrico, devi fornire la chiave pubblica e la chiave privata ARN della tua chiave RSA KMS asimmetrica. La chiave pubblica deve essere codificata in PEM. L'esempio seguente crea un AWS KMS portachiavi con una coppia di chiavi RSA asimmetrica.

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder()
        // Specify algorithmSuite without asymmetric signing here
        //
        // ALG_AES_128_GCM_IV12_TAG16_NO_KDF("0x0014"),
        // ALG_AES_192_GCM_IV12_TAG16_NO_KDF("0x0046"),
        // ALG_AES_256_GCM_IV12_TAG16_NO_KDF("0x0078"),
        // ALG_AES_128_GCM_IV12_TAG16_HKDF_SHA256("0x0114"),
        // ALG_AES_192_GCM_IV12_TAG16_HKDF_SHA256("0x0146"),
        // ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256("0x0178")
        .withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256)
        .build();
                
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

// Create a KMS RSA keyring.
//    This keyring takes in:
//     - kmsClient
//     - kmsKeyId: Must be an ARN representing an asymmetric RSA KMS key
//     - publicKey: A ByteBuffer of a UTF-8 encoded PEM file representing the public
//                  key for the key passed into kmsKeyId
//     - encryptionAlgorithm: Must be either RSAES_OAEP_SHA_256 or RSAES_OAEP_SHA_1
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
        CreateAwsKmsRsaKeyringInput.builder()
                .kmsClient(KmsClient.create())
                .kmsKeyId(rsaKeyArn)
                .publicKey(publicKey)
                .encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
                .build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);

Contesti di crittografia richiesti nella versione 3.x

Con la versione 3. x diSDK di crittografia AWS per Java, è possibile utilizzare il contesto di crittografia richiesto CMM per richiedere contesti di crittografia nelle operazioni crittografiche. Un contesto di crittografia è un insieme di coppie chiave-valore non segrete. Il contesto di crittografia è associato crittograficamente ai dati crittografati in modo che sia necessario lo stesso contesto di crittografia per decrittografare il campo. Quando si utilizza il contesto di crittografia richiesto CMM, è possibile specificare una o più chiavi di contesto di crittografia richieste (chiavi obbligatorie) che devono essere incluse in tutte le chiamate di crittografia e decrittografia.

In encrypt, AWS Encryption SDK verifica che tutte le chiavi del contesto di crittografia richieste siano incluse nel contesto di crittografia specificato. Segna AWS Encryption SDK i contesti di crittografia specificati. Solo le coppie chiave-valore che non sono chiavi richieste vengono serializzate e archiviate in testo semplice nell'intestazione del messaggio crittografato restituito dall'operazione di crittografia.

In decrypt, è necessario fornire un contesto di crittografia che contenga tutte le coppie chiave-valore che rappresentano le chiavi richieste. AWS Encryption SDKUtilizza questo contesto di crittografia e le coppie chiave-valore memorizzate nell'intestazione del messaggio crittografato per ricostruire il contesto di crittografia originale specificato nell'operazione di crittografia. Se AWS Encryption SDK non è possibile ricostruire il contesto di crittografia originale, l'operazione di decrittografia ha esito negativo. Se si fornisce una coppia chiave-valore che contiene la chiave richiesta con un valore errato, il messaggio crittografato non può essere decrittografato. È necessario fornire la stessa coppia chiave-valore specificata in encrypt.

L'esempio seguente inizializza un AWS KMS portachiavi con il contesto di crittografia richiesto CMM.

// Instantiate the AWS Encryption SDK
final AwsCrypto crypto = AwsCrypto.builder()
        .withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
        .build();
    
// Create your encryption context
final Map<String, String> encryptionContext = new HashMap<>();
encryptionContext.put("encryption", "context");
encryptionContext.put("is not", "secret");
encryptionContext.put("but adds", "useful metadata");
encryptionContext.put("that can help you", "be confident that");
encryptionContext.put("the data you are handling", "is what you think it is");    

// Create a list of required encryption contexts
final List<String> requiredEncryptionContextKeys = Arrays.asList("encryption", "context");
    
// Create the keyring
final MaterialProviders materialProviders = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
final CreateAwsKmsKeyringInput keyringInput = CreateAwsKmsKeyringInput.builder()
        .kmsKeyId(keyArn)
        .kmsClient(KmsClient.create())
        .build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(keyringInput);
    
// Create the required encryption context CMM
ICryptographicMaterialsManager cmm = 
    materialProviders.CreateDefaultCryptographicMaterialsManager(
        CreateDefaultCryptographicMaterialsManagerInput.builder()
            .keyring(kmsKeyring)
            .build()
    );
ICryptographicMaterialsManager requiredCMM = 
    materialProviders.CreateRequiredEncryptionContextCMM(
        CreateRequiredEncryptionContextCMMInput.builder()
            .requiredEncryptionContextKeys(requiredEncryptionContextKeys)
            .underlyingCMM(cmm)
            .build()
        );