AWS KMS 키링 - AWS Encryption SDK
AWS KMS 키링에 필요한 권한AWS KMS 키링 AWS KMS keys 에서 식별AWS KMS 키링 생성AWS KMS 검색 키링 사용AWS KMS 리전 검색 키링 사용

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

AWS KMS 키링

AWS KMS 키링은 AWS KMS keys를 사용하여 데이터 키를 생성, 암호화 및 복호화합니다. AWS Key Management Service (AWS KMS)는 KMS 키를 보호하고 FIPS 경계 내에서 암호화 작업을 수행합니다. 가능하면 AWS KMS 키링 또는 유사한 보안 속성을 가진 키링을 사용할 것을 권장합니다.

키링을 지원하는 모든 프로그래밍 언어 구현은 대칭 암호화 KMS 키를 사용하는 AWS KMS 키링을 지원합니다. 다음 프로그래밍 언어 구현은 비대칭 RSA KMS AWS KMS 키를 사용하는 키링도 지원합니다.

  • 의 버전 3.x AWS Encryption SDK for Java

  • .NET AWS Encryption SDK 용의 버전 4.x

  • 선택적 암호화 자료 공급자 라이브러리(MPL) 종속성과 함께 사용하는 AWS Encryption SDK for Python경우 버전 4.x.

  • AWS Encryption SDK for Rust 버전 1.x

  • Go AWS Encryption SDK 용의 버전 0.1.x 이상

다른 언어 구현의 암호화 키링에 비대칭 KMS 키를 포함하려고 하면 암호화 호출이 실패합니다. 복호화 키링에 포함하면 무시됩니다.

AWS 암호화 CLI의 버전 2.3.x AWS Encryption SDK 및 버전 3.0.x부터 AWS KMS 키링 또는 마스터 키 공급자에 AWS KMS 다중 리전 키를 사용할 수 있습니다. multi-Region-aware 기호 사용에 대한 자세한 내용과 예제는 섹션을 참조하세요다중 리전 사용 AWS KMS keys. 다중 리전 키에 대한 자세한 내용은 AWS Key Management Service 개발자 가이드의 다중 리전 키 사용을 참조하세요.

참고

에서 KMS 키링에 AWS Encryption SDK 대한 모든 언급은 AWS KMS 키링을 참조합니다.

AWS KMS 키링에는 두 가지 유형의 래핑 키가 포함될 수 있습니다.

  • 생성기 키: 일반 텍스트 데이터 키를 생성하고 암호화합니다. 데이터를 암호화하는 키링에는 하나의 생성기 키가 있어야 합니다.

  • 추가 키: 생성기 키가 생성한 일반 텍스트 데이터 키를 암호화합니다. AWS KMS 키링에는 0개 이상의 추가 키가 있을 수 있습니다.

메시지를 암호화하려면에 생성기 키가 있어야 합니다. AWS KMS 키링에 KMS 키가 하나만 있는 경우 해당 키는 데이터 키를 생성하고 암호화하는 데 사용됩니다. 복호화할 때 생성기 키는 선택 사항이며 생성기 키와 추가 키의 구분은 무시됩니다.

모든 키링과 마찬가지로 AWS KMS 키링은 독립적으로 사용하거나 동일하거나 다른 유형의 다른 키링과 함께 다중 키링에서 사용할 수 있습니다.

AWS KMS 키링에 필요한 권한

AWS Encryption SDK 에는가 필요하지 AWS 계정 않으며에 의존하지 않습니다 AWS 서비스. 그러나 AWS KMS 키링을 사용하려면 키링 AWS KMS keys 의에 대해 AWS 계정 및 다음과 같은 최소 권한이 필요합니다.

  • AWS KMS 키링으로 암호화하려면 생성기 키에 대한 kms:GenerateDataKey 권한이 필요합니다. AWS KMS 키링의 모든 추가 키에 대해 kms:Encrypt 권한이 필요합니다.

  • AWS KMS 키링으로 복호화하려면 AWS KMS 키링에서 하나 이상의 키에 대한 kms:Decrypt 권한이 필요합니다.

  • AWS KMS 키링으로 구성된 다중 키링으로 암호화하려면 생성기 키링의 생성기 키에 대한 kms:GenerateDataKey 권한이 필요합니다. 다른 모든 키링의 다른 모든 AWS KMS 키에 대해 kms:Encrypt 권한이 필요합니다.

  • 비대칭 RSA AWS KMS 키링으로 암호화하려면 키링을 생성할 때 암호화에 사용할 퍼블릭 키 구성 요소를 지정해야 하므로 kms:GenerateDataKey 또는 kms:Encrypt가 필요하지 않습니다. 이 키링으로 암호화할 때 AWS KMS 호출이 이루어지지 않습니다. 비대칭 RSA AWS KMS 키링으로 복호화하려면 kms:Decrypt 권한이 필요합니다.

권한에 대한 자세한 내용은 AWS Key Management Service 개발자 안내서의 KMS 키 액세스 및 권한을 AWS KMS keys참조하세요.

AWS KMS 키링 AWS KMS keys 에서 식별

AWS KMS 키링은 하나 이상을 포함할 수 있습니다 AWS KMS keys. AWS KMS 키링에서를 지정 AWS KMS key 하려면 지원되는 AWS KMS 키 식별자를 사용합니다. 키링 AWS KMS key 에서를 식별하는 데 사용할 수 있는 키 식별자는 작업 및 언어 구현에 따라 다릅니다. AWS KMS key의 키 식별자에 대한 자세한 내용은 AWS Key Management Service 개발자 가이드의 키 식별자를 참조하세요.

