¿Cómo puedo transformar entre los dos estilos de formato de clave pública, uno “BEGIN RSA PUBLIC KEY”, el otro es “BEGIN PUBLIC KEY”

¿Cómo puedo transformar entre los dos estilos de formato de clave pública, un formato es:

-----BEGIN PUBLIC KEY----- ... -----END PUBLIC KEY----- 

el otro formato es:

 -----BEGIN RSA PUBLIC KEY----- ... -----END RSA PUBLIC KEY----- 

por ejemplo, he generado id_rsa / id_rsa.pub pair utilizando el comando ssh-keygen, calculé la clave pública de id_rsa usando:

 openssl rsa -in id_rsa -pubout -out pub2 

luego volví a calcular la clave pública de id_rsa.pub usando:

 ssh-keygen -f id_rsa.pub -e -m pem > pub1 

el contenido es pub1 es:

 -----BEGIN RSA PUBLIC KEY----- MIIBCgKCAQEA61BjmfXGEvWmegnBGSuS+rU9soUg2FnODva32D1AqhwdziwHINFa D1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBSEVCgJjtHAGZIm5GL/KA86KDp/CwDFMSw luowcXwDwoyinmeOY9eKyh6aY72xJh7noLBBq1N0bWi1e2i+83txOCg4yV2oVXhB o8pYEJ8LT3el6Smxol3C1oFMVdwPgc0vTl25XucMcG/ALE/KNY6pqC2AQ6R2ERlV gPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeulmCpGSynXNcpZ/06+vofGi/2MlpQZNhH Ao8eayMp6FcvNucIpUndo1X8dKMv3Y26ZQIDAQAB -----END RSA PUBLIC KEY----- 

y el contenido de pub2 es:

 -----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA61BjmfXGEvWmegnBGSuS +rU9soUg2FnODva32D1AqhwdziwHINFaD1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBS EVCgJjtHAGZIm5GL/KA86KDp/CwDFMSwluowcXwDwoyinmeOY9eKyh6aY72xJh7n oLBBq1N0bWi1e2i+83txOCg4yV2oVXhBo8pYEJ8LT3el6Smxol3C1oFMVdwPgc0v Tl25XucMcG/ALE/KNY6pqC2AQ6R2ERlVgPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeu lmCpGSynXNcpZ/06+vofGi/2MlpQZNhHAo8eayMp6FcvNucIpUndo1X8dKMv3Y26 ZQIDAQAB -----END PUBLIC KEY----- 

Según lo que entiendo, pub1 y pub2 contienen la misma información de clave pública, pero están en diferentes formatos, me pregunto cómo puedo transformarme entre los dos formatos. ¿Alguien puede mostrarme una introducción concisa sobre los formatos de arrastre?

Usando phpseclib, una implementación pura de PHP RSA …

 loadKey('-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA61BjmfXGEvWmegnBGSuS +rU9soUg2FnODva32D1AqhwdziwHINFaD1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBS EVCgJjtHAGZIm5GL/KA86KDp/CwDFMSwluowcXwDwoyinmeOY9eKyh6aY72xJh7n oLBBq1N0bWi1e2i+83txOCg4yV2oVXhBo8pYEJ8LT3el6Smxol3C1oFMVdwPgc0v Tl25XucMcG/ALE/KNY6pqC2AQ6R2ERlVgPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeu lmCpGSynXNcpZ/06+vofGi/2MlpQZNhHAo8eayMp6FcvNucIpUndo1X8dKMv3Y26 ZQIDAQAB -----END PUBLIC KEY-----'); $rsa->setPublicKey(); echo $rsa->getPublicKey(CRYPT_RSA_PUBLIC_FORMAT_PKCS1_RAW); 

La información codificada en base64 parece coincidir aunque el encabezado diga BEGIN PUBLIC KEY y no COMIENCE RSA PUBLIC KEY. Así que tal vez solo uses str_replace para arreglar eso y ¡deberías estar listo!

Quería ayudar a explicar lo que está pasando aquí.

Una “Clave pública” de RSA consta de dos números:

  • el módulo (por ejemplo, un número de 2.048 bits)
  • el exponente (usualmente 65,537)

Usando su clave pública RSA como ejemplo, los dos números son:

  • Módulo : 297,056,429,939,040,947,991,047,334,197,581,225,628,107,021,573,849,359,042,679,698,093,131,908, 015,712,695,688,944,173,317,630,555,849,768,647,118,986,535,684,992,447,654,339,728,777,985,990,170, 679,511,111,819,558,063,246,667,855,023,730,127,805,401,069,042,322,764,200,545,883,378,826,983,730, 553.730.138.478.384.327.116.513.143.842.816.383.440.639.376.515.039.682.874.046.227.217.032.079.079.790.098.143.158.087.443.017.552.531.393.264.852.461.292.775.129.262.080.851.633.535.934.010.704.122.673.027.067.442.627.059.982.393.297.716.922.243.940.155.855.127.430.302.323.883.824.137.412.883.916.794.359.982.603.439.112.095.116.831.297.809.626.059.569.444.750.808.699.678.211.904.501.083.183.234.323.797.142.810.155.862.553.705.570.600.021.649.944.369.726.123.996.534.870.137.000.784.980.673.984.909.570.977.377.882.585.701
  • Exponente : 65,537

La pregunta entonces es cómo queremos almacenar estos números en una computadora. Primero convertimos ambos a hexadecimal:

  • Módulo: EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65
  • Exponente : 010001

RSA inventó el primer formato

RSA inventó un formato primero:

 RSAPublicKey ::= SEQUENCE { modulus INTEGER, -- n publicExponent INTEGER -- e } 

Eligieron usar el sabor DER del estándar de encoding binaria ASN.1 para representar los dos números [1] :

 SEQUENCE (2 elements) INTEGER (2048 bit): INTEGER (24 bit): 010001 

La encoding binaria final en ASN.1 es:

 30 82 01 0A ;sequence (0x10A bytes long) 02 82 01 01 ;integer (0x101 bytes long) 00 EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65 02 03 ;integer (3 bytes long) 010001 

Si luego ejecuta todos esos bytes juntos y Base64 lo codifica, obtiene:

 MIIBCgKCAQEA61BjmfXGEvWmegnBGSuS+rU9soUg2FnODva32D1AqhwdziwHINFa D1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBSEVCgJjtHAGZIm5GL/KA86KDp/CwDFMSw luowcXwDwoyinmeOY9eKyh6aY72xJh7noLBBq1N0bWi1e2i+83txOCg4yV2oVXhB o8pYEJ8LT3el6Smxol3C1oFMVdwPgc0vTl25XucMcG/ALE/KNY6pqC2AQ6R2ERlV gPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeulmCpGSynXNcpZ/06+vofGi/2MlpQZNhH Ao8eayMp6FcvNucIpUndo1X8dKMv3Y26ZQIDAQAB 

Luego, los laboratorios RSA dijeron agregar un encabezado y un avance:

 -----BEGIN RSA PUBLIC KEY----- MIIBCgKCAQEA61BjmfXGEvWmegnBGSuS+rU9soUg2FnODva32D1AqhwdziwHINFa D1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBSEVCgJjtHAGZIm5GL/KA86KDp/CwDFMSw luowcXwDwoyinmeOY9eKyh6aY72xJh7noLBBq1N0bWi1e2i+83txOCg4yV2oVXhB o8pYEJ8LT3el6Smxol3C1oFMVdwPgc0vTl25XucMcG/ALE/KNY6pqC2AQ6R2ERlV gPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeulmCpGSynXNcpZ/06+vofGi/2MlpQZNhH Ao8eayMp6FcvNucIpUndo1X8dKMv3Y26ZQIDAQAB -----END RSA PUBLIC KEY----- 

Cinco guiones y las palabras BEGIN RSA PUBLIC KEY . Esa es su clave pública RSA PEM DER ASN.1 PKCS # 1

  • PEM: sinónimo de base64
  • DER: un sabor de encoding ASN.1
  • ASN.1: el esquema de encoding binario utilizado
  • PKCS # 1: la especificación formal que dicta que representa una clave pública como estructura que consta de módulo seguido de un exponente
  • Clave pública RSA: el algoritmo de clave pública que se utiliza

No solo RSA

Después de eso, aparecieron otras formas de criptografía de clave pública:

  • Diffie-Hellman
  • Curva elíptica

Cuando llegó el momento de crear un estándar sobre cómo representar los parámetros de esos algoritmos de cifrado, las personas adoptaron muchas de las mismas ideas que RSA originalmente definió:

  • usar encoding binaria ASN.1
  • base64
  • envuélvelo con cinco guiones
  • y las palabras BEGIN PUBLIC KEY

Pero en lugar de usar:

  • -----BEGIN RSA PUBLIC KEY-----
  • -----BEGIN DH PUBLIC KEY-----
  • -----BEGIN EC PUBLIC KEY-----

En su lugar, decidieron incluir el identificador de objeto (OID) de lo que sigue. En el caso de una clave pública de RSA, es decir:

  • RSA PKCS # 1 : 1.2.840.113549.1.1.1

Eso te da una ASN.1 de:

 SEQUENCE (2 elements) SEQUENCE (2 elements) OBJECT IDENTIFIER 1.2.840.113549.1.1.1 NULL BIT STRING (1 element) SEQUENCE (2 elements) INTEGER (2048 bit): INTEGER (24 bit): 010001 

La encoding binaria final en ASN.1 es:

 30 82 01 22 ;SEQUENCE (0x122 bytes = 290 bytes) | 30 0D ;SEQUENCE (0x0d bytes = 13 bytes) | | 06 09 ;OBJECT IDENTIFIER (0x09 = 9 bytes) | | 2A 86 48 86 | | F7 0D 01 01 01 ;hex encoding of 1.2.840.113549.1.1 | | 05 00 ;NULL (0 bytes) | 03 82 01 0F 00 ;BIT STRING (0x10f = 271 bytes) | | 30 82 01 0A ;SEQUENCE (0x10a = 266 bytes) | | | 02 82 01 01 ;INTEGER (0x101 = 257 bytes) | | | | 00 ;leading zero of INTEGER | | | | EB 50 63 99 F5 C6 12 F5 A6 7A 09 C1 19 2B 92 FA | | | | B5 3D B2 85 20 D8 59 CE 0E F6 B7 D8 3D 40 AA 1C | | | | 1D CE 2C 07 20 D1 5A 0F 53 15 95 CA D8 1B A5 D1 | | | | 29 F9 1C C6 76 97 19 F1 43 58 72 C4 BC D0 52 11 | | | | 50 A0 26 3B 47 00 66 48 9B 91 8B FC A0 3C E8 A0 | | | | E9 FC 2C 03 14 C4 B0 96 EA 30 71 7C 03 C2 8C A2 | | | | 9E 67 8E 63 D7 8A CA 1E 9A 63 BD B1 26 1E E7 A0 | | | | B0 41 AB 53 74 6D 68 B5 7B 68 BE F3 7B 71 38 28 | | | | 38 C9 5D A8 55 78 41 A3 CA 58 10 9F 0B 4F 77 A5 | | | | E9 29 B1 A2 5D C2 D6 81 4C 55 DC 0F 81 CD 2F 4E | | | | 5D B9 5E E7 0C 70 6F C0 2C 4F CA 35 8E A9 A8 2D | | | | 80 43 A4 76 11 19 55 80 F8 94 58 E3 DA B5 59 2D | | | | EF E0 6C DE 1E 51 6A 6C 61 ED 78 C1 39 77 AE 96 | | | | 60 A9 19 2C A7 5C D7 29 67 FD 3A FA FA 1F 1A 2F | | | | F6 32 5A 50 64 D8 47 02 8F 1E 6B 23 29 E8 57 2F | | | | 36 E7 08 A5 49 DD A3 55 FC 74 A3 2F DD 8D BA 65 | | | 02 03 ;INTEGER (03 = 3 bytes) | | | | 010001 

