AWS Encryption SDK 구성 - AWS Encryption SDK
프로그래밍 언어 선택래핑 키 선택다중 리전 사용AWS KMS keys알고리즘 제품군 선택암호화된 데이터 키 제한약정 정책 설정스트리밍 데이터 사용캐시 데이터 키

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

AWS Encryption SDK 구성

이AWS Encryption SDK사용하기 쉽도록 설계되었습니다. 비록AWS Encryption SDK에는 여러 가지 구성 옵션이 있으며, 기본값은 대부분의 응용 프로그램에서 실용적이고 안전하도록 신중하게 선택됩니다. 하지만 성능을 향상시키거나 설계에 사용자 지정 기능을 포함하려면 구성을 조정해야 할 수 있습니다.

구현을 구성할 때는 다음을 검토하십시오.AWS Encryption SDK 모범 사례가능한 한 많이 구현하십시오.

프로그래밍 언어 선택

이AWS Encryption SDK여러 가지로 제공됩니다.프로그래밍 언어. 언어 구현은 서로 다른 방식으로 구현될 수 있지만 완전히 상호 운용이 가능하고 동일한 기능을 제공하도록 설계되었습니다. 일반적으로 애플리케이션과 호환되는 라이브러리를 사용합니다. 하지만 특정 구현에 사용할 프로그래밍 언어를 선택할 수도 있습니다. 예를 들어, 함께 일하는 것을 선호하는 경우열쇠 고리, 선택할 수 있습니다AWS Encryption SDK for C또는AWS Encryption SDK for JavaScript.

래핑 키 선택

이AWS Encryption SDK각 메시지를 암호화하기 위해 고유한 대칭 데이터 키를 생성합니다. 사용하지 않는 한데이터 키 캐싱, 데이터 키를 구성, 관리 또는 사용할 필요가 없습니다. 이AWS Encryption SDK이 작업을 수행합니다.

하지만 각 데이터 키를 암호화하려면 하나 이상의 래핑 키를 선택해야 합니다. 이AWS Encryption SDK다양한 크기의 AES 대칭 키와 RSA 비대칭 키를 지원합니다. 또한 지원합니다AWS Key Management Service(AWS KMS) 대칭 암호화AWS KMS keys. 래핑 키의 안전과 내구성에 대한 책임은 사용자에게 있으므로 하드웨어 보안 모듈이나 키 인프라 서비스 (예: 다음과 같은 키 인프라 서비스에서 암호화 키를 사용하는 것이 좋습니다.AWS KMS.

암호화 및 암호 해독을 위한 래핑 키를 지정하려면 키링 (C 및) 을 사용합니다. JavaScript) 또는 마스터 키 제공자 (자바, 파이썬,AWS암호화 (CLI). 하나의 래핑 키 또는 동일하거나 다른 유형의 여러 래핑 키를 지정할 수 있습니다. 여러 개의 래핑 키를 사용하여 데이터 키를 래핑하는 경우 각 래핑 키는 동일한 데이터 키의 사본을 암호화합니다. 암호화된 데이터 키 (래핑 키당 하나) 는 암호화된 데이터와 함께 암호화된 메시지에 저장됩니다.AWS Encryption SDK반환 형식. 데이터를 해독하려면AWS Encryption SDK먼저 래핑 키 중 하나를 사용하여 암호화된 데이터 키를 해독해야 합니다.

다음을 지정하려면AWS KMS key키링 또는 마스터 키 제공자의 경우 지원되는 키 사용AWS KMS키 식별자. 의 키 식별자에 대한 자세한 내용은AWS KMS키, 참조주요 식별자에서AWS Key Management Service개발자 안내서.

  • 를 사용하여 암호화하는 경우AWS Encryption SDK for Java,AWS Encryption SDK for JavaScript,AWS Encryption SDK for Python, 또는AWS암호화 CLI를 사용하면 KMS 키에 유효한 키 ID, 키 ID, 키 ARN, 별칭 이름 또는 별칭 ARN) 을 사용할 수 있습니다. 를 사용하여 암호화하는 경우AWS Encryption SDK for C, 키 ID 또는 키 ARN만 사용할 수 있습니다.

    암호화할 때 KMS 키에 별칭 이름 또는 별칭 ARN을 지정하는 경우AWS Encryption SDK현재 해당 별칭과 연결된 키 ARN을 저장합니다. 별칭은 저장하지 않습니다. 별칭을 변경해도 데이터 키를 해독하는 데 사용되는 KMS 키에는 영향을 주지 않습니다.

  • 엄격 모드 (특정 래핑 키 지정) 에서 복호화할 때는 키 ARN을 사용하여 식별해야 합니다.AWS KMS keys. 이 요구 사항은 AWS Encryption SDK의 모든 언어 구현에 적용됩니다.

    를 사용하여 암호화하는 경우AWS KMS키링,AWS Encryption SDK의 키 ARN 저장합니다.AWS KMS key암호화된 데이터 키의 메타데이터에서 엄격 모드에서 해독하는 경우AWS Encryption SDK래핑 키를 사용하여 암호화된 데이터 키를 해독하기 전에 키링 (또는 마스터 키 공급자) 에 동일한 키 ARN이 나타나는지 확인합니다. 다른 키 식별자를 사용하는 경우AWS Encryption SDK인식하지 못하거나 사용하지 않습니다.AWS KMS key, 식별자가 동일한 키를 참조하더라도

a를 지정하려면원시 AES 키또는 a원시 RSA key pair키링의 래핑 키로 네임스페이스와 이름을 지정해야 합니다. 마스터 키 제공자의 경우Provider ID는 네임스페이스와 동일합니다.Key ID는 이름과 동일합니다. 암호를 해독할 때는 암호화할 때 사용한 것과 동일한 네임스페이스 및 이름을 각 원시 래핑 키에 사용해야 합니다. 다른 네임스페이스 또는 이름을 사용하는 경우AWS Encryption SDK키 자료가 동일하더라도 래핑 키를 인식하거나 사용할 수 없습니다.

다중 리전 사용AWS KMS keys

다음을 사용할 수 있음AWS Key Management Service(AWS KMS) 랩핑 키로 사용되는 다중 리전 키AWS Encryption SDK. 다중 리전 키를 하나로 통합한 경우AWS 리전, 다른 지역의 관련 다중 지역 키를 사용하여 암호를 해독할 수 있습니다.AWS 리전. 다중 지역 키에 대한 Support 버전 2.3에 도입되었습니다.X의AWS Encryption SDK및 버전 3.0.X의AWS암호화 CLI.

AWS KMS다중 리전 키는 집합입니다.AWS KMS keys다르게AWS 리전동일한 키 구성 요소와 키 ID를 갖습니다. 이 기능을 사용할 수 있습니다.관련키는 다른 지역에서 동일한 키인 것처럼 보입니다. 다중 지역 키는 지역 간 호출 없이 한 지역에서 암호화하고 다른 지역에서 해독해야 하는 일반적인 재해 복구 및 백업 시나리오를 지원합니다.AWS KMS. 다중 리전 키에 대한 내용은 단원을 참조하십시오.다중 리전 키 사용에서AWS Key Management Service개발자 안내서.

