Encapsuler une clé à l'aide d'OpenSSL sur Linux

Cette rubrique explique comment encapsuler manuellement une clé avant d'importer la clé dans Cloud KMS. Toi suivez les instructions de cette rubrique si vous ne souhaitez pas utiliser Google Cloud CLI pour encapsuler automatiquement la clé avant de l'importer. Pour une un aperçu des différences, consultez Fonctionnement de l'importation de clés

Vous pouvez suivre la procédure décrite dans cette rubrique en 5 à 10 minutes, sans compter les étapes Avant de commencer.

Avant de commencer

Avant de pouvoir encapsuler une clé, vous devez remplir les conditions préalables suivantes.

1. Créez une clé et un trousseau de clés de ciblage, puis créez une tâche d'importation.
2. Vérifiez que votre clé est disponible localement et correctement formatée pour l'importation dans Cloud KMS.
3. Appliquez un correctif et recompilez OpenSSL

Récupérer la clé d'encapsulation

Cette section explique comment extraire la clé d'encapsulation de la tâche d'importation que vous avez créée dans la section Avant de commencer. Nous vous recommandons d'utiliser la console Google Cloud.

Console

1. Accédez à la page Gestion des clés dans la console Google Cloud.

   Accéder à la page Gestion des clés

2. Cliquez sur le nom du trousseau de clés contenant la tâche d'importation.

3. Cliquez sur l'onglet Tâches d'importation situé en haut de la page.

4. Dans le menu contextuel, cliquez sur Plus , puis sur Télécharger la clé d'encapsulation.

CLI gcloud

Pour vérifier que la tâche d'importation est active, exécutez la commande gcloud kms import-jobs describe :

gcloud kms import-jobs describe IMPORT_JOB \
  --location LOCATION \
  --keyring KEY_RING \
  --format="value(state)"

state: ACTIVE

Exécutez la commande suivante pour enregistrer la clé publique depuis la tâche d'importation dans ${HOME}/wrapping-key.pem.

gcloud kms import-jobs describe \
  --location=LOCATION \
  --keyring=KEY_RING \
  --format="value(publicKey.pem)" \
  IMPORT_JOB > ${HOME}/wrapping-key.pem

Remarque : Vous n'avez besoin de télécharger une clé publique qu'une seule fois et vous pouvez l'utiliser jusqu'à ce que la tâche d'importation expire.

API

1. Appelez la méthode ImportJob.get.

2. Récupérez la clé publique via le champ publicKey de la réponse fournie par ImportJob.get. Cette valeur est de type WrappingPublicKey. Le champ pem du type WrappingPublicKey est la valeur encodée au format PEM (Privacy Enhanced Mail).

Remarque : N'oubliez pas de vérifier que l'algorithme et la longueur de votre clé sont compatibles. Les algorithmes autorisés pour une clé varient selon que la clé est utilisée pour le chiffrement symétrique, le chiffrement asymétrique ou la signature asymétrique, et qu'elle est stockée dans un logiciel ou un module de sécurité matérielle (HSM).

Pour en savoir plus sur le format encodé au format PEM, consultez la page RFC 7468, en particulier les Considérations générales et Encodage textuel des informations sur la clé publique de l'objet .

Configurer des variables d'environnement

Les commandes OpenSSL nécessitent plusieurs chemins de fichiers en tant que valeurs d'entrée. Définissez des variables d'environnement pour les chemins de fichiers afin de faciliter l'exécution des commandes. Assurez-vous d'avoir accès en écriture aux répertoires que vous définissez ci-dessous.

Remarque  Si vous le souhaitez, vous pouvez enregistrer toutes ces commandes dans un script shell et exécuter le script pour définir les variables simultanément. Vous devrez peut-être ajuster certaines valeurs pour chaque clé à encapsuler.

1. Définissez la variable PUB_WRAPPING_KEY sur le chemin d'accès complet à la clé d'encapsulation que vous avez téléchargée depuis la tâche d'importation. La clé d'encapsulation se termine par .pem.

   PUB_WRAPPING_KEY="WRAPPING_KEY_PATH"
   

2. Définissez la variable TARGET_KEY sur le chemin d'accès complet à la clé non encapsulée (cible).

   TARGET_KEY=TARGET_KEY_PATH
   

   Remplacez TARGET_KEY_PATH par le chemin d'accès au fichier .bin pour les clés symétriques ou par le chemin d'accès au fichier .der pour les clés asymétriques.

3. En cas d'encapsulation avec RSA-AES, définissez la variable TEMP_AES_KEY sur le chemin d'accès complet à la clé AES temporaire.

   TEMP_AES_KEY=TEMP_AES_KEY_PATH
   