Y como antes, tomas todos esos bytes, Base64 los codifica, terminas con tu segundo ejemplo:

 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA61BjmfXGEvWmegnBGSuS +rU9soUg2FnODva32D1AqhwdziwHINFaD1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBS EVCgJjtHAGZIm5GL/KA86KDp/CwDFMSwluowcXwDwoyinmeOY9eKyh6aY72xJh7n oLBBq1N0bWi1e2i+83txOCg4yV2oVXhBo8pYEJ8LT3el6Smxol3C1oFMVdwPgc0v Tl25XucMcG/ALE/KNY6pqC2AQ6R2ERlVgPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeu lmCpGSynXNcpZ/06+vofGi/2MlpQZNhHAo8eayMp6FcvNucIpUndo1X8dKMv3Y26 ZQIDAQAB 

Agregue el encabezado y el avance ligeramente diferentes, y obtendrá:

 -----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA61BjmfXGEvWmegnBGSuS +rU9soUg2FnODva32D1AqhwdziwHINFaD1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBS EVCgJjtHAGZIm5GL/KA86KDp/CwDFMSwluowcXwDwoyinmeOY9eKyh6aY72xJh7n oLBBq1N0bWi1e2i+83txOCg4yV2oVXhBo8pYEJ8LT3el6Smxol3C1oFMVdwPgc0v Tl25XucMcG/ALE/KNY6pqC2AQ6R2ERlVgPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeu lmCpGSynXNcpZ/06+vofGi/2MlpQZNhHAo8eayMp6FcvNucIpUndo1X8dKMv3Y26 ZQIDAQAB -----END PUBLIC KEY----- 

Y esta es su clave pública X.509 SubjectPublicKeyInfo / OpenSSL PEM [2] .

Hazlo bien o piratearlo

Ahora que sabe que la encoding no es mágica, puede escribir todas las piezas necesarias para analizar el módulo RSA y el exponente. O puede reconocer que los primeros 24 bytes solo agregan cosas nuevas además del estándar original PKCS # 1

 30 82 01 22 ;SEQUENCE (0x122 bytes = 290 bytes) | 30 0D ;SEQUENCE (0x0d bytes = 13 bytes) | | 06 09 ;OBJECT IDENTIFIER (0x09 = 9 bytes) | | 2A 86 48 86 | | F7 0D 01 01 01 ;hex encoding of 1.2.840.113549.1.1 | | 05 00 ;NULL (0 bytes) | 03 82 01 0F 00 ;BIT STRING (0x10f = 271 bytes) | | ... 

Y debido a una extraordinaria coincidencia de fortuna y buena suerte:

24 bytes coinciden exactamente con 32 caracteres codificados en base64

Eso significa que si toma su segunda clave pública X.509 y separa los primeros 32 caracteres:

 -----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A MIIBCgKCAQEA61BjmfXGEvWmegnBGSuS+rU9soUg2FnODva32D1AqhwdziwHINFa D1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBSEVCgJjtHAGZIm5GL/KA86KDp/CwDFMSw luowcXwDwoyinmeOY9eKyh6aY72xJh7noLBBq1N0bWi1e2i+83txOCg4yV2oVXhB o8pYEJ8LT3el6Smxol3C1oFMVdwPgc0vTl25XucMcG/ALE/KNY6pqC2AQ6R2ERlV gPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeulmCpGSynXNcpZ/06+vofGi/2MlpQZNhH Ao8eayMp6FcvNucIpUndo1X8dKMv3Y26ZQIDAQAB -----END PUBLIC KEY----- 