작업에 가장 적합한 키 식별자를 사용하는 것이 모범 사례입니다.

  • 의 암호화 키링에서 키 ARN 또는 별칭 ARN을 사용하여 KMS 키를 식별할 AWS Encryption SDK for C수 있습니다. 다른 모든 언어 구현에서는 키 ID, 키 ARN, 별칭 이름 또는 별칭 ARN을 사용하여 데이터를 암호화할 수 있습니다.

  • 복호화 키링에서는 키 ARN을 사용하여 AWS KMS keys를 식별해야 합니다. 이 요구 사항은 AWS Encryption SDK의 모든 언어 구현에 적용됩니다. 세부 정보는 래핑 키 선택을 참조하세요.

  • 암호화 및 복호화에 사용되는 키 링에서는 키 ARN을 사용하여 AWS KMS keys를 식별해야 합니다. 이 요구 사항은 AWS Encryption SDK의 모든 언어 구현에 적용됩니다.

암호화 키링에서 KMS 키에 대해 별칭 이름 또는 별칭 ARN을 지정하는 경우 암호화 작업은 현재 별칭과 연결된 키 ARN을 암호화된 데이터 키의 메타데이터에 저장합니다. 별칭은 저장되지 않습니다. 별칭을 변경해도 암호화된 데이터 키를 복호화하는 데 사용되는 KMS 키에는 영향을 주지 않습니다.

AWS KMS 키링 생성

및와 동일하거나 다른 AWS KMS keys 에서 단일 AWS KMS key 또는 여러 로 각 AWS KMS 키링을 구성할 수 AWS 계정 있습니다 AWS 리전. 는 대칭 암호화 KMS 키(SYMMETRIC_DEFAULT) 또는 비대칭 RSA KMS 키여야 AWS KMS keys 합니다. 대칭 암호화 다중 리전 KMS 키를 사용할 수도 있습니다. 다중 키링에서도 하나 이상의 AWS KMS 키링을 사용할 수 있습니다.

데이터를 암호화 및 복호화하는 AWS KMS 키링을 생성하거나 암호화 또는 복호화 전용 AWS KMS 키링을 생성할 수 있습니다. 데이터를 암호화하는 AWS KMS 키링을 생성할 때 일반 텍스트 데이터 키를 생성하고 암호화하는 데 사용되는 생성기 키를 지정해야 합니다. AWS KMS key 데이터 키는 KMS 키와 수학적으로 관련이 없습니다. 그런 다음 선택하면 동일한 일반 텍스트 데이터 키를 암호화하는 추가 AWS KMS keys 를 지정할 수 있습니다. 이 키링으로 보호되는 암호화된 필드를 복호화하려면 사용하는 복호화 키링에 키링에 AWS KMS keys 정의된 중 하나 이상이 포함되거나 그렇지 않아야 합니다 AWS KMS keys. (이 없는 AWS KMS 키링 AWS KMS keys 을 AWS KMS 검색 키링이라고 합니다.)

이외의 AWS Encryption SDK 언어 구현에서는 암호화 키링 또는 다중 키링의 AWS Encryption SDK for C모든 래핑 키가 데이터 키를 암호화할 수 있어야 합니다. 래핑 키가 암호화되지 않으면 암호화 메서드가 실패합니다. 따라서 호출자는 키링의 모든 키에 필요한 권한을 가지고 있어야 합니다. 검색 키링을 사용하여 단독 또는 다중 키링으로 데이터를 암호화하는 경우 암호화 작업이 실패합니다. 단 AWS Encryption SDK for C, 암호화 작업은 표준 검색 키링을 무시하지만 다중 리전 검색 키링을 단독으로 지정하거나 다중 키링에서 지정하는 경우 실패하는 경우는 예외입니다.

다음 예제에서는 생성 AWS KMS 기 키와 하나의 추가 키를 사용하여 키링을 생성합니다. 생성기 키와 추가 키는 모두 대칭 암호화 KMS 키입니다. 이 예제에서는 키 ARN을 사용하여 KMS 키를 식별합니다. 이는 암호화에 사용되는 AWS KMS 키링의 모범 사례이며 복호화에 사용되는 AWS KMS 키링의 요구 사항입니다. 세부 정보는 AWS KMS 키링 AWS KMS keys 에서 식별을 참조하세요.

C

AWS KMS key 의 암호화 키링에서를 식별하려면 키 ARN 또는 별칭 ARN을 AWS Encryption SDK for C지정합니다. 복호화 키링에서는 키 ARN을 사용해야 합니다. 자세한 내용은 AWS KMS 키링 AWS KMS keys 에서 식별 섹션을 참조하세요.

전체 예를 보려면 string.cpp를 참조하세요.

const char * generator_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"

const char * additional_key = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"    

struct aws_cryptosdk_keyring *kms_encrypt_keyring = 
       Aws::Cryptosdk::KmsKeyring::Builder().Build(generator_key,{additional_key});
C# / .NET

AWS Encryption SDK for .NET에서 하나 이상의 KMS 키를 사용하여 키링을 생성하려면 CreateAwsKmsMultiKeyring() 메서드를 사용합니다. 이 예제에서는 두 개의 AWS KMS 키를 사용합니다. 한 개의 KMS 키를 지정하려면 Generator 파라미터만 사용합니다. 추가 KMS 키를 지정하는 KmsKeyIds 파라미터는 선택 사항입니다.

이 키링에 대한 입력은 AWS KMS 클라이언트를 가져오지 않습니다. 대신는 키링에서 KMS 키로 표시되는 각 리전에 기본 AWS KMS 클라이언트를 AWS Encryption SDK 사용합니다. 예를 들어 Generator 파라미터 값으로 식별되는 KMS 키가 미국 서부(오레곤) 리전()에 있는 경우 us-west-2는 us-west-2 리전에 대한 기본 AWS KMS 클라이언트를 AWS Encryption SDK 생성합니다. AWS KMS 클라이언트를 사용자 지정해야 하는 경우 CreateAwsKmsKeyring() 메서드를 사용합니다.

AWS Encryption SDK for .NET에서 암호화 키링 AWS KMS key 에 대해를 지정할 때 키 ID, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

다음 예제에서는 .NET AWS Encryption SDK 용의 버전 4.x와 CreateAwsKmsKeyring() 메서드를 사용하여 AWS KMS 클라이언트를 사용자 지정합니다.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<string> additionalKeys = new List<string> { "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321" };

// Instantiate the keyring input object
var createEncryptKeyringInput = new CreateAwsKmsMultiKeyringInput
{
    Generator = generatorKey,
    KmsKeyIds = additionalKeys
};

var kmsEncryptKeyring = materialProviders.CreateAwsKmsMultiKeyring(createEncryptKeyringInput);
JavaScript Browser

에서 암호화 키링에 AWS KMS key 대해를 지정할 때 키 ID AWS Encryption SDK for JavaScript, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

다음 예제에서는 buildClient 함수를 사용하여 기본 커밋 정책인를 지정합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 를 사용하여 암호화된 메시지의 암호화된 데이터 키 수를 제한buildClient할 수도 있습니다. 자세한 내용은 암호화된 데이터 키 제한 단원을 참조하십시오.

전체 예제는 GitHub의 AWS Encryption SDK for JavaScript 리포지토리에서 kms_simple.ts를 참조하세요.

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

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'

const keyring = new KmsKeyringBrowser({
  clientProvider, 
  generatorKeyId, 
  keyIds: [additionalKey] 
})
JavaScript Node.js

에서 암호화 키링에 AWS KMS key 대해를 지정할 때 키 ID AWS Encryption SDK for JavaScript, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

다음 예제에서는 buildClient 함수를 사용하여 기본 커밋 정책인를 지정합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 를 사용하여 암호화된 메시지의 암호화된 데이터 키 수를 제한buildClient할 수도 있습니다. 자세한 내용은 암호화된 데이터 키 제한 단원을 참조하십시오.

전체 예제는 GitHub의 AWS Encryption SDK for JavaScript 리포지토리에서 kms_simple.ts를 참조하세요.

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

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
                            
const additionalKey = 'alias/exampleAlias'

const keyring = new KmsKeyringNode({
  generatorKeyId,
  keyIds: [additionalKey]
})
Java

하나 이상의 키로 AWS KMS 키링을 생성하려면 CreateAwsKmsMultiKeyring() 메서드를 사용합니다. 이 예제에서는 두 개의 KMS 키를 사용합니다. 한 개의 KMS 키를 지정하려면 generator 파라미터만 사용합니다. 추가 KMS 키를 지정하는 msKeyIds 파라미터는 선택 사항입니다.

이 키링에 대한 입력은 AWS KMS 클라이언트를 가져오지 않습니다. 대신는 키링에서 KMS 키로 표시되는 각 리전에 기본 AWS KMS 클라이언트를 AWS Encryption SDK 사용합니다. 예를 들어 Generator 파라미터 값으로 식별되는 KMS 키가 미국 서부(오레곤) 리전()에 있는 경우 us-west-2는 us-west-2 리전에 대한 기본 AWS KMS 클라이언트를 AWS Encryption SDK 생성합니다. AWS KMS 클라이언트를 사용자 지정해야 하는 경우 CreateAwsKmsKeyring() 메서드를 사용합니다.

에서 암호화 키링에 AWS KMS key 대해를 지정할 때 키 ID AWS Encryption SDK for Java, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

전체 예제는 GitHub의 AWS Encryption SDK for Java 리포지토리에서 BasicEncryptionKeyringExample.java를 참조하세요.

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

하나 이상의 키로 AWS KMS 키링을 생성하려면 create_aws_kms_multi_keyring() 메서드를 사용합니다. 이 예제에서는 두 개의 KMS 키를 사용합니다. 한 개의 KMS 키를 지정하려면 generator 파라미터만 사용합니다. 추가 KMS 키를 지정하는 kms_key_ids 파라미터는 선택 사항입니다.

이 키링에 대한 입력은 AWS KMS 클라이언트를 가져오지 않습니다. 대신는 키링에서 KMS 키로 표시되는 각 리전에 기본 AWS KMS 클라이언트를 AWS Encryption SDK 사용합니다. 예를 들어 generator 파라미터 값으로 식별되는 KMS 키가 미국 서부(오레곤) 리전()에 있는 경우 us-west-2는 us-west-2 리전에 대한 기본 AWS KMS 클라이언트를 AWS Encryption SDK 생성합니다. AWS KMS 클라이언트를 사용자 지정해야 하는 경우 create_aws_kms_keyring() 메서드를 사용합니다.

에서 암호화 키링에 AWS KMS key 대해를 지정할 때 키 ID AWS Encryption SDK for Python, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

다음 예제에서는 기본 커밋 정책인를 사용하여 AWS Encryption SDK 클라이언트를 인스턴스화합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 전체 예제는 GitHub의 AWS Encryption SDK for Python 리포지토리에서 aws_kms_keyring_example.py를 참조하세요.

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring 
kms_multi_keyring_input: CreateAwsKmsMultiKeyringInput = CreateAwsKmsMultiKeyringInput(
    generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    kms_key_ids=arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321
)

kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
    input=kms_multi_keyring_input
)
Rust

하나 이상의 키로 AWS KMS 키링을 생성하려면 create_aws_kms_multi_keyring() 메서드를 사용합니다. 이 예제에서는 두 개의 KMS 키를 사용합니다. 한 개의 KMS 키를 지정하려면 generator 파라미터만 사용합니다. 추가 KMS 키를 지정하는 kms_key_ids 파라미터는 선택 사항입니다.

이 키링에 대한 입력은 AWS KMS 클라이언트를 가져오지 않습니다. 대신는 키링에서 KMS 키로 표시되는 각 리전에 기본 AWS KMS 클라이언트를 AWS Encryption SDK 사용합니다. 예를 들어 generator 파라미터 값으로 식별되는 KMS 키가 미국 서부(오레곤) 리전()에 있는 경우 us-west-2는 us-west-2 리전에 대한 기본 AWS KMS 클라이언트를 AWS Encryption SDK 생성합니다. AWS KMS 클라이언트를 사용자 지정해야 하는 경우 create_aws_kms_keyring() 메서드를 사용합니다.

AWS Encryption SDK for Rust에서 암호화 키링 AWS KMS key 에 대해를 지정할 때 키 ID, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

다음 예제에서는 기본 커밋 정책인를 사용하여 AWS Encryption SDK 클라이언트를 인스턴스화합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 전체 예제는 GitHub의 aws-encryption-sdk 리포지토리의 Rust 디렉터리에 있는 aws_kms_keyring_example.rs를 참조하세요. aws-encryption-sdk 

// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
        
// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
    
// Optional: Create an encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create the AWS KMS keyring 
let kms_keyring = mpl
    .create_aws_kms_keyring()
    .kms_key_id(kms_key_id)
    .kms_client(kms_client)
    .send()
    .await?;

kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
    input=kms_multi_keyring_input
)
Go

하나 이상의 키로 AWS KMS 키링을 생성하려면 create_aws_kms_multi_keyring() 메서드를 사용합니다. 이 예제에서는 두 개의 KMS 키를 사용합니다. 한 개의 KMS 키를 지정하려면 generator 파라미터만 사용합니다. 추가 KMS 키를 지정하는 kms_key_ids 파라미터는 선택 사항입니다.

이 키링에 대한 입력은 AWS KMS 클라이언트를 가져오지 않습니다. 대신는 키링에서 KMS 키로 표시되는 각 리전에 기본 AWS KMS 클라이언트를 AWS Encryption SDK 사용합니다. 예를 들어 generator 파라미터 값으로 식별되는 KMS 키가 미국 서부(오레곤) 리전()에 있는 경우 us-west-2는 us-west-2 리전에 대한 기본 AWS KMS 클라이언트를 AWS Encryption SDK 생성합니다. AWS KMS 클라이언트를 사용자 지정해야 하는 경우 create_aws_kms_keyring() 메서드를 사용합니다.

AWS Encryption SDK for Go에서 암호화 키링 AWS KMS key 에 대해를 지정할 때 키 ID, 키 ARN, 별칭 이름 또는 별칭 ARN과 같은 유효한 키 식별자를 사용할 수 있습니다. AWS KMS 키링 AWS KMS keys 에서를 식별하는 데 도움이 필요하면 섹션을 참조하세요AWS KMS 키링 AWS KMS keys 에서 식별.

다음 예제에서는 기본 커밋 정책인를 사용하여 AWS Encryption SDK 클라이언트를 인스턴스화합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT.

import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create the AWS KMS keyring 
awsKmsMultiKeyringInput := mpltypes.CreateAwsKmsMultiKeyringInput{
    Generator: &arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    KmsKeyIds: []string{arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321},
}
awsKmsMultiKeyring, err := matProv.CreateAwsKmsMultiKeyring(context.Background(), awsKmsMultiKeyringInput)

는 비대칭 RSA KMS AWS KMS 키를 사용하는 키링 AWS Encryption SDK 도 지원합니다. 비대칭 RSA AWS KMS 키링에는 키 페어가 하나만 포함될 수 있습니다.

비대칭 RSA AWS KMS 키링으로 암호화하려면 키링을 생성할 때 암호화에 사용할 퍼블릭 키 구성 요소를 지정해야 하므로 kms:GenerateDataKey 또는 kms:Encrypt가 필요하지 않습니다. 이 키링으로 암호화할 때는 AWS KMS 호출이 이루어지지 않습니다. 비대칭 RSA AWS KMS 키링으로 복호화하려면 kms:Decrypt 권한이 필요합니다.

참고

비대칭 RSA KMS 키를 사용하는 AWS KMS 키링을 생성하려면 다음 프로그래밍 언어 구현 중 하나를 사용해야 합니다.

  • 의 버전 3.x AWS Encryption SDK for Java

  • .NET AWS Encryption SDK 용의 버전 4.x

  • 선택적 암호화 자료 공급자 라이브러리(MPL) 종속성과 함께 사용하는 AWS Encryption SDK for Python경우 버전 4.x.

  • AWS Encryption SDK for Rust 버전 1.x

  • Go AWS Encryption SDK 용의 버전 0.1.x 이상