다중 리전 키를 지원하려면AWS Encryption SDK가 포함되어 있습니다AWS KMS다중 지역 인식 키링 및 마스터 키 제공자. 각 프로그래밍 언어의 새 다중 리전 키와 다중 리전 키를 모두 지원합니다.

  • 단일 지역 키의 경우 다중 영역 인식 기호는 단일 영역과 동일하게 동작합니다.AWS KMS키링 및 마스터 키 제공자. 데이터를 암호화한 단일 지역 키로만 암호문을 해독하려고 시도합니다.

  • 다중 지역 키의 경우 다중 지역 인식 기호는 데이터를 암호화한 동일한 다중 지역 키 또는 지정한 지역의 관련 다중 지역 키를 사용하여 암호문을 해독하려고 시도합니다.

둘 이상의 KMS 키를 사용하는 다중 지역 인식 키 링과 마스터 키 공급자에서는 단일 지역 및 다중 지역 키를 여러 개 지정할 수 있습니다. 그러나 관련된 다중 리전 키 집합에서 하나의 키만 지정할 수 있습니다. 동일한 키 ID로 두 개 이상의 키 식별자를 지정하는 경우 생성자 호출이 실패합니다.

표준 단일 리전에서 다중 리전에서 사용할 수도 있습니다.AWS KMS키링 및 마스터 키 제공자 하지만 암호화하고 해독하려면 동일한 지역에서 동일한 다중 지역 키를 사용해야 합니다. 단일 지역 키링 및 마스터 키 제공자는 데이터를 암호화한 키로만 암호문을 해독하려고 시도합니다.

다음 예제는 다중 지역 키와 새로운 다중 지역 인식 키링 및 마스터 키 공급자를 사용하여 데이터를 암호화하고 해독하는 방법을 보여줍니다. 다음 예제는 의 데이터를 암호화합니다.us-east-1에서 데이터를 영역 지정 및 암호 해독합니다.us-west-2각 리전에서 관련된 다중 리전 키를 사용하는 리전에서 사용합니다. 예제 다중 리전 키 ARN을 의 유효한 값으로 교체한 후에 이러한 예를 실행합니다.AWS 계정.

C

다중 리전 키로 암호화하려면Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()키링을 인스턴스화하는 메서드. 다중 리전 키를 지정합니다.

이 간단한 예제에는암호화 컨텍스트. C에서 암호화 컨텍스트를 사용하는 예제는 을 참조하십시오.문자열 암호화 및 해독.

전체 관련 예제는 단원을 참조하십시오.kms_multi_region_keys.cpp에서AWS Encryption SDK for C리포지토리 GitHub.

/* Encrypt with a multi-Region KMS key in us-east-1 */

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Initialize a multi-Region keyring */
const char *mrk_us_east_1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";   

struct aws_cryptosdk_keyring *mrk_keyring = 
    Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder().Build(mrk_us_east_1);

/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
    aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_ENCRYPT, mrk_keyring);

aws_cryptosdk_keyring_release(mrk_keyring);

/* Encrypt the data
 *   aws_cryptosdk_session_process_full is designed for non-streaming data
 */
aws_cryptosdk_session_process_full(
    session, ciphertext, ciphertext_buf_sz, &ciphertext_len, plaintext, plaintext_len));

/* Clean up the session */
aws_cryptosdk_session_destroy(session);
C# / .NET

미국 동부 (버지니아 북부)) (us-east-1))))) 리전에서 다중 리전 키를 사용하여 암호화하려면 a를 인스턴스화합니다.CreateAwsKmsMrkKeyringInput다중 지역 키의 키 식별자가 있는 객체와AWS KMS지정된 지역의 클라이언트 그런 다음 사용CreateAwsKmsMrkKeyring()키링을 만드는 방법.

이CreateAwsKmsMrkKeyring()메서드는 정확히 하나의 다중 영역 키로 키링을 만듭니다. 다중 지역 키를 포함하여 여러 래핑 키로 암호화하려면CreateAwsKmsMrkMultiKeyring()메서드.

전체 관련 예제는 단원을 참조하십시오.AwsKmsMrkKeyringExample.cs에서AWS Encryption SDK.NET GitHub.

//Encrypt with a multi-Region KMS key in us-east-1 Region

// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();


// Multi-Region keys have a distinctive key ID that begins with 'mrk'
// Specify a multi-Region key in us-east-1
string mrkUSEast1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";

// Create the keyring
// You can specify the Region or get the Region from the key ARN
var createMrkEncryptKeyringInput = new CreateAwsKmsMrkKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USEast1),
    KmsKeyId = mrkUSEast1
};
var mrkEncryptKeyring = materialProviders.CreateAwsKmsMrkKeyring(createMrkEncryptKeyringInput);

// Define the encryption context
var encryptionContext = new Dictionary<string, string>()
{
    {"purpose", "test"}
};

