Comment puis-je transformer entre les deux styles de format de clé publique, l'un "BEGIN RSA PUBLIC KEY", l'autre est "BEGIN PUBLIC KEY"

Question

Comment puis-je transformer entre les deux styles de format de clé publique, un format est:

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

l'autre format est:

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

par exemple, j'ai généré la paire id_rsa/id_rsa.pub à l'aide de la commande ssh-keygen, j'ai calculé la clé publique à partir de id_rsa en utilisant:

openssl rsa -in id_rsa -pubout -out pub2

là encore, j'ai calculé la clé publique de id_rsa.pub en utilisant:

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

le contenu est pub1 est:

et le contenu de pub2 est:

D'après ce que j'ai compris, pub1 et pub2 contiennent les mêmes informations de clé publique, mais leur format est différent. Je me demande comment puis-je passer d'un format à l'autre? Quelqu'un peut-il me montrer une introduction concise sur les formats de remorquage?

user216741 · Accepted Answer

Utilisation de phpseclib, une pure PHP RSA ...

<?php include('Crypt/RSA.php'); $rsa = new Crypt_RSA(); $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);

Le contenu codé en base64 semble correspondre même si l'en-tête indique BEGIN PUBLIC KEY et non BEGIN RSA PUBLIC KEY. Alors peut-être utilisez-vous simplement str_replace pour résoudre ce problème et vous devriez être prêt à partir!

Ian Boyd · Answer

Je voulais aider à expliquer ce qui se passe ici.

Un RSA "Clé publique" se compose de deux nombres:

le module (par exemple, un nombre de 2 048 bits)
l'exposant (généralement 65 537)

En utilisant votre clé publique RSA comme exemple, les deux chiffres sont les suivants:

Module : 297 056,429,939,040,947,047,334,197,581,225,628,107,021, 573.849.359.042.679.698.093.131.908.015.712.695.688.944.317.630.555.849.768.611.988.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
Exposant : 65 537

La question est alors de savoir comment enregistrer ces chiffres dans un ordinateur. Premièrement, nous convertissons les deux en hexadécimal:

Modulus : EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65
Exposant : 010001

RSA a inventé le premier format

RSA a d'abord inventé un format:

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

Ils ont choisi d'utiliser la variante DER de la norme de codage binaire ASN.1 pour représenter les deux nombres [1] :

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

Le codage binaire final en ASN.1 est le suivant:

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 vous exécutez ensuite tous ces octets ensemble et que Base64 les code, vous obtenez:

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

Les laboratoires RSA ont ensuite ajouté un en-tête et une bande-annonce:

Cinq traits d'union et les mots BEGIN RSA PUBLIC KEY. C’est votre clé publique PEM DER ASN.1 PKCS # 1 RSA

PEM: synonyme de base64
DER: un exemple d'encodage ASN.1
ASN.1: le schéma de codage binaire utilisé
PKCS # 1: spécification formelle qui dicte de représenter une clé publique en tant que structure composée d'un module suivi d'un exposant
RSA public key: l'algorithme de clé publique utilisé

Pas seulement RSA

Après cela, d'autres formes de cryptographie à clé publique sont apparues:

Diffie-Hellman
Courbe Ellicptique

Lorsque le moment est venu de créer un standard sur la manière de représenter les paramètres des algorithmes de cryptage , les utilisateurs ont repris bon nombre des idées que RSA avait définies à l'origine:

utiliser le codage binaire ASN.1
base64 il
envelopper avec cinq traits d'union
et les mots BEGIN PUBLIC KEY

Mais plutôt que d'utiliser:

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

Ils ont plutôt décidé d'inclure l'identificateur d'objet (OID) de ce qui va suivre. Dans le cas d'une clé publique RSA, c'est-à-dire:

RSA PKCS # 1 : 1.2.840.113549.1.1.1

Donc, pour la clé publique RSA, il s’agissait essentiellement:

public struct RSAPublicKey { INTEGER modulus, INTEGER publicExponent }

Maintenant, ils ont créé SubjectPublicKeyInfo qui est essentiellement:

public struct SubjectPublicKeyInfo { AlgorithmIdentifier algorithm, RSAPublicKey subjectPublicKey }

La définition actuelle de DER ASN.1 est la suivante:

SubjectPublicKeyInfo ::= SEQUENCE { algorithm ::= SEQUENCE { algorithm OBJECT IDENTIFIER, -- 1.2.840.113549.1.1.1 rsaEncryption (PKCS#1 1) parameters ANY DEFINED BY algorithm OPTIONAL }, subjectPublicKey BIT STRING { RSAPublicKey ::= SEQUENCE { modulus INTEGER, -- n publicExponent INTEGER -- e } }

Cela vous donne une 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): 0282010100EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65 INTEGER (24 bit): 010001

Le codage binaire final en ASN.1 est le suivant:

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

Et comme auparavant, vous prenez tous ces octets, Base64 les code, vous vous retrouvez avec votre deuxième exemple:

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

Ajoutez l'en-tête et la bande-annonce légèrement différents, et vous obtenez:

Et ceci est votre clé publique X.509 SubjectPublicKeyInfo/OpenSSL PEM [2] .

Faites-le bien, ou piratez-le

Maintenant que vous savez que l'encodage n'est pas magique, vous pouvez écrire toutes les pièces nécessaires à l'analyse du module RSA et de l'exposant. Ou vous pouvez reconnaître que les 24 premiers octets viennent d’être ajoutés à la norme originale 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) | | ...

Et en raison d'une extraordinaire coïncidence de fortune et de bonne chance:

24 octets correspondent exactement à 32 caractères codés en base64

Cela signifie que si vous prenez votre deuxième clé publique X.509 et séparez les 32 premiers caractères:

supprimez les 32 premiers caractères et remplacez-le par BEGIN RSA PUBLIC KEY :

Vous avez exactement ce que vous vouliez.

Vincent Povirk · Answer

J'ai trouvé sur ce site une bonne explication technique des différents formats: https://polarssl.org/kb/cryptography/asn1-key-structures-in-der-and-pem

"DEBUT RSA PUBLIC KEY" est PKCS # 1, qui ne peut contenir que des clés RSA.

"BEGIN PUBLIC KEY" est PKCS # 8, qui peut contenir divers formats.

Si vous voulez simplement les convertir avec la ligne de commande, "openssl rsa" est bon pour cela.

Pour convertir PKCS # 8 en PKCS # 1:

openssl rsa -pubin -in <filename> -RSAPublicKey_out

Pour convertir PKCS # 1 en PKCS # 8:

openssl rsa -RSAPublicKey_in -in <filename> -pubout

Lark · Answer

Bien que les commentaires ci-dessus concernant les en-têtes de 32 octets, OID et autres soient intéressants, je ne vois personnellement pas le même comportement, à supposer que je comprenne le point. Je pensais que cela pourrait être utile. explorez-la plus avant dans ce que la plupart des gens pourraient penser être un détail excessif.

Pour commencer, j'ai créé une clé privée RSA et l'ai vérifiée:

>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, horreurs! J'ai exposé une clé privée. Meh ...)

J'extrais et affiche sa clé publique:

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

Il se trouve qu'il existe un autre paramètre de sortie de clé publique (comme mentionné dans un commentaire précédent). J'extrais et affiche la clé publique en utilisant ce mot clé:

>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. Ces deux valeurs de clé publique ne sont pas les mêmes, bien qu'elles soient dérivées de la même clé privée. Ou sont-ils les mêmes? Je coupe et colle les deux chaînes de clé publique dans leurs propres fichiers, puis effectue une vérification du module sur chacune d'elles:

>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-----

Le 'pubin' indique à rsa que cette est réellement supposée être une clé publique et ne vous plaignez pas du fait que ce n'est pas une clé privée.

Maintenant nous prenons la clé publique RSA, affichons le module et le transmogrifionsons en une ancienne 'clé publique' ordinaire (à nouveau, nous devons lui dire que l'entrée est une clé publique):

>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-----

Même module et même valeur de "clé publique" affichée. Pour rendre les choses plus intéressantes (pour moi, en tout cas), lorsque nous ajoutons le mot-clé RSAPublicKey_out, nous obtenons:

>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-----

... et lorsque nous transmobrifions l'ancienne 'clé publique' ordinaire en une clé publique 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-----

... nous avançons sans relâche, et bien que nous venions de faire cela il y a quelques commandes, nous devons inverser les choses pour que la transmogrification passe de RSA à l'ancienne "clé publique":

>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-----

... qui nous ramène là où nous avons commencé. Qu'avons-nous appris?

Résumé: les clés internes sont les mêmes, elles ont juste un aspect différent. Un commentaire précédent soulignait que le format de clé RSA était défini dans PKCS # 1 et que l'ancien format "clé publique" en clair était défini dans PKCS # 8. Cependant, la modification d'un formulaire ne le transforme pas en un autre. J'espère que j'ai maintenant battu cette distinction à mort.

Au cas où il resterait encore un spark de vie), ajoutons-le un peu plus et référençons le certificat généré à l'origine avec la clé privée RSA il y a si longtemps, en examinant sa clé publique et son module. :

>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

... et ils ont tous vécu heureux: le certificat a la même valeur de module que la clé publique RSA, la clé privée RSA et la vieille clé publique "plaine". Le certificat contient la même vieille valeur de 'clé publique' que celle que nous avons vue précédemment, bien qu'il ait été signé avec un fichier marqué comme clé privée RSA. On peut dire qu'il y a un consensus.

Il n'y a pas de mot clé équivalent 'RSAPublicKey_out' dans le quadrant X509 de la galaxie OpenSSL, nous ne pouvons donc pas essayer, bien que la valeur de module soit décrite comme le "module de clé RSA" qui, je suppose, soit aussi proche que possible.

Je ne sais pas à quoi cela ressemblerait avec un certificat signé par un DSA.

Je me rends compte que cela ne répond pas à la question initiale, mais peut-être que cela fournit des informations utiles. Sinon, mes excuses. À tout le moins, les choses à ne pas faire et les hypothèses à ne pas faire.

Nul doute que l’on a noté la répétition légèrement irritante de "l’écriture de la clé RSA", alors que ce n’est pas le cas. Je suppose que cela signifie que le module rsa reconnaît la vieille clé publique comme une véritable clé RSA, et c’est pourquoi il continue à utiliser la "clé RSA" (il s’agit du module rsa, après tout). Si je me souviens bien, la structure générique EVP_PKEY a une union pour tous les types de clé, chaque type de clé ayant son propre ensemble de valeurs spécial (les noms g, w, q et autres consonnes).

En conclusion, je note qu’il ya eu une plainte concernant la programmation et le développement; maintenant, chaque commande OpenSSL a évidemment le code correspondant, et si on souhaite explorer toutes les merveilles de la programmation OpenSSL aujourd'hui, la ligne de commande semblerait être un endroit raisonnable pour commencer. Dans ce cas particulier (comme je l’utilise pour le moment avec un cygwin récent), on pourrait commencer par passer en revue\openssl-1.0.2f\apps\rsa.c et (étant donné que l’un a une tolérance élevée pour les macros)\openssl-1.0. 2f\crypto\pem\pem_all.c

gtrig · Answer

La seule différence entre votre pub1 et votre pub2, à part l'en-tête/le pied de page, est cette chaîne supplémentaire dans pub2: MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A. Si vous supprimez cela, la Base 64 est identique à celle de pub1.

La chaîne supplémentaire correspond à l'identifiant de l'algorithme selon this Answer .