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

Question

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

Demandé el 4 de Août, 2013: Quand la question a-t-elle été
106411 affichage: Nombre de visites la question a
5 Réponses: Nombre de réponses aux questions
Résolu: Situation réelle de la question

Comment puis-je faire la transformation 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 en utilisant la commande ssh-keygen, J'ai calculé la clé publique de id_rsa en utilisant :

openssl rsa -in id_rsa -pubout -out pub2

puis 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 elles sont dans un format différent, je me demande comment je peux transformer entre les deux formats ? Quelqu'un peut-il me montrer une introduction concise sur les deux formats ?

Demandé el 4 de Août, 2013 par welkinwalker

Answer 1

5 Réponses

Answer 2

400voto

Ian Boyd Points 50743

Je voulais aider à expliquer ce qui se passe ici.

Un RSA "Clé publique" est composé 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 :

Modulus : 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
Exposant : 65,537

La question est alors de savoir comment stocker ces chiffres dans un ordinateur. Nous commençons par les convertir en hexadécimal :

Modulus : EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65
Exposant : 010001

RSA a inventé le premier format

RSA a inventé un format en premier :

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

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

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

Le codage binaire final en ASN.1 est :

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 l'on rassemble tous ces octets et qu'on les code en Base64, on obtient :

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

RSA labs a ensuite dit d'ajouter un en-tête et une fin de ligne :

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

PEM : synonyme de base64
DER : une variante de l'encodage ASN.1
ASN.1 : le schéma d'encodage binaire utilisé
PKCS#1 : la spécification formelle qui impose de représenter une clé publique comme une structure composée d'un module suivi d'un exposant.
Clé publique RSA : l'algorithme de clé publique utilisé.

Pas seulement RSA

D'autres formes de cryptographie à clé publique ont ensuite vu le jour :

Diffie-Hellman
Courbe elliptique

Lorsqu'il s'est agi de créer une norme sur la façon de représenter les paramètres de l'industrie de l'aviation ceux les algorithmes de cryptage, les gens ont adopté un grand nombre des mêmes idées que celles définies à l'origine par RSA :

utiliser l'encodage binaire ASN.1
en base64
l'entourer de 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 décidé à la place d'inclure l'identifiant d'objet (OID) de ce qui va suivre. Dans le cas d'une clé publique RSA, c'est :

RSA PKCS#1 : 1.2.840.113549.1.1.1

Donc pour la clé publique RSA, c'était essentiellement :

public struct RSAPublicKey {
   INTEGER modulus,
   INTEGER publicExponent 
}

Maintenant, ils ont créé SubjectPublicKeyInfo qui est en gros :

public struct SubjectPublicKeyInfo {
   AlgorithmIdentifier algorithm,
   RSAPublicKey subjectPublicKey
}

En réalité, la définition ASN.1 de DER 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 un 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): EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65
         INTEGER (24 bit): 010001

Le codage binaire final en ASN.1 est :

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 précédemment, vous prenez tous ces octets, vous les codez en Base64, et vous obtenez votre deuxième exemple :

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

Ajoutez à cela un en-tête et une remorque légèrement différents, et vous obtenez :

Et c'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 tous les éléments nécessaires pour analyser le module et l'exposant RSA. Ou vous pouvez reconnaître que les 24 premiers octets ne sont que des éléments ajoutés à la norme PKCS#1 originale.

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

Ces 24 premiers octets sont "nouveau" des trucs ajoutés :

30 82 01 22 30 0D 06 09 2A 86 48 86 F7 0D 01 01 01 05 00 03 82 01 0F 00

Et grâce à une extraordinaire coïncidence de fortune et de chance :

Il se trouve que 24 octets correspondent exactement à 32 caractères codés en base64

Parce qu'en Base64 : 3 octets deviennent 4 caractères :

30 82 01  22 30 0D  06 09 2A  86 48 86  F7 0D 01  01 01 05  00 03 82  01 0F 00
\______/  \______/  \______/  \______/  \______/  \______/  \______/  \______/
    |         |         |         |         |         |         |         |
  MIIB      IjAN      Bgkq      hkiG      9w0B      AQEF      AAOC      AQ8A

Cela signifie que si vous prenez votre deuxième clé publique X.509, les 32 premiers caractères correspondent uniquement aux éléments nouvellement ajoutés :

Si vous supprimez les 32 premiers caractères, et que vous le changez en COMMENCER LA CLÉ PUBLIQUE RSA :

Vous avez exactement ce que vous vouliez - le plus vieux RSA PUBLIC KEY format.

Répondu el 17 de Avril, 2015 par Ian Boyd (50743 Points )

Answer 3

64voto

Vincent Povirk Points 1487

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

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

"BEGIN PUBLIC KEY" est PKCS#8, qui peut contenir une variété de formats.

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

Pour convertir du PKCS#8 au PKCS#1 :

openssl rsa -pubin -in <filename> -RSAPublicKey_out

Pour convertir du PKCS#1 au PKCS#8 :

openssl rsa -RSAPublicKey_in -in <filename> -pubout