다음 예제에서는 CreateAwsKmsRsaKeyring 메서드를 사용하여 비대칭 RSA KMS 키로 AWS KMS 키링을 생성합니다. 비대칭 RSA AWS KMS 키링을 생성하려면 다음 값을 제공합니다.

  • kmsClient: 새 AWS KMS 클라이언트 생성

  • kmsKeyID: 비대칭 RSA KMS 키를 식별하는 키 ARN

  • publicKey: 전달한 키의 퍼블릭 키를 나타내는 UTF-8 인코딩 PEM 파일의 ByteBuffer kmsKeyID

  • encryptionAlgorithm: 암호화 알고리즘은 RSAES_OAEP_SHA_256 또는 이어야 합니다. RSAES_OAEP_SHA_1

C# / .NET

비대칭 RSA AWS KMS 키링을 생성하려면 비대칭 RSA KMS 키에서 퍼블릭 키와 프라이빗 키 ARN을 제공해야 합니다. 퍼블릭 키는 PEM으로 인코딩되어야 합니다. 다음 예제에서는 비대칭 RSA AWS KMS 키 페어를 사용하여 키링을 생성합니다.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
        
var publicKey = new MemoryStream(Encoding.UTF8.GetBytes(AWS KMS RSA public key));

// Instantiate the keyring input object
var createKeyringInput = new CreateAwsKmsRsaKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = AWS KMS RSA private key ARN,
    PublicKey = publicKey,
    EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};

// Create the keyring
var kmsRsaKeyring = mpl.CreateAwsKmsRsaKeyring(createKeyringInput);
Java

비대칭 RSA AWS KMS 키링을 생성하려면 비대칭 RSA KMS 키에서 퍼블릭 키와 프라이빗 키 ARN을 제공해야 합니다. 퍼블릭 키는 PEM으로 인코딩되어야 합니다. 다음 예제에서는 비대칭 RSA AWS KMS 키 페어를 사용하여 키링을 생성합니다.

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

비대칭 RSA AWS KMS 키링을 생성하려면 비대칭 RSA KMS 키에서 퍼블릭 키와 프라이빗 키 ARN을 제공해야 합니다. 퍼블릭 키는 PEM으로 인코딩되어야 합니다. 다음 예제에서는 비대칭 RSA AWS KMS 키 페어를 사용하여 키링을 생성합니다.

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring 
keyring_input: CreateAwsKmsRsaKeyringInput = CreateAwsKmsRsaKeyringInput(
    public_key=public_key,
    kms_key_id=kms_key_id,
    encryption_algorithm="RSAES_OAEP_SHA_256",
    kms_client=kms_client
)

kms_rsa_keyring: IKeyring = mat_prov.create_aws_kms_rsa_keyring(
    input=keyring_input
)
Rust

비대칭 RSA AWS KMS 키링을 생성하려면 비대칭 RSA KMS 키에서 퍼블릭 키와 프라이빗 키 ARN을 제공해야 합니다. 퍼블릭 키는 PEM으로 인코딩되어야 합니다. 다음 예제에서는 비대칭 RSA AWS KMS 키 페어를 사용하여 키링을 생성합니다.

// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;)

// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);

