Quand les nombres utilisés pour dériver la clé privée RSA doivent-ils avoir un préfixe `00` ?

Question

Étant donné une clé privée RSA...

-----BEGIN RSA PRIVATE KEY-----
MIIBOgIBAAJBAMpZrx0gTluJEu6+fop1e60lwbnlBD6kHvoRx85GBhUgD8SQknjc
LcU2qqM/pV9ZX8MV8x49h2mzrmRyH7kDmpcCAwEAAQJAYf2GYMt5Rrids4IKk5CL
IPFs3FH8eT1PRvh/UvP0FBwDMZu/Q4m+3PNTM3ARQhFuCvWgCalMmZkyVx0HYRLe
4QIhAOaaQm+b/bSoHqolvVTcyfBL09rrLFZhgGkETX3R6cVRAiEA4KLdUm97YBxP
T6/jkn/P7K8SUWEO9o9u8Bif1UKQB2cCIETqoSQ92EqfW9q5wKWV/nvkDYKFehCu
vvOjp40MqPKhAiA2sPBZpbLQD5Rvvk8V1/Bzm5xGG+9csEc+RYCEl5QheQIhAKgi
Xb3zY9lqtpX/mgTIrW6RPB3GocviJOibqtpfNxRU
-----END RSA PRIVATE KEY-----

Non blindée, et décodée en base64 donne...

30 82 01 3a 02 01 00 02 41 00 ca 59 af 1d 20 4e 5b 89 12 ee be 7e 8a 75 7b ad 25 c1 b9 e5 04 3e 
a4 1e fa 11 c7 ce 46 06 15 20 0f c4 90 92 78 dc 2d c5 36 aa a3 3f a5 5f 59 5f c3 15 f3 1e 3d 87 
69 b3 ae 64 72 1f b9 03 9a 97 02 03 01 00 01 02 40 61 fd 86 60 cb 79 46 b8 9d b3 82 0a 93 90 8b 
20 f1 6c dc 51 fc 79 3d 4f 46 f8 7f 52 f3 f4 14 1c 03 31 9b bf 43 89 be dc f3 53 33 70 11 42 11 
6e 0a f5 a0 09 a9 4c 99 99 32 57 1d 07 61 12 de e1 02 21 00 e6 9a 42 6f 9b fd b4 a8 1e aa 25 bd 
54 dc c9 f0 4b d3 da eb 2c 56 61 80 69 04 4d 7d d1 e9 c5 51 02 21 00 e0 a2 dd 52 6f 7b 60 1c 4f 
4f af e3 92 7f cf ec af 12 51 61 0e f6 8f 6e f0 18 9f d5 42 90 07 67 02 20 44 ea a1 24 3d d8 4a 
9f 5b da b9 c0 a5 95 fe 7b e4 0d 82 85 7a 10 ae be f3 a3 a7 8d 0c a8 f2 a1 02 20 36 b0 f0 59 a5 
b2 d0 0f 94 6f be 4f 15 d7 f0 73 9b 9c 46 1b ef 5c b0 47 3e 45 80 84 97 94 21 79 02 21 00 a8 22 
5d bd f3 63 d9 6a b6 95 ff 9a 04 c8 ad 6e 91 3c 1d c6 a1 cb e2 24 e8 9b aa da 5f 37 14 54 

J'ai extrait tous les nombres de celui-ci, dans un tableau...

[ '00',
  '00ca59af1d204e5b8912eebe7e8a757bad25c1b9e5043ea41efa11c7ce460615200fc4909278dc2dc536aaa33fa55f595fc315f31e3d8769b3ae64721fb9039a97',
  '010001',
  '61fd8660cb7946b89db3820a93908b20f16cdc51fc793d4f46f87f52f3f4141c03319bbf4389bedcf35333701142116e0af5a009a94c999932571d076112dee1',
  '00e69a426f9bfdb4a81eaa25bd54dcc9f04bd3daeb2c56618069044d7dd1e9c551',
  '00e0a2dd526f7b601c4f4fafe3927fcfecaf1251610ef68f6ef0189fd542900767',
  '44eaa1243dd84a9f5bdab9c0a595fe7be40d82857a10aebef3a3a78d0ca8f2a1',
  '36b0f059a5b2d00f946fbe4f15d7f0739b9c461bef5cb0473e45808497942179',
  '00a8225dbdf363d96ab695ff9a04c8ad6e913c1dc6a1cbe224e89baada5f371454' 
]