Répondu el 13 de Janvier, 2015 par Vincent Povirk (1487 Points )

Answer 4

16voto

Lark Points 161

Bien que les commentaires ci-dessus concernant les en-têtes de 32 octets, les formats OID et autres soient intéressants, je ne vois personnellement pas le même comportement, en supposant que je comprenne bien. J'ai pensé qu'il pourrait être utile d'approfondir la question dans ce que la plupart des gens pourraient considérer comme un détail excessif. Rien ne dépasse comme l'excès.

Pour commencer, j'ai créé une clé privée RSA, et je 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 y a un autre paramètre de sortie de la clé publique (comme mentionné dans un commentaire précédent). J'extrais et affiche la clé publique en utilisant ce mot-clé à la place :

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

Eh bien, eh 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-elles les mêmes ? Je coupe et colle les deux chaînes de clés publiques dans leurs propres fichiers, puis je fais une vérification du module sur chacune :

>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" dit à rsa que c'est vraiment est est censé être une clé publique, et ne vous plaignez pas que ce n'est pas une clé privée.

Maintenant, nous prenons la clé publique RSA, nous affichons le module et nous la transmogrifions en une bonne vieille "clé publique" (encore une fois, 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 modulus, et même valeur de la 'clé publique' affichée. Pour rendre les choses plus intéressantes (pour moi, en tout cas), lorsque nous ajoutons l'élément RSAPublicKey_out mot-clé que 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 transmogrifions la bonne vieille 'clé publique' 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-----

...qui se poursuivent sans relâche, et bien que nous ayons fait cela il y a quelques commandes, pour illustrer notre propos, nous inversons les choses de sorte que la transmogrification passe de RSA à la bonne vieille "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-----

...ce qui nous ramène à notre point de départ. 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 a souligné que le format de clé RSA a été défini dans PKCS#1, et que le format de clé publique a été défini dans PKCS#8. Cependant, l'édition d'une forme ne la transforme pas en l'autre. J'espère avoir fait le tour de cette distinction.

Au cas où il resterait encore une étincelle de vie, nous allons cependant nous pencher un peu plus sur la question et faire référence au certificat qui a été 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 vécurent tous heureux : le certificat a la même valeur de module que la clé publique RSA, la clé privée RSA et la bonne vieille "clé publique". Le certificat contient la même valeur de "clé publique" que nous avons vue précédemment, bien qu'il ait été signé avec un fichier marqué comme une 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 du module soit décrite comme le "module de la clé RSA", ce qui, je suppose, est aussi proche que possible.

Je ne sais pas comment tout cela se présenterait avec un certificat signé DSA.

Je me rends compte que cela ne répond pas à la question initiale, mais peut-être cela fournit-il un contexte utile. Si ce n'est pas le cas, je m'en excuse. Au moins, des choses à ne pas faire et des suppositions à ne pas faire.

Vous avez sans doute remarqué la répétition un peu irritante de "writing RSA key", alors qu'il ne fait rien de tel. Je suppose que ce que l'on veut dire, c'est que le module rsa reconnaît la bonne vieille clé publique comme une vraie clé RSA, et c'est pourquoi il continue à répéter "RSA key" (de plus, c'est le 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és, avec chaque type de clé ayant son propre ensemble spécial de valeurs (les utilement nommés g, w, q, et autres consonnes).

En conclusion, je note qu'il y avait une plainte concernant la programmation et le développement ; maintenant, chaque commande OpenSSL a évidemment un code correspondant, et si quelqu'un souhaite explorer toutes les merveilles de la programmation OpenSSL aujourd'hui, la ligne de commande semble être un endroit raisonnable pour commencer. Dans ce cas particulier (car j'utilise un cygwin récent en ce moment), on peut commencer par examiner les éléments suivants \openssl -1.0.2f \apps\rsa.c et (si l'on a une grande tolérance pour les macros) \openssl -1.0.2f \crypto\pem\pem_all.c

Répondu el 13 de Octobre, 2016 par Lark (161 Points )

Answer 5

14voto

Utilisateur non enregistré Points 0

Utilisation de phpseclib, une implémentation RSA en PHP ...

<?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);

Les données codées en base64 semblent correspondre, même si l'en-tête indique BEGIN PUBLIC KEY et non BEGIN RSA PUBLIC KEY. Il suffit donc d'utiliser str_replace pour corriger cela et tout devrait bien se passer !

Répondu el 5 de Août, 2013 par Utilisateur non enregistré (0 Points )

Answer 6

10voto

gtrig Points 3127

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

La chaîne supplémentaire correspond à l'identifiant de l'algorithme selon cette réponse .

Répondu el 6 de Août, 2013 par gtrig (3127 Points )

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

Réponses

RSA a inventé le premier format

Pas seulement RSA

Faites-le bien, ou piratez-le

Questions en vedette

Top Tags

Prograide.com

Powered by:

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

Réponses

RSA a inventé le premier format

Pas seulement RSA

Faites-le bien, ou piratez-le

Questions en vedette

Top Tags

Dans notre réseau

Prograide.com

Powered by: