Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

SDK de cifrado de AWS para Java

En este tema se explica cómo instalar y utilizar el SDK de cifrado de AWS para Java. Para obtener más información sobre la programación con SDK de cifrado de AWS para Java, consulte el aws-encryption-sdk-javarepositorio en GitHub. Para obtener API documentación, consulte el Javadoc de. SDK de cifrado de AWS para Java

Requisitos previos

Antes de instalar el SDK de cifrado de AWS para Java, asegúrese de cumplir los siguientes requisitos previos.

Instalación

Instale la versión más reciente de SDK de cifrado de AWS para Java.

Puede instalarlo de SDK de cifrado de AWS para Java las siguientes maneras.

Después de instalar elSDK, comience consultando el ejemplo de código Java de esta guía y el Javadoc en el siguiente. GitHub

AWS KMS llaveros en el SDK de cifrado de AWS para Java

Versión 3. x de los SDK de cifrado de AWS para Java utiliza anillos de claves para realizar el cifrado de sobres. Los AWS KMS llaveros básicos solo admiten SDK de cifrado de AWS para Java una KMS clave. También requieren un AWS KMS cliente, lo que le da la oportunidad de configurar el cliente para Región de AWS la KMS clave.

Para crear un AWS KMS llavero con una o más llaves de embalaje, utilice un llavero múltiple. SDK de cifrado de AWS para Java Tiene un llavero especial con varios llaveros que admite una o más AWS KMS llaves y un llavero estándar con varios llaveros de cualquier tipo compatible. Algunos programadores prefieren usar un método de llaveros múltiples para crear todos sus llaveros, y este método apoya esa estrategia. SDK de cifrado de AWS para Java

SDK de cifrado de AWS para Java Proporciona llaveros básicos de una sola tecla y varios llaveros para todos los casos de uso típicos, incluidas las claves multirregionales. AWS KMS

Por ejemplo, para crear un AWS KMS llavero con una sola AWS KMS tecla, puede utilizar el método]. 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);

Para crear un llavero con una o más AWS KMS claves, utilice el CreateAwsKmsMultiKeyring() método. En este ejemplo se utilizan dos claves de KMS. Para especificar una KMS clave, utilice únicamente el generator parámetro. El msKeyIds parámetro que especifica KMS claves adicionales es opcional.

La entrada de este conjunto de claves no requiere un AWS KMS cliente. En su lugar, AWS Encryption SDK utiliza el AWS KMS cliente predeterminado para cada región representado por una KMS clave en el anillo de claves. Por ejemplo, si la KMS clave identificada por el valor del Generator parámetro se encuentra en la región EE.UU. Oeste (Oregón) (us-west-2), se AWS Encryption SDK crea un AWS KMS cliente predeterminado para la us-west-2 región. Si necesita personalizar el AWS KMS cliente, utilice el CreateAwsKmsKeyring() método.

// 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 = materialProviders.CreateAwsKmsMultiKeyring(keyringInput);

SDK de cifrado de AWS para Java admite conjuntos de AWS KMS claves que utilizan cifrado simétrico (SYMMETRIC_DEFAULT) o claves RSA KMS asimétricas. AWS KMS los llaveros creados con RSA KMS claves asimétricas solo pueden contener un par de claves.

Para cifrar con un RSA AWS KMS anillo de claves asimétrico, no necesita kms: GenerateDataKey ni KMS:Encrypt, ya que debe especificar el material de clave pública que desea utilizar para el cifrado al crear el anillo de claves. No se realizan AWS KMS llamadas al cifrar con este anillo de claves. Para descifrar con un RSA AWS KMS anillo de claves asimétrico, necesita el permiso KMS:Decrypt.

Para crear un conjunto de claves asimétrico, debe proporcionar la RSA AWS KMS clave pública y la clave privada de su clave asimétrica. ARN RSA KMS La clave pública debe estar codificada. PEM En el siguiente ejemplo, se crea un AWS KMS llavero con un par de RSA claves asimétricas.

// 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);

Contextos de cifrado necesarios en la versión 3.x

Con la versión 3. x de SDK de cifrado de AWS para Java, puede usar el contexto de cifrado requerido CMM para requerir contextos de cifrado en sus operaciones criptográficas. Un contexto de cifrado es un conjunto de pares de clave-valor no secretos. El contexto de cifrado se vincula criptográficamente a los datos cifrados, de tal forma que se requiere el mismo contexto de cifrado para descifrar los datos. Si utiliza el contexto de cifrado requeridoCMM, puede especificar una o más claves de contexto de cifrado necesarias (claves obligatorias) que deben incluirse en todas las llamadas de cifrado y descifrado.

Al cifrar, AWS Encryption SDK comprueba que todas las claves de contexto de cifrado necesarias estén incluidas en el contexto de cifrado que especificó. Firma AWS Encryption SDK los contextos de cifrado que especificó. Solo los pares clave-valor que no son claves obligatorias se serializan y almacenan en texto no cifrado en el encabezado del mensaje cifrado que devuelve la operación de cifrado.

Al descifrar, debe proporcionar un contexto de cifrado que contenga todos los pares clave-valor que representan las claves necesarias. AWS Encryption SDK Utiliza este contexto de cifrado y los pares clave-valor almacenados en el encabezado del mensaje cifrado para reconstruir el contexto de cifrado original que especificó en la operación de cifrado. Si AWS Encryption SDK no se puede reconstruir el contexto de cifrado original, se produce un error en la operación de descifrado. Si proporciona un par clave-valor que contiene la clave requerida con un valor incorrecto, el mensaje cifrado no se puede descifrar. Debe proporcionar el mismo par clave-valor que se especificó al cifrar.

El siguiente ejemplo inicializa un conjunto de AWS KMS claves con el contexto de cifrado requerido. 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()
        );