Ce que je ne comprends pas, c'est...

1. Pourquoi certaines des valeurs extraites commencent par 00 et d'autres non ?

2. Quel est le but de la première valeur (00) ? Elle me semble redondante.

La raison pour laquelle je veux savoir, c'est que je veux générer des clés RSA en JavaScript. Je génère les nombres requis, mais je ne sais pas quand ils doivent commencer par des 00.

MODIFICATION

Je ne comprends pas non plus la première partie de l'ensemble...

30 82 01 3a

Je comprends que 01 3a est la longueur du reste du message, mais je ne sais pas ce que représente 30 82.

3. Qu'est-ce que 30 82 au début de la clé décodée ?

Answer 1

```html

La plupart des réponses se trouvent ici : http://pumka.net/2009/12/19/reading-writing-and-converting-rsa-keys-in-pem-der-publickeyblob-and-privatekeyblob-formats/

1. Remarquez que de nombreuses valeurs entières en DER commencent par un octet nul. C'est parce que la norme ASN.1 exige d'ajouter un octet nul au début d'un entier multioctet si le premier bit est réglé sur 1.

2. Mis à jour après la réponse de @Gwyn (http://www.regular-expressions.info/conditional.html) Il s'agit du numéro de version, actuellement uniquement pour distinguer multi-premier de normal, mais sera également utilisé pour distinguer entre les révisions de la spécification RSA

3. Depuis : http://msdn.microsoft.com/en-us/library/windows/desktop/bb648645(v=vs.85).aspx Et : http://msdn.microsoft.com/en-us/library/windows/desktop/bb648641(v=vs.85).aspx

Une SÉQUENCE contient un champ ordonné d'un ou plusieurs types. Elle est encodée dans un triplet TLV qui commence par un octet Tag de 0x30.

...

Si la SÉQUENCE contient moins de 128 octets, le champ Longueur du triplet TLV ne nécessite qu'un seul octet pour spécifier la longueur du contenu. S'il y a plus de 127 octets, le bit 7 du champ Longueur est réglé sur 1 et les bits 6 à 0 spécifient le nombre d'octets supplémentaires utilisés pour identifier la longueur du contenu.

Le Code...

Voici le code javascript, un peu rudimentaire, mais une preuve de fonctionnement de la génération des clés RSA, pour être interopérable avec OpenSSL en utilisant javascript, et une entrée des nombres requis pour la génération des clés...

function hex2b64(h) {
  var b64map="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var b64pad="=";

  var i;
  var c;
  var ret = "";
  for(i = 0; i+3 <= h.length; i+=3) {
    c = parseInt(h.substring(i,i+3),16);
    ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63);
  }
  if(i+1 == h.length) {
    c = parseInt(h.substring(i,i+1),16);
    ret += b64map.charAt(c << 2);
  }
  else if(i+2 == h.length) {
    c = parseInt(h.substring(i,i+2),16);
    ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4);
  }
  while((ret.length & 3) > 0) ret += b64pad;
  return ret;
}

var private_key = "-----BEGIN RSA PRIVATE KEY-----\n"+
"MIIBOgIBAAJBAMpZrx0gTluJEu6+fop1e60lwbnlBD6kHvoRx85GBhUgD8SQknjc\n"+
"LcU2qqM/pV9ZX8MV8x49h2mzrmRyH7kDmpcCAwEAAQJAYf2GYMt5Rrids4IKk5CL\n"+
"IPFs3FH8eT1PRvh/UvP0FBwDMZu/Q4m+3PNTM3ARQhFuCvWgCalMmZkyVx0HYRLe\n"+
"4QIhAOaaQm+b/bSoHqolvVTcyfBL09rrLFZhgGkETX3R6cVRAiEA4KLdUm97YBxP\n"+
"T6/jkn/P7K8SUWEO9o9u8Bif1UKQB2cCIETqoSQ92EqfW9q5wKWV/nvkDYKFehCu\n"+
"vvOjp40MqPKhAiA2sPBZpbLQD5Rvvk8V1/Bzm5xGG+9csEc+RYCEl5QheQIhAKgi\n"+
"Xb3zY9lqtpX/mgTIrW6RPB3GocviJOibqtpfNxRU\n"+
"-----END RSA PRIVATE KEY-----";

// ces nombres ont été extraits de la clé privée RSA donnée
numbers = ['00',
  'ca59af1d204e5b8912eebe7e8a757bad25c1b9e5043ea41efa11c7ce460615200fc4909278dc2dc536aaa33fa55f595fc315f31e3d8769b3ae64721fb9039a97',
  '010001',
  '61fd8660cb7946b89db3820a93908b20f16cdc51fc793d4f46f87f52f3f4141c03319bbf4389bedcf35333701142116e0af5a009a94c999932571d076112dee1',
  'e69a426f9bfdb4a81eaa25bd54dcc9f04bd3daeb2c56618069044d7dd1e9c551',
  'e0a2dd526f7b601c4f4fafe3927fcfecaf1251610ef68f6ef0189fd542900767',
  '44eaa1243dd84a9f5bdab9c0a595fe7be40d82857a10aebef3a3a78d0ca8f2a1',
  '36b0f059a5b2d00f946fbe4f15d7f0739b9c461bef5cb0473e45808497942179',
  'a8225dbdf363d96ab695ff9a04c8ad6e913c1dc6a1cbe224e89baada5f371454' ]

var data = ""

// boucler à travers tous les nombres
for(i in numbers){
  var item = numbers[i]

  // si le premier bit binaire est 1 (si le premier couple de chiffres hexadécimaux est supérieur à 127)
  // ajoute un préfixe `00`, comme l'exige ASN1
  if(parseInt(item.match(/^../),16) > 127){ item = "00"+item }

  // calculer la longueur
  var len = ("0"+(item.length/2).toString(16)).replace(/.(..)/,"$1")

  // construire la chaîne de données, le `02` est le code ASN1 pour la chaîne
  data += "02"+len+item

  // peut vérifier toutes les données d'entrée ici
  // console.log("02", len, item)
}

// calculer la longueur de toutes les données
var datalen = (data.length/2).toString(16)
// ajouter un `0` en tête si nécessaire pour assurer les paires hexadécimales
if(datalen.length % 2 == 1){ datalen = "0"+datalen }

// définir les bits supplémentaires pour définir la longueur si nécessaire, ou les rendre vides
var exlen = parseInt(datalen,16) >= 128 ? (datalen.length/2 + 128).toString(16) : ''

// créer la chaîne de données complète
var full_data = "30"+exlen+datalen+data

// encoder les données
var encoded = hex2b64(full_data)

// diviser en lignes ne dépassant pas 64 caractères
var lines = encoded.match(/.{1,64}/g)

// ajouter l'armure
lines.unshift("-----BEGIN RSA PRIVATE KEY-----")
lines.push("-----END RSA PRIVATE KEY-----")

// tout joindre
var generated_key = lines.join("\n")

// vérifier si la clé générée correspond à la clé attendue
console.log(generated_key == private_key)

```

Answer 2

Juste pour répondre à la 2, comme les autres ont été abordés, le premier 00 est un champ de version. Utilisez le décodeur ASN.1 ici pour décoder le Base64 ou l'hexadécimal et afficher une SÉQUENCE de 9 ENTIER. Vous devez vérifier les spécifications (Voir A.1.2) pour voir ce qu'ils sont, bien que, bien que non définitif, Wikipedia a des informations ici