// Optional: Create an encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create the AWS KMS keyring
let kms_rsa_keyring = mpl
    .create_aws_kms_rsa_keyring()
    .kms_key_id(kms_key_id
    .public_key(aws_smithy_types::Blob::new(public_key))
    .encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
    .kms_client(kms_client)
    .send()
    .await?;
Go
import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create the AWS KMS keyring
awsKmsRSAKeyringInput := mpltypes.CreateAwsKmsRsaKeyringInput{
    KmsClient:           kmsClient,
    KmsKeyId:            kmsKeyID,
    PublicKey:           kmsPublicKey,
    EncryptionAlgorithm: kmstypes.EncryptionAlgorithmSpecRsaesOaepSha256,
}
awsKmsRSAKeyring, err := matProv.CreateAwsKmsRsaKeyring(context.Background(), awsKmsRSAKeyringInput)
if err != nil {
    panic(err)
}

AWS KMS 검색 키링 사용

복호화할 때에서 사용할 AWS Encryption SDK 수 있는 래핑 키를 지정하는 것이 가장 좋습니다. 이 모범 사례를 따르려면 AWS KMS 래핑 키를 지정한 키로 제한하는 AWS KMS 복호화 키링을 사용합니다. 그러나 AWS KMS 검색 키링, 즉 래핑 키를 지정하지 않는 AWS KMS 키링을 생성할 수도 있습니다.

는 표준 AWS KMS 검색 키링과 AWS KMS 다중 리전 키에 대한 검색 키링을 AWS Encryption SDK 제공합니다. AWS Encryption SDK에서 다중 리전 키 사용에 관한 정보는 다중 리전 사용 AWS KMS keys 섹션을 참조하세요.

래핑 키를 지정하지 않기 때문에 검색 키링은 데이터를 암호화할 수 없습니다. 검색 키링을 사용하여 단독 또는 다중 키링으로 데이터를 암호화하는 경우 암호화 작업이 실패합니다. 단 AWS Encryption SDK for C, 암호화 작업은 표준 검색 키링을 무시하지만 다중 리전 검색 키링을 단독으로 지정하거나 다중 키링에서 지정하는 경우 실패하는 경우는 예외입니다.

복호화할 때 검색 키링을 사용하면 AWS Encryption SDK 가 소유자 또는 액세스 권한에 관계없이 암호화된 데이터 키를 AWS KMS key 암호화하는를 사용하여에 암호화된 데이터 키를 복호화 AWS KMS 하도록 요청할 수 있습니다 AWS KMS key. 호출자가 AWS KMS key에 대한 kms:Decrypt 권한이 있는 경우에만 호출이 성공합니다.

중요

복호화 다중 키링에 AWS KMS 검색 키링을 포함하면 검색 키링이 다중 키링의 다른 키링에서 지정한 모든 KMS 키 제한을 재정의합니다. 다중 키링 다중 키링은 제한이 가장 적은 키링처럼 동작합니다. AWS KMS 검색 키링은 단독으로 사용되거나 다중 키링에 사용되는 경우 암호화에 영향을 주지 않습니다.

는 편의를 위해 AWS KMS 검색 키링을 AWS Encryption SDK 제공합니다. 단, 다음과 같은 이유로 가능하면 더 제한적인 키링을 사용하는 것이 좋습니다.

  • 인증 - AWS KMS 검색 키링은 암호화된 메시지에서 데이터 키를 암호화하는 데 AWS KMS key 사용된 모든를 사용할 수 있으므로 호출자는 이를 사용하여 복호화할 수 있는 AWS KMS key 권한을 가집니다. 호출 AWS KMS key 자가 사용하려는이 아닐 수 있습니다. 예를 들어 암호화된 데이터 키 중 하나가 누구나 사용할 수 AWS KMS key 있는 덜 안전한에서 암호화되었을 수 있습니다.

  • 지연 시간 및 성능 - AWS KMS 가 다른 AWS 계정 및 리전 AWS KMS keys 에서에 의해 암호화된 키를 포함하여 암호화된 모든 데이터 키를 복호화하려고 AWS Encryption SDK 하고 AWS KMS keys 호출자가 복호화에 사용할 권한이 없기 때문에 검색 키링이 다른 키링보다 눈에 띄게 느려질 수 있습니다.

검색 키링을 사용하는 경우 검색 필터를 사용하여 지정된 AWS 계정 및 파티션의 키로 사용할 수 있는 KMS 키를 제한하는 것이 좋습니다. 검색 필터는 AWS Encryption SDK버전 1.7.x 이상에서 지원됩니다. 계정 ID 및 파티션을 찾는 데 도움이 필요하면의 AWS 계정 식별자 및 ARN 형식을 참조하세요AWS 일반 참조.

다음 코드는가 사용할 AWS Encryption SDK 수 있는 KMS AWS KMS 키를 aws 파티션 및 111122223333 예제 계정의 키로 제한하는 검색 필터를 사용하여 검색 키링을 인스턴스화합니다.

이 코드를 사용하기 전에 예제 AWS 계정 및 파티션 값을 AWS 계정 및 파티션의 유효한 값으로 바꿉니다. KMS 키가 중국 리전에 있는 경우 aws-cn 파티션 값을 사용하세요. KMS 키가 AWS GovCloud (US) Regions에 있는 경우 aws-us-gov 파티션 값을 사용하세요. 다른 AWS 리전에 있는 경우 aws 파티션 값을 사용하세요.

C

전체 예제는 kms_discovery.cpp를 참조하세요.

std::shared_ptr<KmsKeyring::> discovery_filter(
    KmsKeyring::DiscoveryFilter::Builder("aws")
        .AddAccount("111122223333")
        .Build());

struct aws_cryptosdk_keyring *kms_discovery_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
       .BuildDiscovery(discovery_filter));
C# / .NET

다음 예제에서는 AWS Encryption SDK for .NET 4.x 버전을 사용합니다.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };
        
// In a discovery keyring, you specify an AWS KMS client and a discovery filter,
// but not a AWS KMS key
var kmsDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    DiscoveryFilter = new DiscoveryFilter()
    {
        AccountIds = account,
        Partition = "aws"
    }
};
        
var kmsDiscoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(kmsDiscoveryKeyringInput);
JavaScript Browser

JavaScript에서는 명시적으로 검색 속성을 지정해야 합니다.

다음 예제에서는 buildClient 함수를 사용하여 기본 커밋 정책인를 지정합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 를 사용하여 암호화된 메시지의 암호화된 데이터 키 수를 제한buildClient할 수도 있습니다. 자세한 내용은 암호화된 데이터 키 제한 단원을 참조하십시오.

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

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const discovery = true
const keyring = new KmsKeyringBrowser(clientProvider, {
    discovery,
    discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})
JavaScript Node.js

JavaScript에서는 명시적으로 검색 속성을 지정해야 합니다.

다음 예제에서는 buildClient 함수를 사용하여 기본 커밋 정책인를 지정합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 를 사용하여 암호화된 메시지의 암호화된 데이터 키 수를 제한buildClient할 수도 있습니다. 자세한 내용은 암호화된 데이터 키 제한 단원을 참조하십시오.

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

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const discovery = true

