Converti la chiave pem nel formato ssh-rsa

Ho un certificato in der format, da esso con questo comando genero una chiave pubblica:

 openssl x509 -inform der -in ejbcacert.cer -noout -pubkey > pub1key.pub 

Il che risulta in questo:

 -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7vbqajDw4o6gJy8UtmIbkcpnk O3Kwc4qsEnSZp/TR+fQi62F79RHWmwKOtFmwteURgLbj7D/WGuNLGOfa/2vse3G2 eHnHl5CB8ruRX9fBl/KgwCVr2JaEuUm66bBQeP5XeBotdR4cvX38uPYivCDdPjJ1 QWPdspTBKcxeFbccDwIDAQAB -----END PUBLIC KEY----- 

Come posso ottenere una chiave pubblica come questa? O dal certificato o da questa chiave pubblica?

 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQC7vbqajDw4o6gJy8UtmIbkcpnkO3Kwc4qsEnSZp/TR+fQi62F79RHWmwKOtFmwteURgLbj7D/WGuNLGOfa/2vse3G2eHnHl5CB8ruRX9fBl/KgwCVr2JaEuUm66bBQeP5XeBotdR4cvX38uPYivCDdPjJ1QWPdspTBKcxeFbccDw== 

Questo è stato ottenuto con questo comando:

 ssh-keygen -y -f private_key1.pem > public_key1.pub 

Non c’è bisogno di compilare materiale. Puoi fare lo stesso con ssh-keygen :

 ssh-keygen -f pub1key.pub -i 

leggerà la chiave pubblica in formato openssl da pub1key.pub e l’output in formato OpenSSH.

Nota : in alcuni casi è necessario specificare il formato di input:

 ssh-keygen -f pub1key.pub -i -mPKCS8 

Dai documenti ssh-keygen (da man ssh-keygen):

-m key_format Specifica un formato chiave per le opzioni di conversione -i (importazione) o -e (esportazione). I formati chiave supportati sono: “RFC4716” (chiave pubblica o privata RFC 4716 / SSH2), “PKCS8” (chiave pubblica PEM PKCS8) o “PEM” (chiave pubblica PEM). Il formato di conversione predefinito è “RFC4716”.

Non c’è bisogno di script o altri “trucchi”: openssl e ssh-keygen sono sufficienti. Sto assumendo nessuna password per le chiavi (che è male).

Genera una coppia RSA

Tutti i seguenti metodi forniscono una coppia di chiavi RSA nello stesso formato

  1. Con openssl ( uomo genrsa )

     openssl genrsa -out dummy-genrsa.pem 2048 

    In OpenSSL v1.0.1 genrsa è soppiantato da genpkey quindi questo è il nuovo modo di farlo ( man genpkey ):

     openssl genpkey -algorithm RSA -out dummy-genpkey.pem -pkeyopt rsa_keygen_bits:2048 
  2. Con ssh-keygen

     ssh-keygen -t rsa -b 2048 -f dummy-ssh-keygen.pem -N '' -C "Test Key" 

Conversione di DER in PEM

Se hai una coppia di chiavi RSA in formato DER, potresti volerlo convertire in PEM per consentire la conversione del formato qui sotto:

Generazione:

 openssl genpkey -algorithm RSA -out genpkey-dummy.cer -outform DER -pkeyopt rsa_keygen_bits:2048 

Conversione:

 openssl rsa -inform DER -outform PEM -in genpkey-dummy.cer -out dummy-der2pem.pem 

Estrarre la chiave pubblica dalla coppia RSA formattata PEM

  1. in formato PEM:

     openssl rsa -in dummy-xxx.pem -pubout 
  2. nel formato OpenSSH v2 vedere :

     ssh-keygen -y -f dummy-xxx.pem 

Gli appunti

Versione del sistema operativo e del software:

 [[email protected] ~]# cat /etc/redhat-release ; uname -a ; openssl version CentOS release 6.5 (Final) Linux test1.example.local 2.6.32-431.el6.x86_64 #1 SMP Fri Nov 22 03:15:09 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux OpenSSL 1.0.1e-fips 11 Feb 2013 

Riferimenti:

  • Sysmic.org Converti chiavi tra GnuPG, OpenSsh e OpenSSL

Per rispondere alla mia domanda, dopo aver postato sulla mailing list di openssl, ho ottenuto questo:

Ecco il codice C per convertire da una chiave pubblica OpenSSL a una chiave pubblica OpenSSH. Puoi prendere il codice da questo link e compilarlo da solo:

 static unsigned char pSshHeader[11] = { 0x00, 0x00, 0x00, 0x07, 0x73, 0x73, 0x68, 0x2D, 0x72, 0x73, 0x61}; static int SshEncodeBuffer(unsigned char *pEncoding, int bufferLen, unsigned char* pBuffer) { int adjustedLen = bufferLen, index; if (*pBuffer & 0x80) { adjustedLen++; pEncoding[4] = 0; index = 5; } else { index = 4; } pEncoding[0] = (unsigned char) (adjustedLen >> 24); pEncoding[1] = (unsigned char) (adjustedLen >> 16); pEncoding[2] = (unsigned char) (adjustedLen >> 8); pEncoding[3] = (unsigned char) (adjustedLen ); memcpy(&pEncoding[index], pBuffer, bufferLen); return index + bufferLen; } int main(int argc, char** argv) { int iRet = 0; int nLen = 0, eLen = 0; int encodingLength = 0; int index = 0; unsigned char *nBytes = NULL, *eBytes = NULL; unsigned char* pEncoding = NULL; FILE* pFile = NULL; EVP_PKEY *pPubKey = NULL; RSA* pRsa = NULL; BIO *bio, *b64; ERR_load_crypto_strings(); OpenSSL_add_all_algorithms(); if (argc != 3) { printf("usage: %s public_key_file_name ssh_key_description\n", argv[0]); iRet = 1; goto error; } pFile = fopen(argv[1], "rt"); if (!pFile) { printf("Failed to open the given file\n"); iRet = 2; goto error; } pPubKey = PEM_read_PUBKEY(pFile, NULL, NULL, NULL); if (!pPubKey) { printf("Unable to decode public key from the given file: %s\n", ERR_error_string(ERR_get_error(), NULL)); iRet = 3; goto error; } if (EVP_PKEY_type(pPubKey->type) != EVP_PKEY_RSA) { printf("Only RSA public keys are currently supported\n"); iRet = 4; goto error; } pRsa = EVP_PKEY_get1_RSA(pPubKey); if (!pRsa) { printf("Failed to get RSA public key : %s\n", ERR_error_string(ERR_get_error(), NULL)); iRet = 5; goto error; } // reading the modulus nLen = BN_num_bytes(pRsa->n); nBytes = (unsigned char*) malloc(nLen); BN_bn2bin(pRsa->n, nBytes); // reading the public exponent eLen = BN_num_bytes(pRsa->e); eBytes = (unsigned char*) malloc(eLen); BN_bn2bin(pRsa->e, eBytes); encodingLength = 11 + 4 + eLen + 4 + nLen; // correct depending on the MSB of e and N if (eBytes[0] & 0x80) encodingLength++; if (nBytes[0] & 0x80) encodingLength++; pEncoding = (unsigned char*) malloc(encodingLength); memcpy(pEncoding, pSshHeader, 11); index = SshEncodeBuffer(&pEncoding[11], eLen, eBytes); index = SshEncodeBuffer(&pEncoding[11 + index], nLen, nBytes); b64 = BIO_new(BIO_f_base64()); BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); bio = BIO_new_fp(stdout, BIO_NOCLOSE); BIO_printf(bio, "ssh-rsa "); bio = BIO_push(b64, bio); BIO_write(bio, pEncoding, encodingLength); BIO_flush(bio); bio = BIO_pop(b64); BIO_printf(bio, " %s\n", argv[2]); BIO_flush(bio); BIO_free_all(bio); BIO_free(b64); error: if (pFile) fclose(pFile); if (pRsa) RSA_free(pRsa); if (pPubKey) EVP_PKEY_free(pPubKey); if (nBytes) free(nBytes); if (eBytes) free(eBytes); if (pEncoding) free(pEncoding); EVP_cleanup(); ERR_free_strings(); return iRet; } 

Ho fatto con

ssh-keygen -i -f $ sshkeysfile >> authorized_keys

Il credito va qui

 ssh-keygen -f private.pem -y > public.pub 

Lo script seguente otterrebbe il certificato di chiave pubblica ci.jenkins-ci.org nel formato DER codificato in base64 e lo convertirà in un file di chiave pubblica OpenSSH. Questo codice presuppone che venga utilizzata una chiave RSA a 2048 bit e trae molto da questa risposta di Ian Boyd. Ho spiegato un po ‘di più come funziona nei commenti a questo articolo nella wiki di Jenkins.

 echo -n "ssh-rsa " > jenkins.pub curl -sfI https://ci.jenkins-ci.org/ | grep X-Instance-Identity | tr -d \\r | cut -d\ -f2 | base64 -d | dd bs=1 skip=32 count=257 status=none | xxd -p -c257 | sed s/^/00000007\ 7373682d727361\ 00000003\ 010001\ 00000101\ / | xxd -p -r | base64 -w0 >> jenkins.pub echo >> jenkins.pub 

Tutte le risposte sbagliate. Questo è quello corretto:

ssh-keygen -i -m PKCS8 -f public-key.pem