// Encrypt your plaintext data.
var encryptInput = new EncryptInput
{
    Plaintext = plaintext,
    Keyring = mrkEncryptKeyring,
    EncryptionContext = encryptionContext
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
AWS Encryption CLI

이 예제는 를 암호화합니다.hello.txtus-east-1 리전에서 사용합니다. 이 예제에서는 Region 요소를 사용하여 키 ARN을 지정하므로 이 예제에서는부위의 속성--wrapping-keys파라미터.

래핑 키의 키 ID가 지역을 지정하지 않는 경우 다음을 사용할 수 있습니다.부위의 속성--wrapping-keys지역을 지정하려면 다음과 같이 하십시오.--wrapping-keys key=$keyID region=us-east-1.

# Encrypt with a multi-Region KMS key in us-east-1 Region

# To run this example, replace the fictitious key ARN with a valid value.
$ mrkUSEast1=arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab

$ aws-encryption-cli --encrypt \
                     --input hello.txt \
                     --wrapping-keys key=$mrkUSEast1 \
                     --metadata-output ~/metadata \
                     --encryption-context purpose=test \
                     --output .
Java

다중 리전 키를 인스턴스화합니다.AwsKmsMrkAwareMasterKeyProvider다중 리전 키를 지정합니다.

전체 관련 예제는 단원을 참조하십시오.BasicMultiRegionKeyEncryptionExample.java implement에서AWS Encryption SDK for Java리포지토리 GitHub.

//Encrypt with a multi-Region KMS key in us-east-1 Region

// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
    .withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
    .build();

// Multi-Region keys have a distinctive key ID that begins with 'mrk'
// Specify a multi-Region key in us-east-1
final String mrkUSEast1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";

// Instantiate an AWS KMS master key provider in strict mode for multi-Region keys
// Configure it to encrypt with the multi-Region key in us-east-1
final AwsKmsMrkAwareMasterKeyProvider kmsMrkProvider = AwsKmsMrkAwareMasterKeyProvider
    .builder()
    .buildStrict(mrkUSEast1);

// Create an encryption context
final Map<String, String> encryptionContext = Collections.singletonMap("Purpose", "Test");

// Encrypt your plaintext data
final CryptoResult<byte[], AwsKmsMrkAwareMasterKey> encryptResult = crypto.encryptData(
    kmsMrkProvider,
    encryptionContext,
    sourcePlaintext);
byte[] ciphertext = encryptResult.getResult();
JavaScript Browser

다중 리전 키로 암호화하려면buildAwsKmsMrkAwareStrictMultiKeyringBrowser()키링을 생성하고 다중 지역 키를 지정하는 메서드입니다.

전체 관련 예제는 단원을 참조하십시오.kms_멀티_레지온_심플.ts에서AWS Encryption SDK for JavaScript리포지토리 GitHub.

/* Encrypt with a multi-Region KMS key in us-east-1 Region */

import {
  buildAwsKmsMrkAwareStrictMultiKeyringBrowser,
  buildClient,
  CommitmentPolicy,
  KMS,
} from '@aws-crypto/client-browser'


/* Instantiate an AWS Encryption SDK client */
const { encrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

declare const credentials: {
  accessKeyId: string
  secretAccessKey: string
  sessionToken: string
}

/* Instantiate an AWS KMS client 
 * The AWS Encryption SDK for JavaScript gets the Region from the key ARN
 */
const clientProvider = (region: string) => new KMS({ region, credentials })


/* Specify a multi-Region key in us-east-1 */
const multiRegionUsEastKey =
    'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'

/* Instantiate the keyring */
const encryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringBrowser({
    generatorKeyId: multiRegionUsEastKey,
    clientProvider,
  })


/* Set the encryption context */
const context = {
    purpose: 'test',
  }

/* Test data to encrypt */
const cleartext = new Uint8Array([1, 2, 3, 4, 5])

/* Encrypt the data */
const { result } = await encrypt(encryptKeyring, cleartext, {
    encryptionContext: context,
  })
JavaScript Node.js

다중 리전 키로 암호화하려면buildAwsKmsMrkAwareStrictMultiKeyringNode()키링을 생성하고 다중 지역 키를 지정하는 메서드입니다.

전체 관련 예제는 단원을 참조하십시오.kms_멀티_레지온_심플.ts에서AWS Encryption SDK for JavaScript리포지토리 GitHub.

//Encrypt with a multi-Region KMS key in us-east-1 Region

import { buildClient } from '@aws-crypto/client-node'

/* Instantiate the AWS Encryption SDK client
const { encrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

/* Test string to encrypt */
const cleartext = 'asdf'

/* Multi-Region keys have a distinctive key ID that begins with 'mrk'
 * Specify a multi-Region key in us-east-1
 */
const multiRegionUsEastKey =
    'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'

/* Create an AWS KMS keyring */
const mrkEncryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringNode({
    generatorKeyId: multiRegionUsEastKey,
  })

/* Specify an encryption context */
const context = {
    purpose: 'test',
  }

/* Create an encryption keyring */
const { result } = await encrypt(mrkEncryptKeyring, cleartext, {
    encryptionContext: context,
  })
Python

를 사용하여 암호화하려면AWS KMS다중 지역 키, 사용MRKAwareStrictAwsKmsMasterKeyProvider()메서드를 사용하고 다중 리전 키를 지정합니다.

전체 관련 예제는 단원을 참조하십시오.mrk_aware_kms_provider.py에서AWS Encryption SDK for Python리포지토리 GitHub.

* Encrypt with a multi-Region KMS key in us-east-1 Region

# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT)

# Specify a multi-Region key in us-east-1
mrk_us_east_1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab"

# Use the multi-Region method to create the master key provider
# in strict mode
strict_mrk_key_provider = MRKAwareStrictAwsKmsMasterKeyProvider(
        key_ids=[mrk_us_east_1]
)

# Set the encryption context
encryption_context = {
        "purpose": "test"
    }

# Encrypt your plaintext data
ciphertext, encrypt_header = client.encrypt(
        source=source_plaintext,
        encryption_context=encryption_context,
        key_provider=strict_mrk_key_provider
)

다음으로 암호문을us-west-2리전. 암호문을 다시 암호화할 필요가 없습니다.

엄격 모드에서 암호문을 해독하려면us-west-2지역, 관련 다중 지역 키의 키 ARN을 사용하여 다중 지역 인식 기호를 인스턴스화합니다.us-west-2리전. 다른 지역에서 관련 다중 지역 키의 키 ARN을 지정하는 경우 (포함)us-east-1, 암호화된 경우), 다중 지역 인식 기호는 이를 지역 간 호출합니다.AWS KMS key.

엄격 모드에서 복호화할 때 다중 지역 인식 기호에는 키 ARN이 필요합니다. 관련된 다중 리전 키집합에서 하나의 키 ARN만 허용합니다.

예제 다중 리전 키 ARN을 의 유효한 값으로 교체한 후에 이러한 예를 실행합니다.AWS 계정.

C

다중 리전 키를 사용하여 엄격 모드에서 암호를 해독하려면Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()키링을 인스턴스화하는 메서드. 관련 다중 리전에서 키를 지정합니다.

전체 관련 예제는 단원을 참조하십시오.kms_multi_region_keys.cpp에서AWS Encryption SDK for C리포지토리 GitHub.

/* Decrypt with a related multi-Region KMS key in us-west-2 Region */

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Initialize a multi-Region keyring */
const char *mrk_us_west_2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";    

struct aws_cryptosdk_keyring *mrk_keyring = 
    Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder().Build(mrk_us_west_2);

/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
    aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_ENCRYPT, mrk_keyring);

aws_cryptosdk_session_set_commitment_policy(session,
    COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT);

aws_cryptosdk_keyring_release(mrk_keyring);

/* Decrypt the ciphertext 
 *   aws_cryptosdk_session_process_full is designed for non-streaming data
 */
aws_cryptosdk_session_process_full(
    session, plaintext, plaintext_buf_sz, &plaintext_len, ciphertext, ciphertext_len));

/* Clean up the session */
aws_cryptosdk_session_destroy(session);
C# / .NET

엄격 모드에서 단일 다중 지역 키로 암호를 해독하려면 입력을 조합하고 암호화용 키링을 만들 때 사용한 것과 동일한 생성자와 메서드를 사용하십시오. a 인스턴스화CreateAwsKmsMrkKeyringInput관련 다중 지역 키의 키 ARN을 가진 객체와AWS KMS미국 서부 (오레곤) (us-west-2))) 리전에서 사용할 수 있는 클라이언트 그런 다음 사용CreateAwsKmsMrkKeyring()하나의 다중 지역 KMS 키로 다중 지역 키링을 만드는 방법입니다.

전체 관련 예제는 단원을 참조하십시오.AwsKmsMrkKeyringExample.cs에서AWS Encryption SDK.NET GitHub.

// Decrypt with a related multi-Region KMS key in us-west-2 Region

// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();

// Specify the key ARN of the multi-Region key in us-west-2
string mrkUSWest2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";

// Instantiate the keyring input
// You can specify the Region or get the Region from the key ARN
var createMrkDecryptKeyringInput = new CreateAwsKmsMrkKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    KmsKeyId = mrkUSWest2
};

// Create the multi-Region keyring        
var mrkDecryptKeyring = materialProviders.CreateAwsKmsMrkKeyring(createMrkDecryptKeyringInput);

// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
    Ciphertext = ciphertext,
    Keyring = mrkDecryptKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
AWS Encryption CLI

us-west-2 지역의 관련 다중 지역 키로 암호를 해독하려면키의 속성--wrapping-keys키 ARN을 지정하는 매개 변수입니다.

# Decrypt with a related multi-Region KMS key in us-west-2 Region

# To run this example, replace the fictitious key ARN with a valid value.
$ mrkUSWest2=arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab

$ aws-encryption-cli --decrypt \
                     --input hello.txt.encrypted \
                     --wrapping-keys key=$mrkUSWest2 \
                     --commitment-policy require-encrypt-require-decrypt \
                     --encryption-context purpose=test \
                     --metadata-output ~/metadata \
                     --max-encrypted-data-keys 1 \
                     --buffer \
                     --output .
Java

엄격 모드에서 암호를 해독하려면 다음을 인스턴스화합니다.AwsKmsMrkAwareMasterKeyProvider그리고 로컬 (us-west-2))) 리전에서 지정합니다.

전체 관련 예제는 단원을 참조하십시오.BasicMultiRegionKeyEncryptionExample.java implement에서AWS Encryption SDK for Java리포지토리 GitHub.

// Decrypt with a related multi-Region KMS key in us-west-2 Region

// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
    .withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
    .build();

// Related multi-Region keys have the same key ID. Their key ARNs differs only in the Region field.
String mrkUSWest2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";

// Use the multi-Region method to create the master key provider
// in strict mode
AwsKmsMrkAwareMasterKeyProvider kmsMrkProvider = AwsKmsMrkAwareMasterKeyProvider.builder()
    .buildStrict(mrkUSWest2);

// Decrypt your ciphertext
CryptoResult<byte[], AwsKmsMrkAwareMasterKey> decryptResult = crypto.decryptData(
        kmsMrkProvider,
        ciphertext);
byte[] decrypted = decryptResult.getResult();
JavaScript Browser

엄격 모드에서 암호를 해독하려면buildAwsKmsMrkAwareStrictMultiKeyringBrowser()키링을 생성하고 로컬 (us-west-2)) 리전에서 지정하는 메서드입니다.

전체 관련 예제는 단원을 참조하십시오.kms_멀티_레지온_심플.ts에서AWS Encryption SDK for JavaScript리포지토리 GitHub.

/* Decrypt with a related multi-Region KMS key in us-west-2 Region */

import {
  buildAwsKmsMrkAwareStrictMultiKeyringBrowser,
  buildClient,
  CommitmentPolicy,
  KMS,
} from '@aws-crypto/client-browser'


/* Instantiate an AWS Encryption SDK client */
const { decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

declare const credentials: {
  accessKeyId: string
  secretAccessKey: string
  sessionToken: string
}

/* Instantiate an AWS KMS client 
 * The AWS Encryption SDK for JavaScript gets the Region from the key ARN
 */
const clientProvider = (region: string) => new KMS({ region, credentials })


/* Specify a multi-Region key in us-west-2 */
const multiRegionUsWestKey =
    'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'

/* Instantiate the keyring */
const mrkDecryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringBrowser({
    generatorKeyId: multiRegionUsWestKey,
    clientProvider,
  })


/* Decrypt the data */
const { plaintext, messageHeader } = await decrypt(mrkDecryptKeyring, result)
JavaScript Node.js

엄격 모드에서 암호를 해독하려면buildAwsKmsMrkAwareStrictMultiKeyringNode()키링을 생성하고 로컬 (us-west-2)) 리전에서 지정하는 메서드입니다.

전체 관련 예제는 단원을 참조하십시오.kms_멀티_레지온_심플.ts에서AWS Encryption SDK for JavaScript리포지토리 GitHub.

/* Decrypt with a related multi-Region KMS key in us-west-2 Region */

import { buildClient } from '@aws-crypto/client-node'

/* Instantiate the client
const { decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

/* Multi-Region keys have a distinctive key ID that begins with 'mrk'
 * Specify a multi-Region key in us-east-1
 */
const multiRegionUsWestKey =
    'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'

/* Create an AWS KMS keyring */
const mrkDecryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringNode({
    generatorKeyId: multiRegionUsWestKey,
  })

/* Decrypt your ciphertext */
const { plaintext, messageHeader } = await decrypt(decryptKeyring, result)
Python

엄격 모드에서 암호를 해독하려면MRKAwareStrictAwsKmsMasterKeyProvider()마스터 키 제공자를 생성하는 메서드입니다. 관련 다중 리전에서 키를 지정합니다.

전체 관련 예제는 단원을 참조하십시오.mrk_aware_kms_provider.py에서AWS Encryption SDK for Python리포지토리 GitHub.

# Decrypt with a related multi-Region KMS key in us-west-2 Region

# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT)

# Related multi-Region keys have the same key ID. Their key ARNs differs only in the Region field
mrk_us_west_2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab"

# Use the multi-Region method to create the master key provider
# in strict mode
strict_mrk_key_provider = MRKAwareStrictAwsKmsMasterKeyProvider(
        key_ids=[mrk_us_west_2]
)

# Decrypt your ciphertext
plaintext, _ = client.decrypt(
        source=ciphertext, 
        key_provider=strict_mrk_key_provider
)

에서 암호를 해독할 수도 있습니다.검색 모드와AWS KMS다중 리전 키. 검색 모드에서 암호를 해독할 때는 아무 것도 지정하지 않습니다.AWS KMS keys. (단일 지역에 대한 자세한 내용)AWS KMS디스커버리 키링, 참조AWS KMS Discovery 키 링 사용.)

다중 지역 키로 암호화한 경우 검색 모드의 다중 지역 인식 기호는 로컬 지역의 관련 다중 지역 키를 사용하여 암호 해독을 시도합니다. 없는 경우 호출이 실패합니다. 디스커버리 모드에서는AWS Encryption SDK암호화에 사용되는 다중 지역 키에 대해서는 지역 간 호출을 시도하지 않습니다.

참고

검색 모드에서 다중 영역 인식 기호를 사용하여 데이터를 암호화하는 경우 암호화 작업이 실패합니다.

다음 예제에서는 검색 모드에서 다중 영역 인식 기호를 사용하여 암호를 해독하는 방법을 보여 줍니다. 당신이 지정하지 않기 때문에AWS KMS key, 그AWS Encryption SDK다른 소스에서 지역을 가져와야 합니다. 가능하면 로컬 지역을 명시적으로 지정하십시오. 그렇지 않으면AWS Encryption SDK에 구성된 지역에서 로컬 지역을 가져옵니다.AWS사용 중인 프로그래밍 언어의 SDK.

예제 계정 ID와 다중 리전 키 ARN을 유효한 값으로 교체한 후에 이러한 예를 실행합니다.AWS 계정.

C

다중 리전 키를 사용하여 검색 모드에서 암호를 해독하려면Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder()메서드. 로컬 지역을 지정하려면 a를 정의하십시오.ClientConfiguration그리고 에서 지정하십시오AWS KMS클라이언트.

전체 관련 예제는 단원을 참조하십시오.kms_multi_region_keys.cpp에서AWS Encryption SDK for C리포지토리 GitHub.

/* Decrypt in discovery mode with a multi-Region KMS key */

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Construct a discovery filter for the account and partition. The
 *  filter is optional, but it's a best practice that we recommend.
 */
const char *account_id = "111122223333";
const char *partition = "aws";
const std::shared_ptr<Aws::Cryptosdk::KmsKeyring::DiscoveryFilter> discovery_filter =
    Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder(partition).AddAccount(account_id).Build();

/* Create an AWS KMS client in the desired region. */
const char *region = "us-west-2";