elimine los primeros 32 caracteres y cámbielo a BEGIN RSA PUBLIC KEY :

 -----BEGIN RSA PUBLIC KEY----- MIIBCgKCAQEA61BjmfXGEvWmegnBGSuS+rU9soUg2FnODva32D1AqhwdziwHINFa D1MVlcrYG6XRKfkcxnaXGfFDWHLEvNBSEVCgJjtHAGZIm5GL/KA86KDp/CwDFMSw luowcXwDwoyinmeOY9eKyh6aY72xJh7noLBBq1N0bWi1e2i+83txOCg4yV2oVXhB o8pYEJ8LT3el6Smxol3C1oFMVdwPgc0vTl25XucMcG/ALE/KNY6pqC2AQ6R2ERlV gPiUWOPatVkt7+Bs3h5Ramxh7XjBOXeulmCpGSynXNcpZ/06+vofGi/2MlpQZNhH Ao8eayMp6FcvNucIpUndo1X8dKMv3Y26ZQIDAQAB -----END RSA PUBLIC KEY----- 

Tienes exactamente lo que querías.

Encontré este sitio web como una buena explicación técnica de los diferentes formatos: https://polarssl.org/kb/cryptography/asn1-key-structures-in-der-and-pem

“BEGIN RSA PUBLIC KEY” es PKCS # 1, que solo puede contener claves RSA.

“BEGIN PUBLIC KEY” es PKCS # 8, que puede contener una variedad de formatos.

Si solo quieres convertirlos con la línea de comandos, “openssl rsa” es bueno para esto.

Para convertir de PKCS # 8 a PKCS # 1:

 openssl rsa -pubin -in  -RSAPublicKey_out 

Para convertir de PKCS # 1 a PKCS # 8:

 openssl rsa -RSAPublicKey_in -in  -pubout 

Si bien los comentarios anteriores sobre los encabezados de 32 bytes, los formatos OID y otros son interesantes, personalmente no veo el mismo comportamiento, suponiendo que entiendo el punto. Pensé que podría ser útil explorar esto más allá en lo que la mayoría podría pensar que es un detalle excesivo. Nada excede como exceso.

Para comenzar, creé una clave privada de RSA y la verifiqué:

 >openssl rsa -in newclient_privatekey.pem -check RSA key ok writing RSA key -----BEGIN RSA PRIVATE KEY----- MIICXQIBAAKBgQCn/OlFk7vLRQ6dBiNQkvjnhm4pOYWo+GeAEmU4N1HPZj1dxv70 4hm80eYc7h12xc7oVcDLBdHByGAGBpQfpjgdPyozC/zSqcuU6iBrvzDTpyG1zhIG 76KrcjdbX6PlKAPO9r/dCRmUijFhVoUlY6ywGknmLBrtZkLkBhchgYnMswIDAQAB AoGAQaJ5aivspeEXcpahWavzAFLv27+Tz48usUV+stY6arRhqbBEkV19/N5t8EPA 01U6IGDQ8QIXEIW/rtsHKM6DAZhAbakPDJhJRatcMzJ08ryIkP/c3+onkTquiveG brw7xzn6Xa8ls04aQ6VQR4jxXUjV5bB72pFZnGRoAmS2NiECQQDUoISbmTGjnHM+ kEfunNTXbNmKklwTYhyZaSVsSptnD7CvLWB4qB/g4h2/HjsELag6Z7SlWuYr7tba H3nBYn35AkEAykFRudMqlBy3XmcGIpjxOD+7huyViPoUpy3ui/Bj3GbqsbEAt9cR PyOJa1VFa2JqShta1Tdep8LJv1QvgvY7CwJBAML+al5gAXvwEGhB3RXg0fi2JFLG opZMFbpDCUTkrtu3MeuVC7HbTVDpTSpmSO0uCed2D97NG+USZgsnbnuBHdECQQCw S3FWPXdetQ0srzaMz61rLzphaDULuZhpBMNqnTYeNmMaUcPjewagd3Rf52rkKFun juKE+Yd7SXGbYWEskT5zAkAD7tbNwe5ryD2CT71jrY/5uXMR2yg/A4Ry2ocZkQUp iGflLrHnODvHO5LYLBlSKpjanBceYHJLuMFNZruf7uBM -----END RSA PRIVATE KEY----- 

