Taille de la clé publique Diffie Hellman à courbe elliptique

Question

Je veux utiliser Diffie Hellman pour générer une clé secrète entre un serveur c# et un client c++. Ce code génère une clé publique pour le serveur :

        serverECDH = new ECDiffieHellmanCng(ECCurve.NamedCurves.nistP256);
        serverECDH.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
        serverECDH.HashAlgorithm = CngAlgorithm.Sha256; 
        ECDHPublicKey =Convert.ToBase64String(serverECDH.PublicKey.ToByteArray());
        Console.WriteLine(serverECDH.KeySize); //256
        Console.WriteLine(serverECDH.PublicKey.ToByteArray().Length); //72
        Console.WriteLine(ECDHPublicKey);

Je me demande pourquoi la taille du tableau d'octets de publicKey est de 72 alors que je m'attends à un tableau de 64 octets ? En outre, voici ma mise en œuvre pour générer une clé publique dans le client :

if (NULL == (pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))) HandleErrors(1);
if (1 != EVP_PKEY_paramgen_init(pctx)) HandleErrors(2);
if (1 != EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_X9_62_prime256v1)) HandleErrors(3);

if (!EVP_PKEY_paramgen(pctx, &params)) HandleErrors(4);
if (NULL == (kctx = EVP_PKEY_CTX_new(params, NULL))) HandleErrors(5);

if (1 != EVP_PKEY_keygen_init(kctx)) HandleErrors(6);
if (1 != EVP_PKEY_keygen(kctx, &pkey)) HandleErrors(7);

bio = BIO_new(BIO_s_mem());
PEM_write_bio_PUBKEY(bio, pkey);
int publicKeyLen = BIO_pending(bio);
cout << publicKeyLen << endl;
unsigned char* publicKeyChar = (unsigned char*)malloc(publicKeyLen);
BIO_read(bio, publicKeyChar, publicKeyLen);

ECDHPublicKey =  string(reinterpret_cast<char const*>(publicKeyChar),publicKeyLen);
cout << ECDHPublicKey << endl;

dans ce code, la longueur de la clé publique est de 128 byte(Characters ?) ce qui est encore étrange car je spécifie la courbe NID_X9_62_prime256v1. où est mon erreur ? d'ailleurs est-ce que NID_X9_62_prime256v1 et nistP256 correspondent en c++ et c# ?

EDIT : voici un exemple de sortie de cout << ECDHPublicKey << endl :

-----BEGIN PUBLIC KEY----- MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUFD9ZNby6x2bf/VC16/NHSxIXdit Ips60uLoi0/jKmbmMHRg2xbXVVzV8Uc1DElMlZA817bMFCnVvi1VsM5JYg==

-----END PUBLIC KEY-----

Answer 1

Dans le code C++, cette clé publique n'est pas seulement codée en DER, mais aussi en PEM. Cela ajoute un en-tête et un pied de page autour de la clé publique. base 64 structure DER encodée. Le PEM est utilisé pour les interfaces textuelles où les données binaires peuvent être déformées. C'est pourquoi il est aussi parfois appelé "armure ASCII" (ou "armure ASCII" selon votre dialecte).

Si vous voulez jeter un coup d'œil aux structures du code C++ / OpenSSL, il suffit de coller la structure DER encodée en base 64 dans le fichier ce site ou utiliser openssl asn1parse .

---

La structure Mickeysoft renvoyée par serverECDH.PublicKey.ToByteArray() semble consister en "ECK1" + 20 00 00 00 suivi des deux coordonnées codées de taille statique (qui peuvent être big ou little endian). ECK1 est probablement le format de clé à courbe elliptique 1 - quel qu'il soit - et 20 00 00 00 est probablement la taille de la clé / des coordonnées en octets comme 32 * 8 = 256. Notez que le C# utilise officiellement l'endianement de la plate-forme, de sorte que l'endianement de la clé est de 32 * 8 = 256. 20 00 00 00 est une valeur 32 bits little endian. Vous avez probablement besoin d'une bibliothèque externe pour encoder leurs clés afin que tout autre runtime puisse les comprendre.

---

Pour ce qui est de votre question : oui, la courbe ANS(I) X9.62 prime256r1 est identique à la courbe NIST P-256 et secp256r1 telle qu'elle a été définie à l'origine (je pense) par Certicom corp. La courbe a d'abord été définie, puis reprise et normalisée par diverses organisations.