Porte-clés RSA bruts

PDFRSS

Le trousseau RSA brut effectue le chiffrement et le déchiffrement asymétriques des clés de données dans la mémoire locale à l'aide des clés publiques et privées RSA que vous fournissez. Vous devez générer, stocker et protéger la clé privée, de préférence dans un module de sécurité matériel (HSM) ou un système de gestion des clés. La fonction de chiffrement chiffre la clé de données sous la clé publique RSA. La fonction de déchiffrement déchiffre la clé de données à l'aide de la clé privée. Vous pouvez choisir parmi plusieurs modes de remplissage RSA.

Un porte-clés RSA brut qui chiffre et déchiffre doit inclure une clé publique asymétrique et une clé privée en paire. Toutefois, vous pouvez chiffrer des données à l'aide d'un jeu de clés RSA brut contenant uniquement une clé publique, et vous pouvez déchiffrer des données à l'aide d'un jeu de clés RSA brut contenant uniquement une clé privée. Vous pouvez inclure n'importe quel trousseau RSA brut dans un trousseau à clés multiples. Si vous configurez un jeu de clés RSA brut avec une clé publique et une clé privée, assurez-vous qu'elles font partie de la même paire de clés. Certaines implémentations linguistiques du AWS Encryption SDK ne permettent pas de créer un jeu de clés RSA brut avec des clés provenant de paires différentes. D'autres comptent sur vous pour vérifier que vos clés proviennent de la même paire de clés.

Le jeu de clés RSA brut est équivalent et interagit avec le in Kit SDK de chiffrement AWS pour Java et le JceMasterKeyRawMasterKeyin Kit SDK de chiffrement AWS pour Python lorsqu'il est utilisé avec des clés de chiffrement asymétriques RSA. Vous pouvez chiffrer des données avec une certaine implémentation et déchiffrer les données avec n'importe quelle autre implémentation à l'aide de la même clé d'encapsulage. Pour plus de détails, consultez Compatibilité du porte-clés.

Note

Le porte-clés RSA brut ne prend pas en charge les clés KMS asymétriques. Si vous souhaitez utiliser des clés RSA KMS asymétriques, les langages de programmation suivants prennent en charge les trousseaux de AWS KMS clés utilisant le RSA asymétrique : AWS KMS keys

• Version 3. x du Kit SDK de chiffrement AWS pour Java

• La version 4. x du AWS Encryption SDK pour .NET

• La version 4. x du Kit SDK de chiffrement AWS pour Python, lorsqu'il est utilisé avec la dépendance optionnelle MPL (Cryptographic Material Providers Library).

• La version 0.1. x ou version ultérieure du AWS Encryption SDK for Go

Si vous chiffrez des données à l'aide d'un jeu de clés RSA brut qui inclut la clé publique d'une clé RSA KMS, ni le AWS Encryption SDK NI AWS KMS ne peuvent les déchiffrer. Vous ne pouvez pas exporter la clé privée d'une clé KMS AWS KMS asymétrique vers un jeu de clés RSA brut. L'opération AWS KMS Decrypt ne peut pas déchiffrer le message chiffré renvoyé. AWS Encryption SDK

Lorsque vous créez un jeu de clés RSA brut dans le Kit SDK de chiffrement AWS pour C, veillez à fournir le contenu du fichier PEM qui inclut chaque clé sous forme de chaîne C terminée par un caractère nul, et non sous forme de chemin ou de nom de fichier. Lors de la construction d'un porte-clés RSA brut en JavaScript, prenez en compte la possibilité d'incompatibilité avec d'autres implémentations de langage.

Espaces de noms et noms

Pour identifier le contenu clé RSA d'un trousseau de clés, le trousseau RSA brut utilise un espace de noms de clé et un nom de clé que vous fournissez. Ces valeurs ne sont pas secrètes. Ils apparaissent en texte brut dans l'en-tête du message chiffré renvoyé par l'opération de chiffrement. Nous vous recommandons d'utiliser l'espace de noms de clé et le nom de clé qui identifient la paire de clés RSA (ou sa clé privée) dans votre HSM ou votre système de gestion des clés.

Note

L'espace de noms et le nom de clé sont équivalents aux champs Provider ID (ou Provider) et Key ID dans le JceMasterKey etRawMasterKey.

Kit SDK de chiffrement AWS pour C réserve la valeur de l'espace de noms des aws-kms clés pour les clés KMS. Ne l'utilisez pas dans un trousseau de clés RAW AES ou dans un trousseau de clés RSA brut avec le. Kit SDK de chiffrement AWS pour C

Si vous créez différents trousseaux de clés pour chiffrer et déchiffrer un message donné, l'espace de noms et les valeurs des noms sont essentiels. Si l'espace de noms de clé et le nom de clé dans le jeu de clés de déchiffrement ne correspondent pas exactement, en faisant la distinction majuscules/minuscules, entre l'espace de noms de clé et le nom de clé dans le jeu de clés de chiffrement, le jeu de clés de déchiffrement n'est pas utilisé, même si les clés proviennent de la même paire de clés.