const keyring = new KmsKeyringNode({
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
Java
// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
        .discoveryFilter(discoveryFilter)
        .build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
Python
# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)

# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS discovery keyring
discovery_keyring_input: CreateAwsKmsDiscoveryKeyringInput = CreateAwsKmsDiscoveryKeyringInput(
    kms_client=kms_client,
    discovery_filter=DiscoveryFilter(
        account_ids=[aws_account_id],
        partition="aws"
    )
)

discovery_keyring: IKeyring = mat_prov.create_aws_kms_discovery_keyring(
    input=discovery_keyring_input
)
Rust
// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;

// Create a AWS KMS client.
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);


// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
    .account_ids(vec![aws_account_id.to_string()])
    .partition("aws".to_string())
    .build()?;

// Create the AWS KMS discovery keyring
let discovery_keyring = mpl
    .create_aws_kms_discovery_keyring()
    .kms_client(kms_client.clone())
    .discovery_filter(discovery_filter)
    .send()
    .await?;
Go
import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
    AccountIds: []string{kmsKeyAccountID},
    Partition:  "aws",
}
awsKmsDiscoveryKeyringInput := mpltypes.CreateAwsKmsDiscoveryKeyringInput{
    KmsClient:       kmsClient,
    DiscoveryFilter: &discoveryFilter,
}
awsKmsDiscoveryKeyring, err := matProv.CreateAwsKmsDiscoveryKeyring(context.Background(), awsKmsDiscoveryKeyringInput)
if err != nil {
    panic(err)
}

AWS KMS 리전 검색 키링 사용

AWS KMS 리전 검색 키링은 KMS 키의 ARN을 지정하지 않는 키링입니다. 대신가 특히 KMS 키만 사용하여 복호화 AWS Encryption SDK 할 수 있습니다 AWS 리전.

AWS KMS 리전 검색 키링을 사용하여 복호화할 때는 지정된 AWS KMS key 에서 로 암호화된 모든 암호화된 데이터 키를 AWS Encryption SDK 복호화합니다 AWS 리전. 성공하려면 호출자에게 데이터 키를 암호화 AWS 리전 한 지정된 AWS KMS keys 의에 대한 kms:Decrypt 권한이 하나 이상 있어야 합니다.

다른 검색 키링과 마찬가지로 리전 검색 키링은 암호화에 영향을 주지 않습니다. 암호화된 메시지를 복호화할 때만 작동합니다. 암호화 및 복호화에 사용되는 다중 키링에서 리전 검색 키링을 사용하는 경우 복호화 시에만 유효합니다. 다중 리전 검색 키링을 사용하여 단독 또는 다중 키링으로 데이터를 암호화하는 경우 암호화 작업이 실패합니다.

중요

복호화 다중 키링에 AWS KMS 리전 검색 키링을 포함하는 경우 리전 검색 키링은 다중 키링의 다른 키링에서 지정한 모든 KMS 키 제한을 재정의합니다. 다중 키링 다중 키링은 제한이 가장 적은 키링처럼 동작합니다. AWS KMS 검색 키링은 단독으로 사용되거나 다중 키링에 사용되는 경우 암호화에 영향을 주지 않습니다.

의 리전 검색 키링은 지정된 리전의 KMS 키로만 복호화하려고 AWS Encryption SDK for C 시도합니다. AWS Encryption SDK for JavaScript 및 AWS Encryption SDK for .NET에서 검색 키링을 사용하는 경우 AWS KMS 클라이언트에서 리전을 구성합니다. 이러한 AWS Encryption SDK 구현 AWS KMS 은 리전별로 KMS 키를 필터링하지 않지만 지정된 리전 외부의 KMS 키에 대한 복호화 요청에 실패합니다.

검색 키링을 사용하는 경우 검색 필터를 사용하여 복호화에 사용되는 KMS 키를 지정된 AWS 계정 및 파티션의 키로 제한하는 것이 좋습니다. 검색 필터는 AWS Encryption SDK버전 1.7.x 이상에서 지원됩니다.

예를 들어, 다음 코드는 검색 필터를 사용하여 AWS KMS 리전 검색 키링을 생성합니다. 이 키링은 미국 서부(오레곤) 리전(us-west-2)의 계정 111122223333에서를 KMS 키 AWS Encryption SDK 로 제한합니다.

C

작동 예제에서 이 키링과 create_kms_client 메서드를 보려면 kms_discovery.cpp를 참조하세요.

std::shared_ptr<KmsKeyring::DiscoveryFilter> discovery_filter(
    KmsKeyring::DiscoveryFilter::Builder("aws")
        .AddAccount("111122223333")
        .Build());

struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
       .WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery(discovery_filter));
C# / .NET

AWS Encryption SDK for .NET에는 전용 리전 검색 키링이 없습니다. 단, 여러 기술을 사용하여 복호화할 때 사용되는 KMS 키를 특정 리전으로 제한할 수 있습니다.

검색 키링에서 리전을 제한하는 가장 효율적인 방법은 단일 리전 키만 사용하여 데이터를 암호화한 경우에도 다중 리전 인식 검색 키링을 사용하는 것입니다. 단일 리전 키가 발견되면 다중 리전 인식 키링은 다중 리전 기능을 사용하지 않습니다.

CreateAwsKmsMrkDiscoveryKeyring() 메서드에서 반환된 키링은 AWS KMS를 호출하기 전에 리전별로 KMS 키를 필터링합니다. 암호화된 데이터 키가 CreateAwsKmsMrkDiscoveryKeyringInput 객체의 Region 파라미터로 지정된 리전의 KMS 키로 암호화된 AWS KMS 경우에만에 복호화 요청을 보냅니다.

다음 예제에서는 AWS Encryption SDK for .NET 4.x 버전을 사용합니다.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

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

