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. Vous ne devez suivre les instructions de cette rubrique que si vous ne souhaitez pas utiliser l'outil de ligne de commande gcloud pour encapsuler automatiquement la clé avant de l'importer. Pour obtenir un aperçu des différences, consultez la page 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 Google Cloud Console.

Console

1. Accédez à la page Clés de chiffrement dans Cloud Console.

   Accéder à la page Clés de chiffrement

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.

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-name \
  --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=keyring \
  --format="value(publicKey.pem)" \
  import-job-name > ${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][11].

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

Pour plus d'informations sur l'encodage au format PEM, consultez la section RFC 7468, en particulier les sections Remarques générales et Encodage textuel des informations de clé publique du sujet.

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.

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

2. 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.

   Les commandes suivantes définissent la variable PUB_WRAPPING_KEY sur ${HOME}/wrapping-key.pem.

   PUB_WRAPPING_KEY="${HOME}/wrapping-key.pem"
   

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

   • Pour les clés symétriques, définissez TARGET_KEY sur le chemin d'accès au fichier .bin.
   • Pour les clés asymétriques, définissez TARGET_KEY sur le chemin d'accès au fichier .der.

   TARGET_KEY=/path/to/key
   

4. Définissez la variable BASE_DIR sur un répertoire dans lequel les fichiers temporaires peuvent être écrits, et créez le répertoire si nécessaire. Ce répertoire ne doit être accessible que par votre utilisateur actuel. N'utilisez pas de caractère / à la fin du nom du répertoire.

   BASE_DIR="${HOME}/wrap_tmp"
   mkdir -m 700 -p ${BASE_DIR}
   

5. Définissez des variables d'environnement pour les trois fichiers intermédiaires.

   TEMP_AES_KEY="${BASE_DIR}/temp_aes_key.bin"
   TEMP_AES_KEY_WRAPPED="${BASE_DIR}/temp_aes_key_wrapped.bin"
   TARGET_KEY_WRAPPED="${BASE_DIR}/target_key_wrapped.bin"
   

6. Définissez la variable RSA_AES_WRAPPED_KEY sur le chemin complet pour écrire la clé cible encapsulée que vous finirez par importer, et assurez-vous que vous avez accès au répertoire en écriture.

   RSA_AES_WRAPPED_KEY=/path/to/wrapped-target-key.bin
   mkdir -m u+wx -p $(dirname ${RSA_AES_WRAPPED_KEY})
   

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

   echo "OPENSSL_V110: " ${OPENSSL_V110}; \
   echo "PUB_WRAPPING_KEY: " ${PUB_WRAPPING_KEY}; \
   echo "TARGET_KEY: " ${TARGET_KEY}; \
   echo "BASE_DIR: " ${BASE_DIR}; \
   echo "TEMP_AES_KEY: " ${TEMP_AES_KEY}; \
   echo "TEMP_AES_KEY_WRAPPED: " ${TEMP_AES_KEY_WRAPPED}; \
   echo "TARGET_KEY_WRAPPED: " ${TARGET_KEY_WRAPPED}; \
   echo "RSA_AES_WRAPPED_KEY: " ${RSA_AES_WRAPPED_KEY}
   

Lorsque les variables sont correctement définies, vous êtes prêt à encapsuler la clé.

Encapsuler la clé

1. Exécutez la commande suivante pour générer une clé AES aléatoire temporaire d'une longueur de 32 octets et pour l'enregistrer à l'emplacement désigné par ${TEMP_AES_KEY}.

   "${OPENSSL_V110}" 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.

   "${OPENSSL_V110}" rsautl \
      -encrypt \
      -pubin \
      -inkey "${PUB_WRAPPING_KEY}" \
      -in "${TEMP_AES_KEY}" \
      -out "${TEMP_AES_KEY_WRAPPED}" \
      -oaep
   

3. Encapsulez la clé cible avec la clé AES temporaire à l'aide de l'algorithme CKM_AES_KEY_WRAP_PAD. Remplacez target-key-file par le nom du fichier .bin ou pub pour la clé.

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

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

   Vous avez maintenant encapsulé deux clés :

   • ${TEMP_AES_KEY_WRAPPED} est la clé AES temporaire que vous avez créée sur le système local, encapsulée avec la clé publique de la tâche d'importation.
   • ${TARGET_KEY_WRAPPED} est la clé cible que vous allez importer, encapsulée avec la clé AES temporaire que vous avez générée.

4. Concaténez les deux clés encapsulées, puis écrivez le résultat dans un fichier unique. Ne modifiez pas l'ordre des deux clés dans la commande ci-dessous. La clé temporaire doit précéder la clé cible.

   Avertissement : Cette commande écrase tout fichier existant pointé par la variable ${RSA_AES_WRAPPED_KEY}.

   cat "${TEMP_AES_KEY_WRAPPED}" "${TARGET_KEY_WRAPPED}" > "${RSA_AES_WRAPPED_KEY}"
   

5. Supprimez les fichiers intermédiaires dont vous n'avez plus besoin.

   rm ${BASE_DIR}/*
   

Votre clé encapsulée existe à la variable de position ${RSA_AES_WRAPPED_KEY}, et vous pouvez envoyer une requête pour importer votre clé.