L'espace de noms de clé et le nom de clé du contenu clé des trousseaux de clés de chiffrement et de déchiffrement doivent être identiques, que le jeu de clés contienne la clé publique RSA, la clé privée RSA ou les deux clés de la paire de clés. Supposons, par exemple, que vous cryptiez des données à l'aide d'un jeu de clés RSA brut pour une clé publique RSA avec un espace de noms HSM_01 de clé et un nom de clé. RSA_2048_06 Pour déchiffrer ces données, créez un jeu de clés RSA brut avec la clé privée (ou paire de clés), ainsi que le même espace de noms et le même nom de clé.

Mode de rembourrage

Vous devez spécifier un mode de remplissage pour les porte-clés RSA bruts utilisés pour le chiffrement et le déchiffrement, ou utiliser les fonctionnalités de l'implémentation de votre langage qui le spécifient pour vous.

Il AWS Encryption SDK prend en charge les modes de remplissage suivants, sous réserve des contraintes de chaque langue. Nous recommandons un mode de rembourrage OAEP, en particulier OAEP avec SHA-256 et avec rembourrage SHA-256. MGF1 Le mode de PKCS1rembourrage n'est pris en charge que pour des raisons de rétrocompatibilité.

• OAEP avec SHA-1 et rembourrage SHA-1 MGF1

• OAEP avec SHA-256 et avec rembourrage SHA-256 MGF1

• OAEP avec SHA-384 et avec rembourrage SHA-384 MGF1

• OAEP avec SHA-512 et avec rembourrage SHA-512 MGF1

• PKCS1 Rembourrage v1.5

Les exemples suivants montrent comment créer un jeu de clés RSA brut avec les clés publique et privée d'une paire de clés RSA et l'OAEP avec SHA-256 et avec le mode de remplissage SHA-256. MGF1 Les RSAPrivateKey variables RSAPublicKey et représentent le matériel clé que vous fournissez.

C

Pour créer un trousseau de clés RSA brut dans le Kit SDK de chiffrement AWS pour C, utilisez. aws_cryptosdk_raw_rsa_keyring_new

Lorsque vous créez un jeu de clés RSA brut dans le Kit SDK de chiffrement AWS pour C, veillez à fournir le contenu du fichier PEM qui inclut chaque clé sous forme de chaîne C terminée par un caractère nul, et non sous forme de chemin ou de nom de fichier. Pour un exemple complet, consultez 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);

C# / .NET

Pour instancier un jeu de clés RSA brut dans le domaine .NET, AWS Encryption SDK utilisez la méthode. materialProviders.CreateRawRsaKeyring() Pour un exemple complet, voir Raw RSAKeyring Example.cs.

L'exemple suivant utilise la version 4. x du AWS Encryption SDK pour .NET.

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

JavaScript Browser

Le Kit SDK de chiffrement AWS pour JavaScript navigateur obtient ses primitives cryptographiques de la WebCryptobibliothèque. Avant de construire le porte-clés, vous devez utiliser importPublicKey() et/ou importPrivateKey() importer le matériau clé brut dans le WebCrypto backend. Cela garantit que le trousseau de clés est complet même si tous les appels WebCrypto sont asynchrones. L'objet utilisé par les méthodes d'importation inclut l'algorithme d'encapsulage et son mode de remplissage.

Après avoir importé le matériel clé, utilisez la RawRsaKeyringWebCrypto() méthode pour instancier le trousseau de clés. Lorsque vous créez un jeu de clés RSA brut JavaScript, soyez conscient des incompatibilités potentielles avec les implémentations d'autres langages.

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

Pour un exemple complet, consultez rsa_simple.ts (Browser). 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,
})             

JavaScript Node.js

Pour instancier un jeu de clés RSA brut dans Kit SDK de chiffrement AWS pour JavaScript Node.js, créez une nouvelle instance de la classe. RawRsaKeyringNode Le wrapKey paramètre contient la clé publique. Le unwrapKey paramètre contient la clé privée. Le RawRsaKeyringNode constructeur calcule un mode de remplissage par défaut pour vous, bien que vous puissiez spécifier un mode de remplissage préféré.

Lorsque vous créez un trousseau de clés RSA brut JavaScript, soyez conscient des incompatibilités potentielles avec les implémentations d'autres langages.

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

Pour un exemple complet, consultez rsa_simple.ts (Node.js). JavaScript

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})

Java

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

Python

L'exemple suivant instancie le AWS Encryption SDK client avec la politique d'engagement par défaut,. REQUIRE_ENCRYPT_REQUIRE_DECRYPT Pour un exemple complet, consultez le fichier raw_rsa_keyring_example.py dans le Kit SDK de chiffrement AWS pour Python référentiel dans GitHub.

# 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
)

Rust

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

Go

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

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"
)

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