Aws::Client::ClientConfiguration client_config;
client_config.region = region;
const std::shared_ptr<Aws::KMS::KMSClient> kms_client =
    Aws::MakeShared<Aws::KMS::KMSClient>("AWS_SAMPLE_CODE", client_config);

struct aws_cryptosdk_keyring *mrk_keyring = 
    Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()
        .WithKmsClient(kms_client)
        .BuildDiscovery(region, discovery_filter);

/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
    aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_DECRYPT, mrk_keyring);

aws_cryptosdk_keyring_release(mrk_keyring);
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
/* Decrypt the ciphertext 
 *   aws_cryptosdk_session_process_full is designed for non-streaming data
 */
aws_cryptosdk_session_process_full(
    session, plaintext, plaintext_buf_sz, &plaintext_len, ciphertext, ciphertext_len));

/* Clean up the session */
aws_cryptosdk_session_destroy(session);
C# / .NET

에서 다중 리전 인식 검색 키링을 생성하려면AWS Encryption SDKSDK for .NETCreateAwsKmsMrkDiscoveryKeyringInput를 취하는 객체AWS KMS특정 고객을 위한 클라이언트AWS 리전및 KMS 키를 특정 키로 제한하는 선택적 검색 필터AWS파티션 및 계정. 그런 다음 전화하십시오.CreateAwsKmsMrkDiscoveryKeyring()입력 객체를 사용한 메서드. 전체 관련 예제는 단원을 참조하십시오.AwsKmsMrkDiscoveryKeyringExample.cs에서AWS Encryption SDK.NET GitHub.

둘 이상의 리전에서 사용할 수 있는 다중 리전에서 인식하는 검색 키링을 만들려면AWS 리전사용CreateAwsKmsMrkDiscoveryMultiKeyring()다중 키링을 만들거나 사용하는 방법CreateAwsKmsMrkDiscoveryKeyring()여러 지역을 인식하는 검색 키링을 여러 개 만든 다음CreateMultiKeyring()다중 키링으로 결합하는 방법.

관련 예제는 단원을 참조하십시오.AwsKmsMrkDiscoveryMultiKeyringExample.cs.

// Decrypt in discovery mode with a multi-Region KMS key

// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();

List<string> account = new List<string> { "111122223333" };

// Instantiate the discovery filter
DiscoveryFilter mrkDiscoveryFilter = new DiscoveryFilter()
{
    AccountIds = account,
    Partition = "aws"
}

// Create the keyring
var createMrkDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    DiscoveryFilter = mrkDiscoveryFilter
};
var mrkDiscoveryKeyring = materialProviders.CreateAwsKmsMrkDiscoveryKeyring(createMrkDiscoveryKeyringInput);


// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
    Ciphertext = ciphertext,
    Keyring = mrkDiscoveryKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
AWS Encryption CLI

검색 모드에서 암호를 해독하려면발견의 속성--wrapping-keys파라미터. 이검색 계정과검색 파티션특성은 선택 사항이며, 권장 사항은 아니지만 권장 사항은 아닙니다.

지역을 지정하기 위한 이 명령에는부위의 속성--wrapping-keys파라미터.

# Decrypt in discovery mode with a multi-Region KMS key

$ aws-encryption-cli --decrypt \
                     --input hello.txt.encrypted \
                     --wrapping-keys discovery=true \ 
                                     discovery-account=111122223333 \
                                     discovery-partition=aws \
                                     region=us-west-2 \
                     --encryption-context purpose=test \
                     --metadata-output ~/metadata \
                     --max-encrypted-data-keys 1 \
                     --buffer \
                     --output .
Java

로컬 지역을 지정하려면builder().withDiscoveryMrkRegion파라미터. 그렇지 않으면AWS Encryption SDK에 구성된 지역에서 로컬 지역을 가져옵니다.AWS SDK for Java.

전체 관련 예제는 단원을 참조하십시오.DiscoveryMultiRegionDecryptionExamplejava implement에서AWS Encryption SDK for Java리포지토리 GitHub.

// Decrypt in discovery mode with a multi-Region KMS key

// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
    .withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
    .build();
                
DiscoveryFilter discoveryFilter = new DiscoveryFilter("aws", 111122223333);

AwsKmsMrkAwareMasterKeyProvider mrkDiscoveryProvider = AwsKmsMrkAwareMasterKeyProvider
    .builder()
    .withDiscoveryMrkRegion(Region.US_WEST_2)
    .buildDiscovery(discoveryFilter);

// Decrypt your ciphertext
final CryptoResult<byte[], AwsKmsMrkAwareMasterKey> decryptResult = crypto
    .decryptData(mrkDiscoveryProvider, ciphertext);
JavaScript Browser

대칭형 다중 지역 키로 검색 모드에서 암호를 해독하려면AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser()메서드.

전체 관련 예제는 단원을 참조하십시오.kms_멀티_지역_디스커버리.ts에서AWS Encryption SDK for JavaScript리포지토리 GitHub.

/* Decrypt in discovery mode with a multi-Region KMS key */

import {
  AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser,
  buildClient,
  CommitmentPolicy,
  KMS,
} from '@aws-crypto/client-browser'


/* Instantiate an AWS Encryption SDK client */
const { decrypt } = buildClient()

declare const credentials: {
  accessKeyId: string
  secretAccessKey: string
  sessionToken: string
}

/* Instantiate the KMS client with an explicit Region */
const client = new KMS({ region: 'us-west-2', credentials })


/* Create a discovery filter */
const discoveryFilter = { partition: 'aws', accountIDs: ['111122223333'] }


/* Create an AWS KMS discovery keyring */
const mrkDiscoveryKeyring = new AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser({
    client,
    discoveryFilter,
  })


/* Decrypt the data */
const { plaintext, messageHeader } = await decrypt(mrkDiscoveryKeyring, ciphertext)
JavaScript Node.js

대칭형 다중 지역 키로 검색 모드에서 암호를 해독하려면AwsKmsMrkAwareSymmetricDiscoveryKeyringNode()메서드.

전체 관련 예제는 단원을 참조하십시오.kms_멀티_지역_디스커버리.ts에서AWS Encryption SDK for JavaScript리포지토리 GitHub.

/* Decrypt in discovery mode with a multi-Region KMS key */

import {
  AwsKmsMrkAwareSymmetricDiscoveryKeyringNode,
  buildClient,
  CommitmentPolicy,
  KMS,
} from '@aws-crypto/client-node'

/* Instantiate the Encryption SDK client
const { decrypt } = buildClient()

/* Instantiate the KMS client with an explicit Region */
const client = new KMS({ region: 'us-west-2' })

/* Create a discovery filter */
const discoveryFilter = { partition: 'aws', accountIDs: ['111122223333'] }

/* Create an AWS KMS discovery keyring */
const mrkDiscoveryKeyring = new AwsKmsMrkAwareSymmetricDiscoveryKeyringNode({
    client,
    discoveryFilter,
  })

/* Decrypt your ciphertext */
const { plaintext, messageHeader } = await decrypt(mrkDiscoveryKeyring, result)
Python

다중 리전 키를 사용하여 검색 모드에서 암호를 해독하려면MRKAwareDiscoveryAwsKmsMasterKeyProvider()메서드.