4. Définissez la variable WRAPPED_KEY sur le chemin d'accès complet où vous vous voulez enregistrer la clé cible encapsulée prête à être utilisée l'importation.

   WRAPPED_KEY=WRAPPED_KEY_PATH
   

5. Vérifiez que toutes les variables d'environnement sont correctement définies à l'aide des commandes suivantes :

   echo "PUB_WRAPPING_KEY: " ${PUB_WRAPPING_KEY}; \
   echo "TARGET_KEY: " ${TARGET_KEY}; \
   echo "TEMP_AES_KEY: " ${TEMP_AES_KEY}; \
   echo "WRAPPED_KEY: " ${WRAPPED_KEY}
   

Lorsque les variables sont correctement définies, vous êtes prêt à encapsuler la clé. Il y a l'une des deux approches décrites ci-dessous: avec ARR uniquement ou avec RSA-AES

Encapsuler la clé

Encapsuler la clé avec RSA

Dans cette approche, la clé cible est encapsulée dans un bloc RSA. La taille de la clé cible est donc limitée. Par exemple, vous ne pouvez pas utiliser cette méthode pour encapsuler une autre ARR . Les méthodes d'importation compatibles sont rsa-oaep-3072-sha256 et rsa-oaep-4096-sha256

• Encapsulez la clé cible avec la clé publique d'encapsulation à l'aide de la méthode l'algorithme CKM_RSA_PKCS_OAEP:

  openssl pkeyutl \
    -encrypt \
    -pubin \
    -inkey ${PUB_WRAPPING_KEY} \
    -in ${TARGET_KEY} \
    -out ${WRAPPED_KEY} \
    -pkeyopt rsa_padding_mode:oaep \
    -pkeyopt rsa_oaep_md:sha256 \
    -pkeyopt rsa_mgf1_md:sha256
  

Encapsuler la clé avec RSA-AES

Dans cette approche, la clé cible est encapsulée avec une clé AES temporaire. La temporaire AES est ensuite encapsulée par la clé RSA. Ces deux clés encapsulées concaténés et importés. Étant donné que la clé cible est encapsulée à l'aide d'AES plutôt que de RSA, cette approche peut être utilisée pour encapsuler de grandes clés. L'importation compatible méthodes sont rsa-oaep-3072-sha1-aes-256, rsa-oaep-4096-sha1-aes-256, rsa-oaep-3072-sha256-aes-256 et rsa-oaep-4096-sha256-aes-256.

1. Générez une clé AES aléatoire temporaire de 32 octets, puis enregistrez-la dans l'établissement identifié par ${TEMP_AES_KEY}:

   openssl rand -out "${TEMP_AES_KEY}" 32
   

2. Encapsulez la clé AES temporaire avec la clé publique d'encapsulation à l'aide de l'algorithme CKM_RSA_PKCS_OAEP. Si la méthode d'importation est rsa-oaep-3072-sha1-aes-256 ou rsa-oaep-4096-sha1-aes-256, utilisez sha1 pour rsa_oaep_md et rsa_mgf1_md. Utiliser sha256 pour rsa-oaep-3072-sha256-aes-256 et rsa-oaep-4096-sha256-aes-256.

   openssl pkeyutl \
     -encrypt \
     -pubin \
     -inkey ${PUB_WRAPPING_KEY} \
     -in ${TEMP_AES_KEY} \
     -out ${WRAPPED_KEY} \
     -pkeyopt rsa_padding_mode:oaep \
     -pkeyopt rsa_oaep_md:{sha1|sha256} \
     -pkeyopt rsa_mgf1_md:{sha1|sha256}
   

3. Définissez la variable OpenSSL_V110 sur le chemin d'accès de votre script openssl.sh. Si vous avez bien suivi les instructions pour appliquer un correctif et recompiler OpenSSL, vous pouvez utiliser cette commande sans modifier la valeur de la variable.

   OPENSSL_V110="${HOME}/local/bin/openssl.sh"
   

4. Encapsulez la clé cible avec la clé AES temporaire à l'aide de la méthode l'algorithme CKM_AES_KEY_WRAP_PAD, puis l'ajouter à WRAPPED_KEY.

   "${OPENSSL_V110}" enc \
     -id-aes256-wrap-pad \
     -iv A65959A6 \
     -K $( hexdump -v -e '/1 "%02x"' < "${TEMP_AES_KEY}" ) \
     -in "${TARGET_KEY}" >> "${WRAPPED_KEY}"
   

   L'option -iv A65959A6 définit A65959A6 en tant que valeur initiale alternative. Ce est requis par la norme RFC 5649 spécifique.

Étape suivante

• La clé encapsulée enregistrée dans WRAPPED_KEY est maintenant prête à être importée. Pour importer la clé, suivez les instructions de la section Importer un fichier clé encapsulée manuellement.