(Oh, horrores! He expuesto una clave privada. Meh …)

Extraigo y visualizo su clave pública:

 >openssl rsa -in newclient_privatekey.pem -pubout writing RSA key -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCn/OlFk7vLRQ6dBiNQkvjnhm4p OYWo+GeAEmU4N1HPZj1dxv704hm80eYc7h12xc7oVcDLBdHByGAGBpQfpjgdPyoz C/zSqcuU6iBrvzDTpyG1zhIG76KrcjdbX6PlKAPO9r/dCRmUijFhVoUlY6ywGknm LBrtZkLkBhchgYnMswIDAQAB -----END PUBLIC KEY----- 

Ocurre que hay otro parámetro de salida de clave pública (como se menciona en un comentario anterior). Extraigo y visualizo la clave pública usando esa palabra clave en su lugar:

 >openssl rsa -in newclient_privatekey.pem -RSAPublicKey_out writing RSA key -----BEGIN RSA PUBLIC KEY----- MIGJAoGBAKf86UWTu8tFDp0GI1CS+OeGbik5haj4Z4ASZTg3Uc9mPV3G/vTiGbzR 5hzuHXbFzuhVwMsF0cHIYAYGlB+mOB0/KjML/NKpy5TqIGu/MNOnIbXOEgbvoqty N1tfo+UoA872v90JGZSKMWFWhSVjrLAaSeYsGu1mQuQGFyGBicyzAgMBAAE= -----END RSA PUBLIC KEY----- 

Bien bien. Estos dos valores de clave pública no son los mismos, aunque se derivan de la misma clave privada. ¿O son lo mismo? Corto y pego las dos cadenas de teclas públicas en sus propios archivos, y luego hago una comprobación de módulo en cada una:

 >openssl rsa -in newclient_publickey.pem -pubin -modulus Modulus= A7FCE94593BBCB450E9D06235092F8E7 866E293985A8F867801265383751CF66 3D5DC6FEF4E219BCD1E61CEE1D76C5CE E855C0CB05D1C1C8600606941FA6381D 3F2A330BFCD2A9CB94EA206BBF30D3A7 21B5CE1206EFA2AB72375B5FA3E52803 CEF6BFDD0919948A316156852563ACB0 1A49E62C1AED6642E40617218189CCB3 writing RSA key -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCn/OlFk7vLRQ6dBiNQkvjnhm4p OYWo+GeAEmU4N1HPZj1dxv704hm80eYc7h12xc7oVcDLBdHByGAGBpQfpjgdPyoz C/zSqcuU6iBrvzDTpyG1zhIG76KrcjdbX6PlKAPO9r/dCRmUijFhVoUlY6ywGknm LBrtZkLkBhchgYnMswIDAQAB -----END PUBLIC KEY----- 

El ‘pubin’ le dice a la rsa que se supone que se trata de una clave pública y no se queja de que no es una clave privada.

