Cette rubrique explique comment encapsuler manuellement une clé avant d'importer la clé dans Cloud KMS. Ne suivez les instructions de cette rubrique que si vous ne souhaitez pas utiliser la CLI Google Cloud 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.
- Créez une clé et un trousseau de clés de ciblage, puis créez une tâche d'importation.
- Vérifiez que votre clé est disponible localement et correctement formatée pour l'importation dans Cloud KMS.
- 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. Il est recommandé d'utiliser Google Cloud Console.
Console
Accédez à la page Gestion des clés dans la console.
Cliquez sur le nom du trousseau de clés contenant la tâche d'importation.
Cliquez sur l'onglet Tâches d'importation situé en haut de la page.
Dans le menu contextuel, cliquez sur Plus more_vert, 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
API
Appelez la méthode [
ImportJob.get
][11].Récupérez la clé publique via le champ [
publicKey
][13] de la réponse fournie parImportJob.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.
Définissez la variable
OpenSSL_V110
sur le chemin d'accès de votre scriptopenssl.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"
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"
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
- Pour les clés symétriques, définissez
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}
Si vous encapsulez des annonces aux formats RSA et AES, définissez les variables d'environnement des 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"
Définissez la variable
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.WRAPPED_KEY=/path/to/wrapped-target-key.bin mkdir -m u+wx -p $(dirname ${WRAPPED_KEY})
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 "WRAPPED_KEY: " ${WRAPPED_KEY}
Lorsque les variables sont définies correctement, vous pouvez encapsuler la clé.
Encapsuler la clé avec RSA
Encapsulez la clé cible 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 "${TARGET_KEY}" \ -out "${WRAPPED_KEY}" \ -oaep
Encapsuler la clé avec RSA et AES
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
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
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
oupub
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.
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.
cat "${TEMP_AES_KEY_WRAPPED}" "${TARGET_KEY_WRAPPED}" > "${WRAPPED_KEY}"
Supprimez les fichiers intermédiaires dont vous n'avez plus besoin.
rm ${BASE_DIR}/*
Votre clé encapsulée se trouve dans la variable d'emplacement ${WRAPPED_KEY}
, et vous pouvez demander à importer votre clé.