Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Porte-clés RSA bruts 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](https://github.com/aws/aws-encryption-sdk-c/blob/master/include/aws/cryptosdk/cipher.h). 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.](use-multi-keyring.md) 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 [JceMasterKey[RawMasterKey](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.raw.html#aws_encryption_sdk.key_providers.raw.RawMasterKey)](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)in 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 en savoir plus, consultez [Compatibilité du porte-clés](choose-keyring.md#keyring-compatibility). **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* et versions ultérieures 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](https://github.com/aws/aws-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 trousseau de clés RSA brut. L'opération AWS KMS Decrypt ne peut pas déchiffrer le [message chiffré](concepts.md#message) 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é](javascript-compatibility.md) 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é](concepts.md#message) 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` et`RawMasterKey`. 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](https://tools.ietf.org/html/rfc8017#section-7.1), en particulier OAEP avec SHA-256 et avec rembourrage SHA-256. MGF1 Le mode de [PKCS1](https://tools.ietf.org/html/rfc8017#section-7.2)rembourrage n'est pris en charge que pour des raisons de rétrocompatibilité. + OAEP avec SHA-1 et avec 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\$1rsa\$1keyring.c](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/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\$1 / .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](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/RawRSAKeyringExample.cs). L'exemple suivant utilise la version 4. *x* et versions ultérieures 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 [WebCrypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)bibliothèque. Avant de construire le trousseau de clés, vous devez l'utiliser `importPublicKey()` and/or `importPrivateKey()` pour 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](javascript-compatibility.md) avec les implémentations d'autres langages. L'exemple suivant utilise la `buildClient` fonction pour spécifier la [politique d'engagement par défaut](migrate-commitment-policy.md),`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](configure.md#config-limit-keys). Pour un exemple complet, consultez [rsa\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/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](javascript-compatibility.md) avec les implémentations d'autres langages. L'exemple suivant utilise la `buildClient` fonction pour spécifier la [politique d'engagement par défaut](migrate-commitment-policy.md),`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](configure.md#config-limit-keys). Pour un exemple complet, consultez [rsa\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/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](migrate-commitment-policy.md),. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Pour un exemple complet, consultez le [fichier raw\$1rsa\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/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) } ``` ------