Tengo un certificado en der formato, con este comando generar una clave pública:

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

Que se traduce en esto:

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

¿Cómo puedo obtener una clave pública como esta? Ya sea desde el certificado o
a partir de esta clave pública?

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

Este fue obtenido con este comando:

ssh-keygen -y -f private_key1.pem > public_key1.pub
  • La forma en que has publicado en el «Este fue obtenido con este comando» trabajó para mí mejor que cualquiera de las respuestas a continuación.
  • Ídem @YoavShapira. Un paso más si viene de una openssl PKCS12 clave privada: «openssl pkcs12 -en private_key1.p12 -out private_key1.pem»
  • Sí, pero la cuestión es que quiere convertir usando sólo la clave pública. Tal vez él no tiene la clave privada y que sólo él tiene la clave pública y la quiere convertir de formato PEM ssh-rsa formato.
  • Dada una .pem de AWS, el comando que dan sobre ssh-keygen -y -f private_key1.pem > public_key1.pub trabajado muy bien para mí.
  • Todas las respuestas incorrectas. Esta es la correcta: ssh-keygen -i -m PKCS8 -f public-key.pem
InformationsquelleAutor Adrya | 2009-06-18

9 Comentarios

  1. 116

    No hay necesidad de compilar cosas. Usted puede hacer lo mismo con ssh-keygen:

    ssh-keygen -f pub1key.pub -i
    

    va a leer la clave pública en openssl formato de pub1key.pub y de salida en formato OpenSSH.

    Nota: En algunos casos será necesario especificar el formato de entrada:

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

    De la ssh-keygen docs (De man ssh-keygen):

    -m key_format Especificar un formato de la clave para la -i (importación) o -e (exportación) de las opciones de conversión. El admite formatos de clave son: «RFC4716» (RFC 4716/SSH2 de claves públicas o privadas), «PKCS8» (PEM PKCS8 de clave pública) o «PEM» (PEM de clave pública). El valor predeterminado de conversión de formato es «RFC4716».

    • ssh-keygen: ilegal opción-m
    • no funciona para mí.
    • si -m no es compatible, funciona bien sin ella.
    • La pregunta va en la otra dirección.
    • Para el futuro de la web de los buscadores de la verdad, si esto no funciona para usted, los comentarios en la pregunta original, trabajó para mí.
    • En mi caso, la -m PKCS8 era necesario
    • Puedo obtener uudecode failed. Cuando se ejecuta este
    • $ ssh-keygen -f mykey.pub -i key_from_blob: invalid format decode blob failed.
    • He añadido de nuevo el más específico, más el formato de la respuesta debido a que se requiere por mí y algunos otros. Parece que funciona depende de qué versión de ssh-keygen está utilizando y/ o formato de entrada.
    • Usted salvó mi vida, MUCHAS gracias. Su respuesta DEBE ser marcado como correcto !

  2. 44

    Sin necesidad de secuencias de comandos u otros ‘trucos’: openssl y ssh-keygen son suficientes. Estoy suponiendo que no hay contraseña para las llaves (que es malo).

    Generar un RSA par

    Todos los siguientes métodos de dar un par de claves RSA en el mismo formato

    1. Con openssl (hombre genrsa)

      openssl genrsa -out dummy-genrsa.pem 2048
      

      En OpenSSL v1.0.1 genrsa es sustituido por genpkey así que esta es la nueva forma de hacerlo (hombre 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"
      

    La conversión de DER a PEM

    Si usted tiene un par de claves RSA en formato DER, puede que desee convertir a PEM para permitir la conversión de formato a continuación:

    Generación:

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

    De conversión:

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

    Extraer la clave pública de la PEM formato de RSA par

    1. en formato PEM:

      openssl rsa -in dummy-xxx.pem -pubout
      
    2. en OpenSSH v2 formato ver:

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

    Notas

    OS y la versión de 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
    

    Referencias:

    • / / , ¿Esto realmente generar una clave en el ssh-rsa formato? Buena referencia, por cierto.
    • sí (consulte «Extraer la clave pública de la PEM formato de RSA par», punto 2): una vez que uno tiene el certificado en formato pem: ssh-keygen -y -f dummy-xxx.pem produce un ssh-rsa AAAA[...]== ajuste por ssh del authorized_keys archivo.
    • Buena pieza informativa… pero no creo que realmente responde a la pregunta así como el de arriba mucho más corto de la pieza.
  3. 23

    Para responder a mi propia pregunta, después de la publicación en openssl lista de correo tiene esto:

    Aquí está el código C para convertir de una OpenSSL clave pública a un OpenSSH clave pública.
    Usted puede agarrar el código de en este enlace y compilarlo usted mismo:

    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;
    }
    
    • En caso de que alguien se está preguntando cómo compilar esta (estaba), aquí está el compilador de llamada: gcc-o pubkey2ssh pubkey2ssh.c -lcrypto
    • ¿de dónde obtener argv[2] (ssh_key_description) de… acabo de tener una —–BEGIN RSA de CLAVE PÚBLICA—– MIGJAoGBAMC62xWiOZYlhUhmk+JESy5eZunwGoG9kSHUMn67iBNZLEsR2qn44j1b TOtZRuEsSAKxu7alFlJVu5aSGbUvin3Dusyasl5szjtf9vzgjhsvycortchc1tui WMAWfv2BLTmK4zBEC33riEBLeX8Trphp3ybimtzqv81zrzhzbsnragmbaae= —–END RSA de CLAVE PÚBLICA—– no tiene una descripción
    • Por lo general es sólo la dirección de correo electrónico del dueño de la clave. Pero se puede poner lo que quiera int descripción.
    • Php de la aplicación opensshtopem aquí github.com/131/yks/blob/master/class/stds/crypt.php#L346
    • La respuesta de @mkalkov por debajo de la conversión, el uso de Linux herramientas de línea de comandos. Sólo se necesita la clave pública pem archivo con los encabezados de quita y líneas combinadas como una entrada.
  4. 11

    Todas las respuestas incorrectas. Esta es la correcta:

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

    • GRACIAS! Este gran trabajo
    • No me funciona: «do_convert_from_pkcs8: clave.pem no es un reconocido público formato de la clave». ¿Qué trabajo se «ssh-keygen-y -f clave.pem» que imprime el ssh-rsa de texto necesarios para authorized_keys.
    • Esto no es trabajo do_convert_from_pkcs8: TEST.pem is not a recognised public key format
  5. 6

    Hice con

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

    El crédito va aquí

    • ¿Por qué no dar crédito a Victor arriba? Él le dio el mismo comando de casi 8 meses antes.
    • Desde el registro de edición de Víctor respuesta puede ver que, originalmente, la respuesta fue un poco diferente, yo asumo que esta es la razón por la
  6. 2

    La siguiente secuencia de comandos de obtener la ci.jenkins-ci.org certificado de clave pública en base64 codificado en formato DER y la convierten en una de OpenSSH archivo de clave pública. Este código supone que una clave RSA de 2048 bits se utiliza y atrae una gran cantidad de este Ian Boyd respuesta. Me he explicado un poco más de cómo funciona en los comentarios a este artículo en Jenkins wiki.

    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
    
    • OMG esta es la mejor respuesta! Y funciona! (Sólo he tenido que cambiar de status=ninguno con status=noxfer). Sólo uso el segundo comando que comienza con «base64» y darle un PEM archivo de entrada con los encabezados de los despojados y de todas las líneas que se concatena con uno. Gracias @mkalkov!
    • Nota: los comandos anteriores asumen clave de 2048 bits y no funcionará correctamente si se le da una clave de un tamaño diferente.
  7. 1

    FWIW, este script de BASH que tendrá un PEM – o DER-formato X. 509 certificado o OpenSSL archivo de clave pública (también en formato PEM) como primer argumento y devuelvan un OpenSSH de clave pública RSA. Esto amplía @mkalkov la respuesta anterior. Los requisitos son cat, grep, tr, dd, xxd, sed, xargs, file, uuidgen, base64, openssl (1.0+), y, por supuesto,bash. Todos, excepto openssl (contiene base64) son bastante garantizados para ser parte de la base de que se instale en cualquier moderno sistema Linux, excepto tal vez xxd (que Fedora se muestra en la vim-common paquete). Si alguien quiere que limpiar y hacer más agradable, caveat lector.

    #!/bin/bash
    #
    # Extract a valid SSH format public key from an X509 public certificate.
    #
    
    # Variables:
    pubFile=$1
    fileType="no"
    pkEightTypeFile="$pubFile"
    tmpFile="/tmp/`uuidgen`-pkEightTypeFile.pk8"
    
    # See if a file was passed:
    [ ! -f "$pubFile" ] && echo "Error, bad or no input file $pubFile." && exit 1
    
    # If it is a PEM format X.509 public cert, set $fileType appropriately:
    pemCertType="X$(file $pubFile | grep 'PEM certificate')"
    [ "$pemCertType" != "X" ] && fileType="PEM"
    
    # If it is an OpenSSL PEM-format PKCS#8-style public key, set $fileType appropriately:
    pkEightType="X$(grep -e '-BEGIN PUBLIC KEY-' $pubFile)"
    [ "$pkEightType" != "X" ] && fileType="PKCS"
    
    # If this is a file we can't recognise, try to decode a (binary) DER-format X.509 cert:
    if [ "$fileType" = "no" ]; then
            openssl x509 -in $pubFile -inform DER -noout
            derResult=$(echo $?)
            [ "$derResult" = "0" ] && fileType="DER"
    fi
    
    # Exit if not detected as a file we can use:
    [ "$fileType" = "no" ] && echo "Error, input file not of type X.509 public certificate or OpenSSL PKCS#8-style public key (not encrypted)." && exit 1
    
    # Convert the X.509 public cert to an OpenSSL PEM-format PKCS#8-style public key:
    if [ "$fileType" = "PEM" -o "$fileType" = "DER" ]; then
            openssl x509 -in $pubFile -inform $fileType -noout -pubkey > $tmpFile
            pkEightTypeFile="$tmpFile"
    fi
    
    # Build the string:
    # Front matter:
    frontString="$(echo -en 'ssh-rsa ')"
    
    # Encoded modulus and exponent, with appropriate pointers:
    encodedModulus="$(cat $pkEightTypeFile | grep -v -e "----" | tr -d '\n' | 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 )"
    
    # Add a comment string based on the filename, just to be nice:
    commentString=" $(echo $pubFile | xargs basename | sed -e 's/\.crt\|\.cer\|\.pem\|\.pk8\|\.der//')"
    
    # Give the user a string:
    echo $frontString $encodedModulus $commentString
    
    # cleanup:
    rm -f $tmpFile
    

Dejar respuesta

Please enter your comment!
Please enter your name here