전체 관련 예제는 단원을 참조하십시오.mrk_aware_kms_provider.py에서AWS Encryption SDK for Python리포지토리 GitHub.

# Decrypt in discovery mode with a multi-Region KMS key

# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient()

# Create the discovery filter and specify the region
decrypt_kwargs = dict(
        discovery_filter=DiscoveryFilter(account_ids="111122223333", partition="aws"),
        discovery_region="us-west-2",
    )

# Use the multi-Region method to create the master key provider
# in discovery mode
mrk_discovery_key_provider = MRKAwareDiscoveryAwsKmsMasterKeyProvider(**decrypt_kwargs)

# Decrypt your ciphertext
plaintext, _ = client.decrypt(
        source=ciphertext, 
        key_provider=mrk_discovery_key_provider
)

알고리즘 제품군 선택

이AWS Encryption SDK다중 지원대칭 및 비대칭 암호화 알고리즘지정한 래핑 키로 데이터 키를 암호화하는 데 사용됩니다. 그러나 해당 데이터 키를 사용하여 데이터를 암호화하는 경우AWS Encryption SDK기본값은 a입니다.권장 알고리즘 모음AES-GCM 알고리즘을 다음과 같이 사용합니다.키 추출된,디지털 서명, 및주요 약정. 기본 알고리즘 스위트가 대부분의 애플리케이션에 적합할 수 있지만 대체 알고리즘 제품군을 선택할 수 있습니다. 예를 들어, 일부 신뢰 모델은 없는 알고리즘 제품군에 의해 충족될 수 있습니다.디지털 서명. 알고리즘 제품군에 대한 자세한 내용은AWS Encryption SDK지원, 참조AWS Encryption SDK에서 지원되는 알고리즘 세트.

다음 예제는 암호화할 때 대체 알고리즘 제품군을 선택하는 방법을 보여줍니다. 이 예제에서는 키 도출 및 키 약정이 있지만 디지털 서명은 없는 권장 AES-GCM 알고리즘 제품군을 선택합니다. 디지털 서명이 포함되지 않은 알고리즘 제품군으로 암호화하는 경우 암호 해독 시 서명되지 않은 전용 암호 해독 모드를 사용하십시오. 서명된 암호문을 발견하면 실패하는 이 모드는 스트리밍 복호화 시 가장 유용합니다.

C

대체 알고리즘 제품군을 지정하려면AWS Encryption SDK for C, CMM을 명시적으로 만들어야 합니다. 그런 다음 사용aws_cryptosdk_default_cmm_set_alg_idCMM 및 선택한 알고리즘 제품군을 사용합니다.

/* Specify an algorithm suite without signing */

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);

/* To set an alternate algorithm suite, create an cryptographic 
   materials manager (CMM) explicitly
 */
struct aws_cryptosdk_cmm *cmm = aws_cryptosdk_default_cmm_new(aws_default_allocator(), kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring); 

/* Specify the algorithm suite for the CMM */
aws_cryptosdk_default_cmm_set_alg_id(cmm, ALG_AES256_GCM_HKDF_SHA512_COMMIT_KEY);
    
/* Construct the session with the CMM, 
   then release the CMM reference 
 */
struct aws_cryptosdk_session *session = aws_cryptosdk_session_new_from_cmm_2(alloc, AWS_CRYPTOSDK_ENCRYPT, cmm);
aws_cryptosdk_cmm_release(cmm);

/* Encrypt the data 
   Use aws_cryptosdk_session_process_full with non-streaming data
 */
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(
                          session, 
                          ciphertext, 
                          ciphertext_buf_sz, 
                          &ciphertext_len, 
                          plaintext, 
                          plaintext_len)) {
    aws_cryptosdk_session_destroy(session);
    return AWS_OP_ERR;
}

디지털 서명 없이 암호화된 데이터를 해독할 때는 다음을 사용하십시오.AWS_CRYPTOSDK_DECRYPT_UNSIGNED. 이로 인해 서명된 암호문이 발견되면 암호 해독에 실패합니다.

/* Decrypt unsigned streaming data */

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
    
/* Create a session for decrypting with the AWS KMS keyring
   Then release the keyring reference
 */
struct aws_cryptosdk_session *session =
        aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT_UNSIGNED, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring); 
   
if (!session) {
    return AWS_OP_ERR;
}
    
/* Limit encrypted data keys */
aws_cryptosdk_session_set_max_encrypted_data_keys(session, 1);
  
/* Decrypt 
   Use aws_cryptosdk_session_process_full with non-streaming data
 */
    if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(
                          session,                          
                          plaintext,
                          plaintext_buf_sz,
                          &plaintext_len,
                          ciphertext,
                          ciphertext_len)) {
    aws_cryptosdk_session_destroy(session);
    return AWS_OP_ERR;
}
C# / .NET

대체 알고리즘 제품군을 지정하려면AWS Encryption SDKSDK for .NETAlgorithmSuiteId의 속성입니다.EncryptInputobject. 이AWS Encryption SDK.NET용 포함상수이를 사용하여 선호하는 알고리즘 세트를 식별할 수 있습니다.

이AWS Encryption SDKfor .NET에는 스트리밍 데이터를 지원하지 않기 때문에 스트리밍 복호화 시 서명된 암호문을 탐지하는 메서드가 없습니다.

// Specify an algorithm suite without signing

// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();

// Create the keyring
var keyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = keyArn
};
var keyring = materialProviders.CreateAwsKmsKeyring(keyringInput);

// Encrypt your plaintext data
var encryptInput = new EncryptInput
{
    Plaintext = plaintext,
    Keyring = keyring,
    AlgorithmSuiteId = AlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
AWS Encryption CLI

암호화할 때hello.txtfile, 이 예에서는--algorithm디지털 서명이 없는 알고리즘 제품군을 지정하는 파라미터입니다.

# Specify an algorithm suite without signing

# To run this example, replace the fictitious key ARN with a valid value.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab

$ aws-encryption-cli --encrypt \
                     --input hello.txt \
                     --wrapping-keys key=$keyArn \
                     --algorithm AES_256_GCM_HKDF_SHA512_COMMIT_KEY \
                     --metadata-output ~/metadata \
                     --encryption-context purpose=test \
                     --commitment-policy require-encrypt-require-decrypt \
                     --output hello.txt.encrypted \
                     --decode

이 예제에서는 암호를 해독할 때--decrypt-unsigned파라미터. 이 매개 변수는 특히 입력과 출력을 항상 스트리밍하는 CLI에서 부호가 없는 암호문을 해독하는 데 권장됩니다.

# Decrypt unsigned streaming data

# To run this example, replace the fictitious key ARN with a valid value.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab

$ aws-encryption-cli --decrypt-unsigned \
                     --input hello.txt.encrypted \
                     --wrapping-keys key=$keyArn \
                     --max-encrypted-data-keys 1 \
                     --commitment-policy require-encrypt-require-decrypt \
                     --encryption-context purpose=test \
                     --metadata-output ~/metadata \
                     --output .
Java

대체 알고리즘 제품군을 지정하려면AwsCrypto.builder().withEncryptionAlgorithm()메서드. 이 예제에서는 디지털 서명이 없는 대체 알고리즘 제품군을 지정합니다.

// Specify an algorithm suite without signing

// Instantiate the client
AwsCrypto crypto = AwsCrypto.builder()
    .withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
    .withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY)
    .build();

