Raw RSA 키링

에서 Raw RSA 키링을 생성하려면를 AWS Encryption SDK for C사용합니다aws_cryptosdk_raw_rsa_keyring_new.

에서 Raw RSA 키링을 구성할 때는 경로 또는 파일 이름이 아닌 null로 종료된 C-문자열로 각 키를 포함하는 PEM 파일의 내용을 제공해야 AWS Encryption SDK for C합니다. 전체 예제를 보려면 raw_rsa_keyring.c를 참조하세요.

struct aws_allocator *alloc = aws_default_allocator();

AWS_STATIC_STRING_FROM_LITERAL(key_namespace, "HSM_01");
AWS_STATIC_STRING_FROM_LITERAL(key_name, "RSA_2048_06");

struct aws_cryptosdk_keyring *rawRsaKeyring = aws_cryptosdk_raw_rsa_keyring_new(
    alloc,
    key_namespace,
    key_name,
    private_key_from_pem,
    public_key_from_pem,
    AWS_CRYPTOSDK_RSA_OAEP_SHA256_MGF1);

AWS Encryption SDK for .NET에서 Raw RSA 키링을 인스턴스화하려면 materialProviders.CreateRawRsaKeyring() 메서드를 사용합니다. 전체 예제는 RawRSAKeyringExample.cs를 참조하세요.

다음 예제에서는 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());

var keyNamespace = "HSM_01";
var keyName = "RSA_2048_06";

// Get public and private keys from PEM files
var publicKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePublicKey.pem"));
var privateKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePrivateKey.pem"));

// Create the keyring input
var createRawRsaKeyringInput = new CreateRawRsaKeyringInput
{
    KeyNamespace = keyNamespace,
    KeyName = keyName,
    PaddingScheme = PaddingScheme.OAEP_SHA512_MGF1,
    PublicKey = publicKey,
    PrivateKey = privateKey
};

// Create the keyring
var rawRsaKeyring = materialProviders.CreateRawRsaKeyring(createRawRsaKeyringInput);

브라우저 AWS Encryption SDK for JavaScript 의는 WebCrypto 라이브러리에서 암호화 프리미티브를 가져옵니다. 키링을 구성하기 전에 WebCrypto 백엔드로 원시 키 자료를 가져오는 데 importPublicKey() 또는 importPrivateKey()를 사용해야 합니다. 이렇게 하면 WebCrypto에 대한 모든 호출이 비동기식이어도 키링이 완료됩니다. 가져오기 메서드가 사용하는 객체에는 래핑 알고리즘과 해당 패딩 모드가 포함됩니다.

키 자료를 가져온 후 RawRsaKeyringWebCrypto() 메서드를 사용하여 키링을 인스턴스화하세요. JavaScript에서 Raw RSA 키링을 구성하면 다른 언어 구현과 호환되지 않을 수 있습니다.

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

전체 예제는 rsa_simple.ts(JavaScript 브라우저)를 참조하세요.

import {
  RsaImportableKey,
  RawRsaKeyringWebCrypto,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-browser'

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

const privateKey = await RawRsaKeyringWebCrypto.importPrivateKey(
  privateRsaJwKKey
)

const publicKey = await RawRsaKeyringWebCrypto.importPublicKey(
  publicRsaJwKKey
)

const keyNamespace = 'HSM_01'
const keyName = 'RSA_2048_06'

const keyring = new RawRsaKeyringWebCrypto({
  keyName,
  keyNamespace,
  publicKey,
  privateKey,
})             

Node.js AWS Encryption SDK for JavaScript 용에서 Raw RSA 키링을 인스턴스화하려면 RawRsaKeyringNode 클래스의 새 인스턴스를 생성합니다. wrapKey 파라미터는 퍼블릭 키를 보유합니다. unwrapKey파라미터는 프라이빗 키를 보유합니다. 기본 패딩 모드를 지정할 수는 있지만 RawRsaKeyringNode 생성자가 기본 패딩 모드를 자동으로 계산합니다.

JavaScript에서 Raw RSA 키링을 구성하면 다른 언어 구현과 호환되지 않을 수 있습니다.

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

전체 예제를 보려면 rsa_simple.ts(JavaScript Node.js)를 참조하세요.

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

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

const keyNamespace = 'HSM_01'
const keyName = 'RSA_2048_06'

const keyring = new RawRsaKeyringNode({ keyName, keyNamespace, rsaPublicKey, rsaPrivateKey})

final CreateRawRsaKeyringInput keyringInput = CreateRawRsaKeyringInput.builder()
        .keyName("RSA_2048_06")
        .keyNamespace("HSM_01")
        .paddingScheme(PaddingScheme.OAEP_SHA256_MGF1)
        .publicKey(RSAPublicKey)
        .privateKey(RSAPrivateKey)
        .build();
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
IKeyring rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);

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

# Define the key namespace and key name
key_name_space = "HSM_01"
key_name = "RSA_2048_06"

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

# Create Raw RSA keyring
keyring_input: CreateRawRsaKeyringInput = CreateRawRsaKeyringInput(
    key_namespace=key_name_space,
    key_name=key_name,
    padding_scheme=PaddingScheme.OAEP_SHA256_MGF1,
    public_key=RSAPublicKey,
    private_key=RSAPrivateKey
)

raw_rsa_keyring: IKeyring = mat_prov.create_raw_rsa_keyring(
    input=keyring_input
)

// Instantiate the AWS Encryption SDK client
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()),
]);

// Define the key namespace and key name
let key_namespace: &str = "HSM_01";
let key_name: &str = "RSA_2048_06";
                    
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create Raw RSA keyring
let raw_rsa_keyring = mpl
    .create_raw_rsa_keyring()
    .key_name(key_name)
    .key_namespace(key_namespace)
    .padding_scheme(PaddingScheme::OaepSha256Mgf1)
    .public_key(aws_smithy_types::Blob::new(RSAPublicKey))
    .private_key(aws_smithy_types::Blob::new(RSAPrivateKey))
    .send()
    .await?;

// Instantiate the material providers library
matProv, err := awscryptographymaterialproviderssmithygenerated.NewClient(awscryptographymaterialproviderssmithygeneratedtypes.MaterialProvidersConfig{})
                
// Create Raw RSA keyring
rsaKeyRingInput := awscryptographymaterialproviderssmithygeneratedtypes.CreateRawRsaKeyringInput{
	KeyName:       "rsa",
	KeyNamespace:  "rsa-keyring",
	PaddingScheme: awscryptographymaterialproviderssmithygeneratedtypes.PaddingSchemePkcs1,
	PublicKey:     pem.EncodeToMemory(publicKeyBlock),
	PrivateKey:    pem.EncodeToMemory(privateKeyBlock),
}

rsaKeyring, err := matProv.CreateRawRsaKeyring(context.Background(), rsaKeyRingInput)

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",
}

// Define the key namespace and key name
var keyNamespace = "HSM_01"
var keyName = "RSA_2048_06"

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

// Create Raw RSA keyring
rsaKeyRingInput := mpltypes.CreateRawRsaKeyringInput{
    KeyName:       keyName,
    KeyNamespace:  keyNamespace,
    PaddingScheme: mpltypes.PaddingSchemeOaepSha512Mgf1,
    PublicKey:     (RSAPublicKey),
    PrivateKey:    (RSAPrivateKey),
}
rsaKeyring, err := matProv.CreateRawRsaKeyring(context.Background(), rsaKeyRingInput)
if err != nil {
    panic(err)
}