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 1

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

puis à nouveau, j'ai calculé la clé publique à partir 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:

Selon ma compréhension, pub1 et pub2 contiennent les mêmes informations de clé publique, mais ils sont dans un format différent, je me demande comment puis-je transformer entre les deux formats? Quelqu'un peut-il me montrer une introduction concise sur les formats de remorquage?

Question 2

Utilisation de phpseclib, une implémentation pure de 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);

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

Question 3

Je voulais aider à expliquer ce qui se passe ici.

Une «clé publique» RSA se compose de deux nombres:

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

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

Module : 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 devient alors comment voulons-nous stocker ces nombres dans un ordinateur. Nous convertissons d'abord les deux en hexadécimal:

Modulus : EB506399F5C612F5A67A09C1192B92FAB53DB28520D859CE0EF6B7D83D40AA1C1DCE2C0720D15A0F531595CAD81BA5D129F91CC6769719F1435872C4BCD0521150A0263B470066489B918BFCA03CE8A0E9FC2C0314C4B096EA30717C03C28CA29E678E63D78ACA1E9A63BDB1261EE7A0B041AB53746D68B57B68BEF37B71382838C95DA8557841A3CA58109F0B4F77A5E929B1A25DC2D6814C55DC0F81CD2F4E5DB95EE70C706FC02C4FCA358EA9A82D8043A47611195580F89458E3DAB5592DEFE06CDE1E516A6C61ED78C13977AE9660A9192CA75CD72967FD3AFAFA1F1A2FF6325A5064D847028F1E6B2329E8572F36E708A549DDA355FC74A32FDD8DBA65
Exponent : 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 saveur DER du standard de codage 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 vous exécutez ensuite tous ces octets ensemble et que vous l'encodez en Base64, vous obtenez:

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

Les laboratoires RSA ont alors dit d'ajouter 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: une saveur d'encodage ASN.1
ASN.1: le schéma de codage binaire utilisé
PKCS # 1: La spécification formelle qui dicte la représentation d'une clé publique sous la forme d'une structure constituée d'un module suivi d'un exposant
Clé publique RSA: 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

Quand est venu le temps de créer une norme sur la façon de représenter les paramètres de ces algorithmes de chiffrement, les gens ont adopté beaucoup des mêmes idées que RSA avait définies à l'origine:

utiliser le codage binaire ASN.1
base64 il
enveloppez-le 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 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, c'était essentiellement:

public struct RSAPublicKey {
   INTEGER modulus,
   INTEGER publicExponent 
}

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

public struct SubjectPublicKeyInfo {
   AlgorithmIdentifier algorithm,
   RSAPublicKey subjectPublicKey
}

En réalité, la définition DER ASN.1 est:

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 avant, vous prenez tous ces octets, vous les encodez en Base64, 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 pour analyser le module et l'exposant RSA. Ou vous pouvez reconnaître que les 24 premiers octets sont juste ajoutés de nouveaux éléments en plus de la norme PKCS # 1 d'origine

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 des "nouveaux" éléments 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 en raison d'une extraordinaire coïncidence de fortune et de chance:

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

Parce qu'en Base64: 3 octets devient quatre 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 les remplacez par BEGIN RSA PUBLIC KEY :

Vous avez exactement ce que vous vouliez - l'ancien RSA PUBLIC KEYformat.

Question 4

J'ai trouvé que ce site Web était 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 de PKCS # 8 à PKCS # 1:

openssl rsa -pubin -in <filename> -RSAPublicKey_out

Pour convertir de PKCS # 1 à PKCS # 8:

openssl rsa -RSAPublicKey_in -in <filename> -pubout

Question 5

Bien que les commentaires ci-dessus concernant les en-têtes 32 octets, les formats OID et autres soient intéressants, je ne vois personnellement pas le même comportement, en supposant que je comprends le point. J'ai pensé qu'il pourrait être utile d'explorer cela plus avant dans ce que la plupart pourraient penser être des détails excessifs. Rien ne dépasse comme l'excès.

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 dévoilé une clé privée. Meh ...)

J'extrait 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é à 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-----

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 je vérifie le 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 ce vraiment est censé être une clé publique, et ne se plaignent pas que ce n'est pas une clé privée.

Maintenant, nous prenons la clé publique RSA, affichons le module et la transmogrifions en une ancienne `` 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 module, et même valeur de «clé publique» affichée. Pour rendre les choses plus intéressantes (pour moi, en tout cas), lorsque nous cliquons sur 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 transmogrifions l'ancienne `` 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-----

... marchant sans relâche, et bien que nous venons de le faire il y a quelques commandes, pour faire comprendre, nous inversons les choses afin que la transmogrification passe du RSA à la simple `` 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 là où nous avons commencé. Qu'avons-nous appris?

Résumé: les touches en interne sont les mêmes, elles sont simplement différentes. Un commentaire précédent a souligné que le format de clé RSA a été défini dans PKCS # 1, et l'ancien format de «clé publique» a été défini dans PKCS # 8. Cependant, modifier 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 une étincelle de vie, fouettons-la un peu plus et référençons le 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 ont tous vécu heureux pour toujours: le certificat a la même valeur de module que la clé publique RSA, la clé privée RSA et la vieille «clé publique». Le certificat contient la même ancienne valeur de «clé publique» que nous avons vue précédemment, bien qu'il ait été signé avec un fichier marqué comme clé privée RSA. Il est prudent de 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, donc nous ne pouvons pas essayer cela, bien que la valeur du module soit décrite comme le "module de clé RSA" qui, je suppose, est aussi proche que nous obtiendrons.

À quoi tout cela ressemblerait avec un certificat signé DSA, je ne sais pas.

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, des choses à ne pas faire et des suppositions à 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", quand on ne fait rien de tel. Je suppose que ce que cela signifie, c'est que le module rsa reconnaît l'ancienne clé publique comme une vraie clé RSA, et c'est pourquoi il continue à insister sur la "clé RSA" (en 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, chaque type de clé ayant son propre ensemble spécial de valeurs (les g, w, q et autres consonnes).

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

Question 6

La seule différence entre votre pub1 et pub2, en plus de l' en- tête / pied de page, est cette chaîne supplémentaire 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 cette réponse .