Wrapping di una chiave utilizzando OpenSSL su Linux

Questo argomento mostra come eseguire il wrapping manuale di una chiave prima di importarla in Cloud KMS. Devi seguire le istruzioni riportate in questo argomento solo se non vuoi utilizzare l'interfaccia a riga di comando di Google Cloud per eseguire automaticamente il wrapping della chiave prima di importarla. Per una panoramica delle differenze, consulta la sezione Come funziona l'importazione delle chiavi.

Puoi completare i passaggi in questo argomento in 5-10 minuti, esclusi i passaggi Prima di iniziare.

Prima di iniziare

Per poter aggregare una chiave devi completare i seguenti prerequisiti.

  1. Crea un keyring e una chiave di destinazione e crea un job di importazione.
  2. Verifica che la chiave sia disponibile localmente e formattata correttamente per l'importazione in Cloud KMS.
  3. Fare patch e ricompilare OpenSSL

Recupera la chiave di wrapping

Questa sezione mostra come recuperare la chiave di wrapping dal job di importazione che hai creato in Prima di iniziare. Si consiglia di utilizzare Google Cloud Console.

console

  1. Vai alla pagina Gestione delle chiavi in Google Cloud Console.

    Vai alla pagina Gestione delle chiavi

  2. Fai clic sul nome del keyring che contiene il job di importazione.

  3. Fai clic sulla scheda Importa job nella parte superiore della pagina.

  4. Fai clic su Altro , quindi su Scarica chiave di wrapping nel menu popup.

gcloud

Per verificare che il job di importazione sia attivo, esegui il comando gcloud kms import-jobs describe:

gcloud kms import-jobs describe import-job \
  --location location \
  --keyring key-ring-name \
  --format="value(state)"
state: ACTIVE

Esegui questo comando per salvare la chiave pubblica dal job di importazione in ${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

  1. Chiama il metodo [ImportJob.get][11].

  2. Recupera la chiave pubblica tramite il campo [publicKey][13] della risposta di ImportJob.get. Questo valore è di tipo [WrappingPublicKey][14]. Il campo [pem][21] del tipo [WrappingPublicKey][22] è la chiave pubblica codificata nel formato PEM (Privacy Enhanced Mail).

Per ulteriori informazioni sul formato codificato PEM, consulta la sezione RFC 7468, in particolare le sezioni Considerazioni generali e Codifica testuale della scheda Informazioni pubbliche del soggetto.

Imposta le variabili di ambiente

I comandi OpenSSL richiedono diversi percorsi file come valori di input. Definisci le variabili di ambiente per i percorsi file per semplificare l'esecuzione dei comandi.

  1. Imposta la variabile OpenSSL_V110 sul percorso dello script openssl.sh. Se hai seguito esattamente le istruzioni per l'applicazione di patch e la compilazione di OpenSSL, puoi utilizzare questo comando senza modificare il valore della variabile.

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

  2. Imposta la variabile PUB_WRAPPING_KEY sul percorso completo della chiave di wrapping che hai scaricato dal job di importazione. La chiave di wrapping termina tra .pem.

    I seguenti comandi impostano la variabile PUB_WRAPPING_KEY su ${HOME}/wrapping-key.pem.

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

  3. Imposta la variabile TARGET_KEY sul percorso completo della chiave senza wrapper.

    • Per le chiavi simmetriche, imposta TARGET_KEY sul percorso del file .bin.
    • Per le chiavi asimmetriche, imposta TARGET_KEY sul percorso del file .der.
    TARGET_KEY=/path/to/key
    

  4. Imposta la variabile BASE_DIR su una directory in cui è possibile scrivere file temporanei e, se necessario, crea la directory. Questa directory deve essere accessibile solo dal tuo utente attuale. Non utilizzare un carattere finale / alla fine del nome della directory.

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

  5. Definisci le variabili di ambiente per i tre file intermedi.

    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. Imposta la variabile RSA_AES_WRAPPED_KEY sul percorso completo per scrivere la chiave di destinazione aggregata che andrai a importare e assicurati di avere l'accesso per scrivere nella directory.

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

  7. Verifica che tutte le variabili di ambiente siano impostate correttamente utilizzando i seguenti comandi:

    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}
    

Dopo aver impostato le variabili correttamente, puoi aggregare la chiave.

Aggrega la chiave

  1. Esegui questo comando per generare una chiave AES casuale temporanea di 32 byte e salvarla nel percorso indicato da ${TEMP_AES_KEY}.

    "${OPENSSL_V110}" rand -out "${TEMP_AES_KEY}" 32
    

  2. Aggrega la chiave AES temporanea con la chiave pubblica di wrapping utilizzando l'algoritmo CKM_RSA_PKCS_OAEP.

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

  3. Aggrega la chiave di destinazione con la chiave AES temporanea utilizzando l'algoritmo CKM_AES_KEY_WRAP_PAD. Sostituisci target-key-file con il nome del file .bin o pub per la chiave.

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

    Il flag -iv A65959A6 imposta A65959A6 come valore iniziale alternativo. Questa operazione è richiesta dalla specifica RFC 5649.

    Ora hai eseguito il wrapping di due chiavi:

    • ${TEMP_AES_KEY_WRAPPED} è la chiave AES temporanea che hai creato nel sistema locale, aggregata con la chiave pubblica del job di importazione.
    • ${TARGET_KEY_WRAPPED} è la chiave di destinazione che importerai, aggregata con la chiave AES temporanea che hai generato.
  4. Concatena le due chiavi inserite nel codice e scrivi l'output in un singolo file. Non modificare l'ordine delle due chiavi nel comando sotto; la chiave temporanea deve precedere la chiave di destinazione.

    cat "${TEMP_AES_KEY_WRAPPED}" "${TARGET_KEY_WRAPPED}" > "${RSA_AES_WRAPPED_KEY}"
    
  5. Elimina i file intermedi che non sono più necessari.

    rm ${BASE_DIR}/*
    

La chiave aggregata è presente nella variabile di località ${RSA_AES_WRAPPED_KEY} e puoi fare una richiesta di importazione della tua chiave.