String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

// Create a master key provider in strict mode
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
    .buildStrict(awsKmsKey);
    
// Create an encryption context to identify this ciphertext
        Map<String, String> encryptionContext = Collections.singletonMap("Example", "FileStreaming");

// Encrypt your plaintext data
CryptoResult<byte[], KmsMasterKey> encryptResult = crypto.encryptData(
    masterKeyProvider,
    sourcePlaintext,
    encryptionContext);
byte[] ciphertext = encryptResult.getResult();

복호화를 위해 데이터를 스트리밍할 때는createUnsignedMessageDecryptingStream()해독하는 모든 암호문이 서명되지 않았는지 확인하는 메서드입니다.

// Decrypt unsigned streaming data

// Instantiate the client
AwsCrypto crypto = AwsCrypto.builder()
  .withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
  .withMaxEncryptedDataKeys(1)
  .build();

// Create a master key provider in strict mode
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
  .buildStrict(awsKmsKey);

// Decrypt the encrypted message
FileInputStream in = new FileInputStream(srcFile + ".encrypted");  
CryptoInputStream<KmsMasterKey> decryptingStream = crypto.createUnsignedMessageDecryptingStream(masterKeyProvider, in);
  
// Return the plaintext data
// Write the plaintext data to disk
FileOutputStream out = new FileOutputStream(srcFile + ".decrypted");
IOUtils.copy(decryptingStream, out);
decryptingStream.close();
JavaScript Browser

대체 알고리즘 제품군을 지정하려면suiteId파라미터AlgorithmSuiteIdentifier열거형.

// Specify an algorithm suite without signing

// Instantiate the client 
const { encrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )

// Specify a KMS key 
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

// Create a keyring with the KMS key
const keyring = new KmsKeyringBrowser({ generatorKeyId })

// Encrypt your plaintext data 
const { result } = await encrypt(keyring, cleartext, { suiteId: AlgorithmSuiteIdentifier.ALG_AES256_GCM_IV12_TAG16_HKDF_SHA512_COMMIT_KEY, encryptionContext: context, })

암호를 해독할 때는 표준을 사용하십시오.decrypt메서드.AWS Encryption SDK for JavaScript브라우저에는decrypt-unsigned브라우저가 스트리밍을 지원하지 않기 때문입니다.

// Decrypt unsigned streaming data

// Instantiate the client 
const { decrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )

// Create a keyring with the same KMS key used to encrypt
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"; 
const keyring = new KmsKeyringBrowser({ generatorKeyId })

// Decrypt the encrypted message 
const { plaintext, messageHeader } = await decrypt(keyring, ciphertextMessage)
JavaScript Node.js

대체 알고리즘 제품군을 지정하려면suiteId파라미터AlgorithmSuiteIdentifier열거형.

// Specify an algorithm suite without signing

// Instantiate the client 
const { encrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )

// Specify a KMS key
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

// Create a keyring with the KMS key
const keyring = new KmsKeyringNode({ generatorKeyId })

// Encrypt your plaintext data 
const { result } = await encrypt(keyring, cleartext, { suiteId: AlgorithmSuiteIdentifier.ALG_AES256_GCM_IV12_TAG16_HKDF_SHA512_COMMIT_KEY, encryptionContext: context, })

디지털 서명 없이 암호화된 데이터를 해독할 때는 다음을 사용하십시오. decryptUnsignedMessage스트림. 이 메서드는 서명된 암호문을 발견하면 실패합니다.

// Decrypt unsigned streaming data

// Instantiate the client 
const { decryptUnsignedMessageStream } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )

// Create a keyring with the same KMS key used to encrypt
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"; 
const keyring = new KmsKeyringNode({ generatorKeyId })

// Decrypt the encrypted message 
const outputStream = createReadStream(filename) .pipe(decryptUnsignedMessageStream(keyring))
Python

대체 암호화 알고리즘을 지정하려면algorithm파라미터Algorithm열거형.

# Specify an algorithm suite without signing

# Instantiate a client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT, 
                                                max_encrypted_data_keys=1)

# Create a master key provider in strict mode
aws_kms_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
aws_kms_strict_master_key_provider = StrictAwsKmsMasterKeyProvider(
        key_ids=[aws_kms_key]
)

# Encrypt the plaintext using an alternate algorithm suite
ciphertext, encrypted_message_header = client.encrypt(
    algorithm=Algorithm.AES_256_GCM_HKDF_SHA512_COMMIT_KEY, source=source_plaintext, key_provider=kms_key_provider
)

디지털 서명 없이 암호화된 메시지를 해독할 때는decrypt-unsigned스트리밍 모드 (특히 스트리밍 중 복호화할 때) 

# Decrypt unsigned streaming data

# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT, 
                                                max_encrypted_data_keys=1)

# Create a master key provider in strict mode
aws_kms_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
aws_kms_strict_master_key_provider = StrictAwsKmsMasterKeyProvider(
        key_ids=[aws_kms_key]
)

# Decrypt with decrypt-unsigned
with open(ciphertext_filename, "rb") as ciphertext, open(cycled_plaintext_filename, "wb") as plaintext:
    with client.stream(mode="decrypt-unsigned", 
                       source=ciphertext, 
                       key_provider=master_key_provider) as decryptor:
        for chunk in decryptor:
            plaintext.write(chunk)

# Verify that the encryption context
assert all(
   pair in decryptor.header.encryption_context.items() for pair in encryptor.header.encryption_context.items()
)
return ciphertext_filename, cycled_plaintext_filename

암호화된 데이터 키 제한

암호화된 메시지의 암호화된 데이터 키 수를 제한할 수 있습니다. 이 모범 사례 기능은 암호화 시 잘못 구성된 키링을 탐지하거나 복호화할 때 악성 암호문을 탐지하는 데 도움이 될 수 있습니다. 또한 주요 인프라에 대한 불필요하고 비용이 많이 들며 잠재적으로 철저한 호출을 방지할 수 있습니다. 암호화된 데이터 키를 제한하는 것은 신뢰할 수 없는 출처의 메시지를 해독할 때 가장 유용합니다.

대부분의 암호화된 메시지에는 암호화에 사용되는 각 래핑 키마다 암호화된 데이터 키가 하나씩 있지만 암호화된 메시지에는 최대 65,535개의 암호화된 데이터 키가 포함될 수 있습니다. 악의적인 공격자는 수천 개의 암호화된 데이터 키로 암호화된 메시지를 만들 수 있으며, 이 중 어느 것도 해독할 수 없습니다. 그 결과AWS Encryption SDK메시지의 암호화된 데이터 키가 모두 소진될 때까지 암호화된 각 데이터 키를 해독하려고 시도합니다.

암호화된 데이터 키를 제한하려면MaxEncryptedDataKeys파라미터. 이 매개 변수는 버전 1.9부터 지원되는 모든 프로그래밍 언어에서 사용할 수 있습니다.X그리고 2.2입니다.X의AWS Encryption SDK. 암호화 및 복호화 시 선택적이며 유효합니다. 다음 예에서는 세 가지 다른 래핑 키로 암호화된 데이터를 해독합니다. 이MaxEncryptedDataKeys이 값은 3으로 설정됩니다.

C
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = 
      Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn1, { key_arn2, key_arn3 });