Ahora tomamos la clave pública de RSA, mostramos el módulo y la transformamos en una simple ‘clave pública’ (de nuevo, tenemos que decirle que la entrada es una clave pública):

 >openssl rsa -in newclient_rsapublickey.pem -RSAPublicKey_in -modulus Modulus= A7FCE94593BBCB450E9D06235092F8E7 866E293985A8F867801265383751CF66 3D5DC6FEF4E219BCD1E61CEE1D76C5CE E855C0CB05D1C1C8600606941FA6381D 3F2A330BFCD2A9CB94EA206BBF30D3A7 21B5CE1206EFA2AB72375B5FA3E52803 CEF6BFDD0919948A316156852563ACB0 1A49E62C1AED6642E40617218189CCB3 writing RSA key -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCn/OlFk7vLRQ6dBiNQkvjnhm4p OYWo+GeAEmU4N1HPZj1dxv704hm80eYc7h12xc7oVcDLBdHByGAGBpQfpjgdPyoz C/zSqcuU6iBrvzDTpyG1zhIG76KrcjdbX6PlKAPO9r/dCRmUijFhVoUlY6ywGknm LBrtZkLkBhchgYnMswIDAQAB -----END PUBLIC KEY----- 

El mismo módulo y el mismo valor de ‘clave pública’ se muestran. Para hacer las cosas más interesantes (para mí, de todos modos), cuando ingresamos la palabra clave RSAPublicKey_out obtenemos:

 >openssl rsa -in newclient_rsapublickey.pem -RSAPublicKey_in -modulus -RSAPublicKey_out Modulus= A7FCE94593BBCB450E9D06235092F8E7 866E293985A8F867801265383751CF66 3D5DC6FEF4E219BCD1E61CEE1D76C5CE E855C0CB05D1C1C8600606941FA6381D 3F2A330BFCD2A9CB94EA206BBF30D3A7 21B5CE1206EFA2AB72375B5FA3E52803 CEF6BFDD0919948A316156852563ACB0 1A49E62C1AED6642E40617218189CCB3 writing RSA key -----BEGIN RSA PUBLIC KEY----- MIGJAoGBAKf86UWTu8tFDp0GI1CS+OeGbik5haj4Z4ASZTg3Uc9mPV3G/vTiGbzR 5hzuHXbFzuhVwMsF0cHIYAYGlB+mOB0/KjML/NKpy5TqIGu/MNOnIbXOEgbvoqty N1tfo+UoA872v90JGZSKMWFWhSVjrLAaSeYsGu1mQuQGFyGBicyzAgMBAAE= -----END RSA PUBLIC KEY----- 

… y cuando transformamos la antigua y simple ‘clave pública’ en una clave pública de RSA:

 >openssl rsa -in newclient_publickey.pem -pubin -RSAPublicKey_out writing RSA key -----BEGIN RSA PUBLIC KEY----- MIGJAoGBAKf86UWTu8tFDp0GI1CS+OeGbik5haj4Z4ASZTg3Uc9mPV3G/vTiGbzR 5hzuHXbFzuhVwMsF0cHIYAYGlB+mOB0/KjML/NKpy5TqIGu/MNOnIbXOEgbvoqty N1tfo+UoA872v90JGZSKMWFWhSVjrLAaSeYsGu1mQuQGFyGBicyzAgMBAAE= -----END RSA PUBLIC KEY----- 

… marchando implacablemente, y aunque acabamos de hacer esto hace unos pocos comandos, para aclarar las cosas, la transmogrificación es de RSA a simple y antigua ‘clave pública’:

 >openssl rsa -in newclient_rsapublickey.pem -RSAPublicKey_in -pubout writing RSA key -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCn/OlFk7vLRQ6dBiNQkvjnhm4p OYWo+GeAEmU4N1HPZj1dxv704hm80eYc7h12xc7oVcDLBdHByGAGBpQfpjgdPyoz C/zSqcuU6iBrvzDTpyG1zhIG76KrcjdbX6PlKAPO9r/dCRmUijFhVoUlY6ywGknm LBrtZkLkBhchgYnMswIDAQAB -----END PUBLIC KEY----- 

… que nos lleva de vuelta al lugar donde comenzamos. ¿Qué hemos aprendido?