// Create the discovery filter
var filter = DiscoveryFilter = new DiscoveryFilter
{
    AccountIds = account,
    Partition = "aws"
};
                                
var regionalDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    Region = RegionEndpoint.USWest2,
    DiscoveryFilter = filter
};                                

var kmsRegionalDiscoveryKeyring = materialProviders.CreateAwsKmsMrkDiscoveryKeyring(regionalDiscoveryKeyringInput);

AWS KMS 클라이언트(AmazonKeyManagementServiceClient)의 인스턴스에 리전을 지정 AWS 리전 하여 KMS 키를 특정 로 제한할 수도 있습니다. 단, 이 구성은 multi-Region-aware 검색 키링을 사용하는 것보다 효율성이 떨어지고 비용이 더 많이 들 수 있습니다. 호출하기 전에 리전별로 KMS 키를 필터링하는 대신 AWS KMS for AWS Encryption SDK .NET은 암호화된 각 데이터 키에 AWS KMS 대해 (복호화할 때까지)를 호출하고 AWS KMS 를 사용하여 사용하는 KMS 키를 지정된 리전으로 제한합니다.

다음 예제에서는 AWS Encryption SDK for .NET 4.x 버전을 사용합니다.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };
        
// Create the discovery filter,
// but not a AWS KMS key
var createRegionalDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    DiscoveryFilter = new DiscoveryFilter()
    {
        AccountIds = account,
        Partition = "aws"
    }
};
        
var kmsRegionalDiscoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(createRegionalDiscoveryKeyringInput);
JavaScript Browser

다음 예제에서는 buildClient 함수를 사용하여 기본 커밋 정책인를 지정합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 를 사용하여 암호화된 메시지의 암호화된 데이터 키 수를 제한buildClient할 수도 있습니다. 자세한 내용은 암호화된 데이터 키 제한 단원을 참조하십시오.

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

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser(clientProvider, {
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
JavaScript Node.js

다음 예제에서는 buildClient 함수를 사용하여 기본 커밋 정책인를 지정합니다REQUIRE_ENCRYPT_REQUIRE_DECRYPT. 를 사용하여 암호화된 메시지의 암호화된 데이터 키 수를 제한buildClient할 수도 있습니다. 자세한 내용은 암호화된 데이터 키 제한 단원을 참조하십시오.

이 키링과 limitRegions 함수를 보려면 작업 예제에서 kms_regional_discovery.ts를 참조하세요.

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

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({
    clientProvider,
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
Java
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
        .discoveryFilter(discoveryFilter)
        .regions("us-west-2")
        .build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
Python
# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)

# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS regional discovery keyring
regional_discovery_keyring_input: CreateAwsKmsMrkDiscoveryKeyringInput = \
    CreateAwsKmsMrkDiscoveryKeyringInput(
        kms_client=kms_client,
        region=mrk_replica_decrypt_region,
        discovery_filter=DiscoveryFilter(
            account_ids=[111122223333],
            partition="aws"
        )
)

    regional_discovery_keyring: IKeyring = mat_prov.create_aws_kms_mrk_discovery_keyring(
        input=regional_discovery_keyring_input
    )
Rust
// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;

// Optional: Create an encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create an AWS KMS client
let decrypt_kms_config = aws_sdk_kms::config::Builder::from(&sdk_config)
    .region(Region::new(mrk_replica_decrypt_region.clone()))
    .build();
let decrypt_kms_client = aws_sdk_kms::Client::from_conf(decrypt_kms_config);


// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
    .account_ids(vec![aws_account_id.to_string()])
    .partition("aws".to_string())
    .build()?;

// Create the regional discovery keyring
let discovery_keyring = mpl
    .create_aws_kms_mrk_discovery_keyring()
    .kms_client(decrypt_kms_client)
    .region(mrk_replica_decrypt_region)
    .discovery_filter(discovery_filter)
    .send()
    .await?;
Go
import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
    AccountIds: []string{awsAccountID},
    Partition:  "aws",
}

// Create the regional discovery keyring
awsKmsMrkDiscoveryInput := mpltypes.CreateAwsKmsMrkDiscoveryKeyringInput{
    KmsClient:       kmsClient,
    Region:          alternateRegionMrkKeyRegion,
    DiscoveryFilter: &discoveryFilter,
}
awsKmsMrkDiscoveryKeyring, err := matProv.CreateAwsKmsMrkDiscoveryKeyring(context.Background(), awsKmsMrkDiscoveryInput)
if err != nil {
    panic(err)
}

AWS Encryption SDK for JavaScript 또한는 Node.js 및 브라우저에 대한 excludeRegions 함수를 내보냅니다. 이 함수는 특정 AWS KMS 리전 AWS KMS keys 에서 생략되는 리전 검색 키링을 생성합니다. 다음 예제에서는 미국 동부(버지니아 북부)(us-east-1)를 AWS 리전 제외한 모든 AWS KMS keys 의 계정 111122223333에서를 사용할 수 있는 AWS KMS 리전 검색 키링을 생성합니다.

에는 유사한 메서 AWS Encryption SDK for C 드가 없지만 사용자 지정 ClientSupplier를 생성하여 구현할 수 있습니다.

이 예는 Node.js에 대한 코드를 보여줍니다.

const discovery = true
const clientProvider = excludeRegions(['us-east-1'], getKmsClient)
const keyring = new KmsKeyringNode({
    clientProvider,
    discovery,
    discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})