/* Create a session */
struct aws_cryptosdk_session *session = 
    aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);

/* Limit encrypted data keys */
aws_cryptosdk_session_set_max_encrypted_data_keys(session, 3);
  
/* Decrypt */
size_t ciphertext_consumed_output;
aws_cryptosdk_session_process(session,
    plaintext_output,
    plaintext_buf_sz_output,
    &plaintext_len_output,
    ciphertext_input,
    ciphertext_len_input,
    &ciphertext_consumed_output);
assert(aws_cryptosdk_session_is_done(session));
assert(ciphertext_consumed == ciphertext_len);
C# / .NET

암호화된 데이터 키를 제한하려면AWS Encryption SDK.NET의 경우 에 대한 클라이언트를 인스턴스화합니다.AWS Encryption SDK.NET의 경우 선택 사항으로 설정MaxEncryptedDataKeys파라미터는 원하는 값으로 그런 다음 전화해Decrypt()구성된 메서드AWS Encryption SDK예.

// Decrypt with limited data keys

// Instantiate the material providers
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();

// Configure the commitment policy on the AWS Encryption SDK instance
var config = new AwsEncryptionSdkConfig
{
    MaxEncryptedDataKeys = 3
};
var encryptionSdk = AwsEncryptionSdkFactory.CreateAwsEncryptionSdk(config);

// Create the keyring
string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
var createKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = keyArn
};
var decryptKeyring = materialProviders.CreateAwsKmsKeyring(createKeyringInput);

// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
    Ciphertext = ciphertext,
    Keyring = decryptKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
AWS Encryption CLI
# Decrypt with limited encrypted data keys

$ aws-encryption-cli --decrypt \
    --input hello.txt.encrypted \
    --wrapping-keys key=$key_arn1 key=$key_arn2 key=$key_arn3 \
    --buffer \
    --max-encrypted-data-keys 3 \
    --encryption-context purpose=test \
    --metadata-output ~/metadata \
    --output .
Java
// Construct a client with limited encrypted data keys
final AwsCrypto crypto = AwsCrypto.builder()
  .withMaxEncryptedDataKeys(3)
  .build();

// Create an AWS KMS master key provider
final KmsMasterKeyProvider keyProvider = KmsMasterKeyProvider.builder()
      .buildStrict(keyArn1, keyArn2, keyArn3);
   
// Decrypt
final CryptoResult<byte[], KmsMasterKey> decryptResult = crypto.decryptData(keyProvider, ciphertext)
JavaScript Browser
// Construct a client with limited encrypted data keys
const { encrypt, decrypt } = buildClient({ maxEncryptedDataKeys: 3 })

declare const credentials: {
  accessKeyId: string
  secretAccessKey: string
  sessionToken: string
}
const clientProvider = getClient(KMS, {
  credentials: { accessKeyId, secretAccessKey, sessionToken }
})

// Create an AWS KMS keyring
const keyring = new KmsKeyringBrowser({
  clientProvider,
  keyIds: [keyArn1, keyArn2, keyArn3],
})

// Decrypt
const { plaintext, messageHeader } = await decrypt(keyring, ciphertext)
JavaScript Node.js
// Construct a client with limited encrypted data keys
const { encrypt, decrypt } = buildClient({ maxEncryptedDataKeys: 3 })

// Create an AWS KMS keyring
const keyring = new KmsKeyringBrowser({
  keyIds: [keyArn1, keyArn2, keyArn3],
})
  
// Decrypt
const { plaintext, messageHeader } = await decrypt(keyring, ciphertext)
Python
# Instantiate a client with limited encrypted data keys
client = aws_encryption_sdk.EncryptionSDKClient(max_encrypted_data_keys=3)

# Create an AWS KMS master key provider
master_key_provider = aws_encryption_sdk.StrictAwsKmsMasterKeyProvider(
    key_ids=[key_arn1, key_arn2, key_arn3])

# Decrypt
plaintext, header = client.decrypt(source=ciphertext, key_provider=master_key_provider)

약정 정책 설정

A약정 정책애플리케이션의 암호화 및 암호 해독 여부를 결정하는 구성 설정입니다.주요 약정. 키 커밋을 통한 암호화 및 복호화는AWS Encryption SDK모범 사례.

약정 정책을 설정하고 조정하는 것은 중요한 단계입니다.이주버전 1.7부터.X그리고 그 이전AWS Encryption SDK버전 2.0로 업데이트.X그리고 나중에. 이 진행 상황은 에 자세히 설명되어 있습니다.마이그레이션 주제.

최신 버전의 기본 약정 정책 값입니다.AWS Encryption SDK(버전 2.0부터 시작.X),RequireEncryptRequireDecrypt, 대부분의 상황에 이상적입니다. 하지만 키 약정 없이 암호화된 암호문을 해독해야 하는 경우 약정 정책을 다음과 같이 변경해야 할 수 있습니다.RequireEncryptAllowDecrypt. 각 프로그래밍 언어에서 약정 정책을 설정하는 방법의 예는 다음을 참조하십시오.약정 정책 설정.

스트리밍 데이터 사용

복호화를 위해 데이터를 스트리밍할 때는 다음 사항에 유의하세요.AWS Encryption SDK무결성 검사가 완료된 후 디지털 서명이 검증되기 전에 해독된 일반 텍스트를 반환합니다. 서명이 확인될 때까지 일반 텍스트를 반환하거나 사용하지 않으려면 전체 암호 해독 프로세스가 완료될 때까지 스트리밍된 일반 텍스트를 버퍼링하는 것이 좋습니다.

이 문제는 암호 해독을 위해 암호문을 스트리밍하는 경우에만 발생하며 다음과 같은 알고리즘 제품군을 사용하는 경우에만 발생합니다.디폴트 알고리즘 제품군, 여기에는 다음이 포함됩니다.디지털 서명.

버퍼링을 더 쉽게 하기 위해, 일부AWS Encryption SDK언어 구현 (예:AWS Encryption SDK for JavaScriptNode.js 에서는 암호 해독 방법의 일부로 버퍼링 기능을 포함합니다. 이AWS입력 및 출력을 항상 스트리밍하는 암호화 CLI 도입--buffer버전 1.9의 매개 변수.X그리고 2.2입니다.X. 다른 언어 구현에서는 기존 버퍼링 기능을 사용할 수 있습니다. (더AWS Encryption SDKfor .NET은 스트리밍을 지원하지 않습니다.)

디지털 서명이 없는 알고리즘 제품군을 사용하는 경우 반드시decrypt-unsigned각 언어 구현의 기능. 이 기능은 암호문을 해독하지만 서명된 암호문을 발견하면 실패합니다. 자세한 내용은 알고리즘 제품군 선택 단원을 참조하세요.

캐시 데이터 키

일반적으로 데이터 키를 재사용하는 것은 권장되지 않지만AWS Encryption SDK을 제공합니다데이터 키 캐싱데이터 키를 제한적으로 재사용할 수 있는 옵션입니다. 데이터 키 캐싱은 일부 애플리케이션의 성능을 개선하고 주요 인프라에 대한 호출을 줄일 수 있습니다. 프로덕션에서 데이터 키 캐싱을 사용하기 전에보안 임계값그리고 테스트하여 데이터 키 재사용의 단점보다 이점이 더 큰지 확인하십시오.