Resumen: las claves internas son las mismas, simplemente se ven diferentes. Un comentario anterior señaló que el formato de la clave RSA se definió en PKCS # 1, y el formato antiguo de “clave pública” se definió en PKCS # 8. Sin embargo, editar un formulario no lo convierte en el otro. Espero haber superado esta distinción hasta la muerte.

En caso de que aún nos quede una chispa de vida, volvamos a esto un poco más y hagamos referencia al certificado que se generó originalmente con la clave privada RSA hace mucho tiempo, examinando su clave pública y su módulo:

 >openssl x509 -in newclient_cert.pem -pubkey -noout -modulus -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCn/OlFk7vLRQ6dBiNQkvjnhm4p OYWo+GeAEmU4N1HPZj1dxv704hm80eYc7h12xc7oVcDLBdHByGAGBpQfpjgdPyoz C/zSqcuU6iBrvzDTpyG1zhIG76KrcjdbX6PlKAPO9r/dCRmUijFhVoUlY6ywGknm LBrtZkLkBhchgYnMswIDAQAB -----END PUBLIC KEY----- Modulus= A7FCE94593BBCB450E9D06235092F8E7 866E293985A8F867801265383751CF66 3D5DC6FEF4E219BCD1E61CEE1D76C5CE E855C0CB05D1C1C8600606941FA6381D 3F2A330BFCD2A9CB94EA206BBF30D3A7 21B5CE1206EFA2AB72375B5FA3E52803 CEF6BFDD0919948A316156852563ACB0 1A49E62C1AED6642E40617218189CCB3 

… y todos vivieron felices para siempre: el certificado tiene el mismo valor de módulo que la clave pública RSA, la clave privada RSA y la vieja clave pública simple. El certificado contiene el mismo antiguo valor de “clave pública” que vimos anteriormente, aunque se firmó con un archivo marcado como una clave privada de RSA. Es seguro decir que hay un consenso.

No existe la palabra clave equivalente ‘RSAPublicKey_out’ en el cuadrante X509 de la galaxia OpenSSL, por lo que no podemos intentarlo, aunque el valor del módulo se describe como el “módulo de la clave RSA”, que supongo que es lo más cercano que obtendremos.

Cómo se vería todo esto con un certificado firmado por DSA, no lo sé.

Me doy cuenta de que esto no responde a la pregunta original, pero tal vez proporciona algunos antecedentes útiles. Si no, mis disculpas. Por lo menos, cosas que no se deben hacer y suposiciones que no se deben hacer.

Sin duda, uno ha notado la repetición ligeramente irritante de “escribir la clave RSA”, cuando no está haciendo tal cosa. Supongo que lo que quiere decir es que el módulo rsa reconoce la antigua clave pública simple como una verdadera clave RSA, y es por eso que sigue insistiendo en la “clave RSA” (más es el módulo rsa, después de todo). Si recuerdo correctamente, la estructura genérica EVP_PKEY tiene una unión para todos los tipos de clave, con cada tipo de clave tiene su propio conjunto especial de valores (el útil llamado g, w, q y otras consonantes).

Para concluir, observo que hubo una queja sobre progtwigción y desarrollo; ahora, cada comando de OpenSSL obviamente tiene el código correspondiente, y si uno desea explorar todas las maravillas que es la progtwigción de OpenSSL hoy en día, la línea de comando parecería un lugar razonable para comenzar. En este caso particular (ya que estoy usando un cygwin reciente en este momento) uno podría comenzar por revisar \ openssl-1.0.2f \ apps \ rsa.c y (dado que uno tiene una alta tolerancia para las macros) \ openssl-1.0. 2f \ crypto \ pem \ pem_all.c

La única diferencia entre su pub1 y pub2, además del encabezado / pie de página, es esta cadena adicional en pub2: MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A . Si elimina eso, la Base 64 es idéntica a la de pub1.

La cadena adicional corresponde al identificador del algoritmo de acuerdo con esta Respuesta .

Intereting Posts