{"id":296,"date":"2026-06-20T20:41:39","date_gmt":"2026-06-20T20:41:39","guid":{"rendered":"https:\/\/shattered.io\/fr\/2026\/06\/20\/ecdsa-ed25519-nodejs\/"},"modified":"2026-06-20T20:41:39","modified_gmt":"2026-06-20T20:41:39","slug":"ecdsa-ed25519-nodejs","status":"publish","type":"post","link":"https:\/\/shattered.io\/fr\/2026\/06\/20\/ecdsa-ed25519-nodejs\/","title":{"rendered":"ECDSA et Ed25519 dans Node.js : 12 \u00c9tapes [2026]"},"content":{"rendered":"\n

Le module crypto<\/code> de Node.js 22 prend en charge ECDSA et Ed25519 nativement, sans aucune d\u00e9pendance externe. Une cl\u00e9 ECDSA P-256 offre le m\u00eame niveau de s\u00e9curit\u00e9 qu’une cl\u00e9 RSA de 3 072 bits, avec une taille 12 fois plus petite. Ed25519 g\u00e9n\u00e8re environ 120 000 signatures par seconde contre 2 000 pour RSA-2048, soit un facteur 60. Ce tutoriel construit pas \u00e0 pas un service de signature num\u00e9rique complet, de la g\u00e9n\u00e9ration des cl\u00e9s jusqu’au d\u00e9ploiement d’une API REST s\u00e9curis\u00e9e.<\/p>\n\n\n\n

Pourquoi ECDSA et Ed25519 supplantent RSA en 2026<\/h2>\n\n\n\n

RSA a domin\u00e9 la cryptographie asym\u00e9trique pendant 45 ans. En 2026, il reste pr\u00e9sent dans les syst\u00e8mes legacy, mais trois tendances l’ont contraint \u00e0 reculer. TLS 1.3 (RFC 8446) a supprim\u00e9 les suites de chiffrement RSA sans forward secrecy. GitHub exige depuis 2022 les cl\u00e9s Ed25519 pour les nouveaux comptes SSH. Le standard FIDO2\/WebAuthn utilise ECDSA P-256 comme algorithme primaire pour l’authentification sans mot de passe.<\/p>\n\n\n\n

La cryptographie sur courbes elliptiques (ECC) repose sur un probl\u00e8me math\u00e9matique distinct du factoring RSA : le probl\u00e8me du logarithme discret sur une courbe elliptique (ECDLP). Aucun algorithme classique connu ne r\u00e9sout ce probl\u00e8me en temps polynomial pour les courbes standardis\u00e9es. Une cl\u00e9 ECC de 256 bits offre 128 bits de s\u00e9curit\u00e9, identique \u00e0 RSA-3072 avec une taille 12 fois inf\u00e9rieure. Selon le rapport NIST SP 800-57 mis \u00e0 jour en 2025, RSA-2048 fournit seulement 112 bits de s\u00e9curit\u00e9 et devra \u00eatre retir\u00e9 des syst\u00e8mes f\u00e9d\u00e9raux am\u00e9ricains d’ici 2030.<\/p>\n\n\n\n

Algorithme<\/th>Taille de cl\u00e9<\/th>S\u00e9curit\u00e9 (bits)<\/th>Signatures\/s (Intel Xeon)<\/th>Cas d’usage typique<\/th><\/tr><\/thead>
RSA-2048<\/td>2 048 bits<\/td>112 bits<\/td>~2 000<\/td>Legacy TLS, PGP ancien<\/td><\/tr>
RSA-4096<\/td>4 096 bits<\/td>140 bits<\/td>~400<\/td>Certificats CA racine<\/td><\/tr>
ECDSA P-256<\/td>256 bits<\/td>128 bits<\/td>~35 000<\/td>TLS 1.3, JWT, FIDO2, code signing<\/td><\/tr>
ECDSA P-384<\/td>384 bits<\/td>192 bits<\/td>~18 000<\/td>Secteur d\u00e9fense, gouvernement<\/td><\/tr>
Ed25519<\/strong><\/td>256 bits<\/td>128 bits<\/td>~120 000<\/td>SSH, WireGuard, GPG, npm provenance<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

ECDSA (Elliptic Curve Digital Signature Algorithm) et EdDSA (Edwards-curve Digital Signature Algorithm) sont deux familles distinctes. ECDSA P-256 utilise la courbe NIST P-256 (aussi appel\u00e9e secp256r1 ou prime256v1) et produit des signatures DER encod\u00e9es. Ed25519 utilise la courbe Edwards Curve 25519 con\u00e7ue par Daniel Bernstein, avec une r\u00e9sistance prouv\u00e9e contre les attaques par canaux auxiliaires. Le standard RFC 8032<\/a> d\u00e9finit Ed25519 comme une impl\u00e9mentation EdDSA sur Curve25519 avec SHA-512. Ces deux algorithmes sont d\u00e9sormais recommand\u00e9s par l’ANSSI pour les applications civiles fran\u00e7aises, tandis que P-384 reste requis pour les informations classifi\u00e9es.<\/p>\n\n\n\n

Pr\u00e9requis<\/h2>\n\n\n\n

Ce tutoriel requiert un environnement \u00e0 jour. Aucune biblioth\u00e8que externe n’est n\u00e9cessaire pour les 10 premi\u00e8res \u00e9tapes : Node.js int\u00e8gre OpenSSL 3.x depuis la version 18. Express est utilis\u00e9 uniquement pour le service REST de l’\u00e9tape 11.<\/p>\n\n\n\n

Composant<\/th>Version minimale<\/th>Version recommand\u00e9e<\/th>V\u00e9rification<\/th><\/tr><\/thead>
Node.js<\/td>18.0.0<\/td>22.14.x LTS<\/td>node --version<\/code><\/td><\/tr>
npm<\/td>9.0.0<\/td>10.9.x<\/td>npm --version<\/code><\/td><\/tr>
OpenSSL (inclus)<\/td>1.1.1<\/td>3.0.x<\/td>node -e \"console.log(process.versions.openssl)\"<\/code><\/td><\/tr>
Express (optionnel)<\/td>4.18.x<\/td>5.x<\/td>npm list express<\/code><\/td><\/tr>
Connaissances<\/td>Hash cryptographique<\/td>Bases crypto asym\u00e9trique<\/td>Voir articles pr\u00e9requis ci-dessous<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Pour consolider les bases th\u00e9oriques avant de commencer, lire les articles Signatures num\u00e9riques : comment le hachage et les cl\u00e9s garantissent l’authenticit\u00e9<\/a> et HMAC-SHA256 en Node.js : signer une API en 12 \u00e9tapes [2026]<\/a>.<\/p>\n\n\n\n

\u00c9tape 1 : Initialiser le projet<\/h2>\n\n\n\n

Cr\u00e9er la structure de r\u00e9pertoires et initialiser le projet npm. L’ensemble de l’\u00e9tapes 1 \u00e0 10 n’utilise que le module crypto<\/code> int\u00e9gr\u00e9 \u00e0 Node.js. Express est ajout\u00e9 en option pour le service REST de l’\u00e9tape 11.<\/p>\n\n\n\n

mkdir ecdsa-ed25519-tutorial\ncd ecdsa-ed25519-tutorial\nnpm init -y\nmkdir keys scripts\n\n# Optionnel : installer Express pour le service REST (\u00e9tape 11)\nnpm install express\n\n# V\u00e9rifier la version d'OpenSSL et les courbes disponibles\nnode -e \"const c = require('crypto'); console.log('OpenSSL:', process.versions.openssl); console.log('Courbes P-256:', c.getCurves().filter(x => x.includes('256')))\"<\/code><\/pre>\n\n\n\n
Sortie attendue :<\/p>\n\n\n\n
OpenSSL: 3.0.15\nCourbes P-256: [ 'prime256v1', 'secp256r1' ]<\/code><\/pre>\n\n\n\n
Point de contr\u00f4le :<\/strong> Si la sortie ne contient pas prime256v1<\/code>, Node.js a \u00e9t\u00e9 compil\u00e9 sans support ECC complet. Mettre \u00e0 jour vers Node.js 22 LTS via nvm install 22<\/code>.<\/p>\n\n\n\n
\u00c9tape 2 : Comprendre ECDSA et EdDSA avant d’\u00e9crire du code<\/h2>\n\n\n\n
Deux familles de courbes elliptiques sont utilis\u00e9es dans ce tutoriel, et leurs diff\u00e9rences techniques ont des cons\u00e9quences directes sur l’API Node.js.<\/p>\n\n\n\n
NIST P-256 (secp256r1 \/ prime256v1) :<\/strong> Courbe de Weierstrass approuv\u00e9e dans FIPS 186-5<\/a>. Les signatures ECDSA produites sur P-256 sont encod\u00e9es au format DER (ASN.1 binaire), de taille variable entre 70 et 72 octets. Chaque signature ECDSA n\u00e9cessite un nonce al\u00e9atoire k unique. Si k est r\u00e9utilis\u00e9 pour deux signatures diff\u00e9rentes avec la m\u00eame cl\u00e9 priv\u00e9e, la cl\u00e9 priv\u00e9e peut \u00eatre reconstitu\u00e9e math\u00e9matiquement (la PlayStation 3 de Sony a \u00e9t\u00e9 compromise de cette fa\u00e7on en 2010). Node.js utilise OpenSSL pour g\u00e9n\u00e9rer des k s\u00e9curis\u00e9s.<\/p>\n\n\n\n
Curve25519 \/ Ed25519 :<\/strong> Courbe tordue d’Edwards con\u00e7ue par Daniel Bernstein en 2006. Ed25519 est l’algorithme de signature EdDSA sur cette courbe, avec SHA-512 int\u00e9gr\u00e9. Les signatures font toujours exactement 64 octets. Ed25519 est r\u00e9sistant par construction aux attaques par canaux auxiliaires (timing attacks) car les op\u00e9rations ne d\u00e9pendent pas de donn\u00e9es secr\u00e8tes. Diff\u00e9rence critique dans l’API Node.js : ECDSA requiert de sp\u00e9cifier l’algorithme de hachage ('SHA256'<\/code>), tandis qu’Ed25519 le g\u00e8re en interne et re\u00e7oit null<\/code> comme algorithme.<\/p>\n\n\n\n
Note importante :<\/strong> Ne pas confondre P-256 (secp256r1, NIST) avec secp256k1 (courbe Koblitz utilis\u00e9e par Bitcoin et Ethereum). Ce sont deux courbes distinctes avec des param\u00e8tres diff\u00e9rents. namedCurve: 'P-256'<\/code> et namedCurve: 'prime256v1'<\/code> d\u00e9signent la m\u00eame courbe NIST. namedCurve: 'secp256k1'<\/code> est diff\u00e9rente et ne convient pas pour TLS ou JWT.<\/p>\n\n\n\n
\u00c9tape 3 : G\u00e9n\u00e9rer une paire de cl\u00e9s ECDSA P-256<\/h2>\n\n\n\n
La g\u00e9n\u00e9ration utilise crypto.generateKeyPairSync()<\/code> avec le type 'ec'<\/code>. La cl\u00e9 priv\u00e9e doit toujours \u00eatre chiffr\u00e9e avec AES-256-CBC et une passphrase robuste avant d’\u00eatre persist\u00e9e sur disque.<\/p>\n\n\n\n
\/\/ scripts\/generate-ecdsa.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nfunction generateECDSAKeyPair(passphrase) {\n  const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', {\n    namedCurve: 'P-256',                    \/\/ NIST P-256 = secp256r1 = prime256v1\n    publicKeyEncoding: {\n      type: 'spki',                          \/\/ SubjectPublicKeyInfo (standard X.509)\n      format: 'pem'\n    },\n    privateKeyEncoding: {\n      type: 'pkcs8',                         \/\/ PKCS#8 PrivateKeyInfo\n      format: 'pem',\n      cipher: 'aes-256-cbc',               \/\/ Chiffrement de la cl\u00e9 priv\u00e9e\n      passphrase: passphrase\n    }\n  });\n  return { privateKey, publicKey };\n}\n\nconst PASSPHRASE = process.env.KEY_PASSPHRASE;\nif (!PASSPHRASE) {\n  console.error('Erreur : d\u00e9finir la variable KEY_PASSPHRASE avant de g\u00e9n\u00e9rer les cl\u00e9s');\n  process.exit(1);\n}\n\nconst { privateKey, publicKey } = generateECDSAKeyPair(PASSPHRASE);\n\nconst keysDir = path.join(__dirname, '..', 'keys');\nfs.mkdirSync(keysDir, { recursive: true });\n\nfs.writeFileSync(path.join(keysDir, 'ecdsa-private.pem'), privateKey, { mode: 0o600 });\nfs.writeFileSync(path.join(keysDir, 'ecdsa-public.pem'), publicKey, { mode: 0o644 });\n\nconsole.log('Cl\u00e9s ECDSA P-256 g\u00e9n\u00e9r\u00e9es avec succ\u00e8s');\nconsole.log('\\nCl\u00e9 publique (\u00e0 distribuer librement) :');\nconsole.log(publicKey);\nconsole.log('Taille cl\u00e9 publique PEM :', publicKey.length, 'caract\u00e8res (~119 octets encod\u00e9s)');<\/code><\/pre>\n\n\n\n
Ex\u00e9cuter avec :<\/p>\n\n\n\n
KEY_PASSPHRASE=mon-secret-fort node scripts\/generate-ecdsa.js\n\n# Sortie attendue :\nCl\u00e9s ECDSA P-256 g\u00e9n\u00e9r\u00e9es avec succ\u00e8s\n\nCl\u00e9 publique (\u00e0 distribuer librement) :\n-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3h7U...\n-----END PUBLIC KEY-----\nTaille cl\u00e9 publique PEM : 178 caract\u00e8res (~119 octets encod\u00e9s)<\/code><\/pre>\n\n\n\n
Une cl\u00e9 publique ECDSA P-256 en PEM repr\u00e9sente 65 octets de donn\u00e9es brutes (1 octet de type + 32 octets x + 32 octets y), contre 294 octets pour RSA-2048. La cl\u00e9 priv\u00e9e chiffr\u00e9e AES-256-CBC fait environ 365 octets.<\/p>\n\n\n\n
\u00c9tape 4 : Signer des donn\u00e9es avec ECDSA<\/h2>\n\n\n\n
La signature utilise crypto.sign()<\/code>, disponible depuis Node.js 12. La fonction prend l’algorithme de hachage, les donn\u00e9es en Buffer, et la cl\u00e9 priv\u00e9e. Elle retourne la signature au format DER binaire.<\/p>\n\n\n\n
\/\/ scripts\/sign-ecdsa.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nfunction signWithECDSA(data, privateKeyPem, passphrase) {\n  \/\/ D\u00e9chiffrer la cl\u00e9 priv\u00e9e prot\u00e9g\u00e9e\n  const privateKeyObject = crypto.createPrivateKey({\n    key: privateKeyPem,\n    format: 'pem',\n    passphrase: passphrase\n  });\n\n  \/\/ Signer : SHA-256 + ECDSA P-256 = algorithme ES256 (nomenclature JWT)\n  const signature = crypto.sign('SHA256', Buffer.from(data, 'utf8'), privateKeyObject);\n\n  \/\/ Retourner en Base64 pour un transport JSON-friendly\n  return signature.toString('base64');\n}\n\nconst keysDir = path.join(__dirname, '..', 'keys');\nconst privateKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-private.pem'), 'utf8');\nconst PASSPHRASE = process.env.KEY_PASSPHRASE;\n\nconst message = 'Contrat sign\u00e9 \u00e9lectroniquement le 20 juin 2026';\nconst signature = signWithECDSA(message, privateKeyPem, PASSPHRASE);\n\nconsole.log('Message :', message);\nconsole.log('Signature ECDSA (Base64) :', signature);\nconsole.log('Longueur brute :', Buffer.from(signature, 'base64').length, 'octets (DER, variable 70-72)');<\/code><\/pre>\n\n\n\n
Sortie attendue :<\/p>\n\n\n\n
Message : Contrat sign\u00e9 \u00e9lectroniquement le 20 juin 2026\nSignature ECDSA (Base64) : MEYCIQDy8n...+3A==\nLongueur brute : 72 octets (DER, variable 70-72)<\/code><\/pre>\n\n\n\n
Particularit\u00e9 ECDSA :<\/strong> La signature DER encode les entiers r et s avec un pr\u00e9fixe de longueur variable. La taille oscille entre 70 et 72 octets selon si r ou s ont leur bit de poids fort \u00e0 1 (n\u00e9cessitant un octet de padding 0x00). Cette variabilit\u00e9 pose probl\u00e8me pour les JWT, qui exigent le format P1363 (r||s concat\u00e9n\u00e9s, 64 octets fixes, voir \u00e9tape 8).<\/p>\n\n\n\n
\u00c9tape 5 : V\u00e9rifier une signature ECDSA<\/h2>\n\n\n\n
La v\u00e9rification utilise crypto.verify()<\/code> avec la cl\u00e9 publique. Contrairement \u00e0 la cl\u00e9 priv\u00e9e, la cl\u00e9 publique peut \u00eatre distribu\u00e9e librement et sans passphrase. Elle ne donne aucune capacit\u00e9 \u00e0 signer, uniquement \u00e0 v\u00e9rifier.<\/p>\n\n\n\n
\/\/ scripts\/verify-ecdsa.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nfunction verifyECDSA(data, signatureBase64, publicKeyPem) {\n  try {\n    return crypto.verify(\n      'SHA256',\n      Buffer.from(data, 'utf8'),\n      publicKeyPem,\n      Buffer.from(signatureBase64, 'base64')\n    );\n  } catch {\n    return false;  \/\/ Signature malform\u00e9e ou cl\u00e9 incompatible\n  }\n}\n\nconst keysDir = path.join(__dirname, '..', 'keys');\nconst privateKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-private.pem'), 'utf8');\nconst publicKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-public.pem'), 'utf8');\nconst PASSPHRASE = process.env.KEY_PASSPHRASE;\n\nconst message = 'Contrat sign\u00e9 \u00e9lectroniquement le 20 juin 2026';\nconst privateKey = crypto.createPrivateKey({ key: privateKeyPem, passphrase: PASSPHRASE });\nconst signature = crypto.sign('SHA256', Buffer.from(message), privateKey).toString('base64');\n\n\/\/ Test 1 : message non alt\u00e9r\u00e9\nconsole.log('V\u00e9rification (original) :', verifyECDSA(message, signature, publicKeyPem)); \/\/ true\n\n\/\/ Test 2 : message alt\u00e9r\u00e9 d'un seul caract\u00e8re\nconsole.log('V\u00e9rification (alt\u00e9r\u00e9) :', verifyECDSA(message + '.', signature, publicKeyPem)); \/\/ false\n\n\/\/ Test 3 : signature corrompue\nconst corruptedSig = signature.slice(0, -4) + 'AAAA';\nconsole.log('V\u00e9rification (signature corrompue) :', verifyECDSA(message, corruptedSig, publicKeyPem)); \/\/ false<\/code><\/pre>\n\n\n\n
Sortie attendue :<\/p>\n\n\n\n
V\u00e9rification (original) : true\nV\u00e9rification (alt\u00e9r\u00e9) : false\nV\u00e9rification (signature corrompue) : false<\/code><\/pre>\n\n\n\n
\u00c9tape 6 : G\u00e9n\u00e9rer une paire de cl\u00e9s Ed25519<\/h2>\n\n\n\n
Ed25519 utilise le type 'ed25519'<\/code> dans generateKeyPairSync()<\/code>. La cl\u00e9 priv\u00e9e Ed25519 fait 32 octets (encod\u00e9e en 64 octets en PKCS#8 PEM). La cl\u00e9 publique fait 32 octets. Une limitation importante : Node.js ne supporte pas le chiffrement natif de la cl\u00e9 priv\u00e9e Ed25519 via l’option cipher<\/code>, contrairement \u00e0 ECDSA.<\/p>\n\n\n\n
\/\/ scripts\/generate-ed25519.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nfunction generateEd25519KeyPair() {\n  const { privateKey, publicKey } = crypto.generateKeyPairSync('ed25519', {\n    publicKeyEncoding: {\n      type: 'spki',\n      format: 'pem'\n    },\n    privateKeyEncoding: {\n      type: 'pkcs8',\n      format: 'pem'\n      \/\/ Pas de cipher pour Ed25519 en Node.js (limitation OpenSSL)\n      \/\/ Utiliser HashiCorp Vault, AWS Secrets Manager, ou GPG pour prot\u00e9ger ce fichier\n    }\n  });\n  return { privateKey, publicKey };\n}\n\nconst { privateKey, publicKey } = generateEd25519KeyPair();\nconst keysDir = path.join(__dirname, '..', 'keys');\n\nfs.writeFileSync(path.join(keysDir, 'ed25519-private.pem'), privateKey, { mode: 0o600 });\nfs.writeFileSync(path.join(keysDir, 'ed25519-public.pem'), publicKey, { mode: 0o644 });\n\nconsole.log('Cl\u00e9s Ed25519 g\u00e9n\u00e9r\u00e9es avec succ\u00e8s');\nconsole.log('Taille cl\u00e9 publique PEM :', publicKey.length, 'caract\u00e8res (32 octets bruts)');\nconsole.log('\\nCl\u00e9 publique Ed25519 :');\nconsole.log(publicKey);<\/code><\/pre>\n\n\n\n
Sortie attendue :<\/p>\n\n\n\n
Cl\u00e9s Ed25519 g\u00e9n\u00e9r\u00e9es avec succ\u00e8s\nTaille cl\u00e9 publique PEM : 119 caract\u00e8res (32 octets bruts)\n\nCl\u00e9 publique Ed25519 :\n-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA...\n-----END PUBLIC KEY-----<\/code><\/pre>\n\n\n\n
La cl\u00e9 publique Ed25519 fait 32 octets bruts contre 65 pour ECDSA P-256 et 256 pour RSA-2048. Cette compacit\u00e9 a un impact mesurable sur la taille des tokens JWT et des paquets r\u00e9seau dans les protocoles haute fr\u00e9quence.<\/p>\n\n\n\n
\u00c9tape 7 : Signer et v\u00e9rifier avec Ed25519<\/h2>\n\n\n\n
Diff\u00e9rence critique par rapport \u00e0 ECDSA : Ed25519 int\u00e8gre le hachage dans l’algorithme lui-m\u00eame (SHA-512 en interne). Passer un algorithme de hachage explicite \u00e0 crypto.sign()<\/code> avec une cl\u00e9 Ed25519 g\u00e9n\u00e8re une erreur en Node.js 22. L’argument algorithme doit \u00eatre null<\/code>.<\/p>\n\n\n\n
\/\/ scripts\/sign-verify-ed25519.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nfunction signWithEd25519(data, privateKeyPem) {\n  \/\/ null = Ed25519 g\u00e8re le hachage en interne (SHA-512 + d\u00e9rivation Curve25519)\n  \/\/ ERREUR si on passe 'SHA256' ici : TypeError: Invalid key type\n  const signature = crypto.sign(null, Buffer.from(data, 'utf8'), privateKeyPem);\n  return signature.toString('base64');\n}\n\nfunction verifyEd25519(data, signatureBase64, publicKeyPem) {\n  try {\n    return crypto.verify(\n      null,                                       \/\/ null obligatoire pour Ed25519\n      Buffer.from(data, 'utf8'),\n      publicKeyPem,\n      Buffer.from(signatureBase64, 'base64')\n    );\n  } catch {\n    return false;\n  }\n}\n\nconst keysDir = path.join(__dirname, '..', 'keys');\nconst privateKeyPem = fs.readFileSync(path.join(keysDir, 'ed25519-private.pem'), 'utf8');\nconst publicKeyPem = fs.readFileSync(path.join(keysDir, 'ed25519-public.pem'), 'utf8');\n\nconst message = 'Transaction valid\u00e9e par Ed25519 - 20 juin 2026 10:30:00 UTC';\n\nconst signature = signWithEd25519(message, privateKeyPem);\nconsole.log('Signature Ed25519 (Base64) :', signature);\nconsole.log('Taille fixe :', Buffer.from(signature, 'base64').length, 'octets (toujours 64)');\n\nconsole.log('V\u00e9rification (original) :', verifyEd25519(message, signature, publicKeyPem));     \/\/ true\nconsole.log('V\u00e9rification (alt\u00e9r\u00e9) :', verifyEd25519(message + '!', signature, publicKeyPem)); \/\/ false<\/code><\/pre>\n\n\n\n
Sortie attendue :<\/p>\n\n\n\n
Signature Ed25519 (Base64) : dGhpcyBpcyBhIG...==\nTaille fixe : 64 octets (toujours 64)\nV\u00e9rification (original) : true\nV\u00e9rification (alt\u00e9r\u00e9) : false<\/code><\/pre>\n\n\n\n
La taille fixe de 64 octets d’Ed25519 simplifie les protocoles r\u00e9seau : pas besoin de parser un encodage DER \u00e0 longueur variable, les buffers peuvent \u00eatre pr\u00e9-allou\u00e9s de taille fixe.<\/p>\n\n\n\n
\u00c9tape 8 : Impl\u00e9menter JWT sign\u00e9 avec ES256 (ECDSA + SHA-256)<\/h2>\n\n\n\n
Le standard JWT (RFC 7519) supporte ECDSA via l’algorithme ES256 (ECDSA P-256 + SHA-256). ES256 est le deuxi\u00e8me algorithme JWT le plus r\u00e9pandu apr\u00e8s RS256. L’impl\u00e9mentation ci-dessous n’utilise aucune biblioth\u00e8que externe, uniquement le module crypto<\/code>. Un d\u00e9tail critique : Node.js retourne les signatures ECDSA au format DER, mais RFC 7518 impose le format P1363 (r et s concat\u00e9n\u00e9s, 64 octets fixes). La conversion DER vers P1363 est obligatoire.<\/p>\n\n\n\n
\/\/ scripts\/jwt-es256.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\n\/\/ Base64url : pas de padding, + devient -, \/ devient _\nfunction toBase64url(buffer) {\n  return Buffer.from(buffer).toString('base64')\n    .replace(\/=\/g, '').replace(\/\\+\/g, '-').replace(\/\\\/\/g, '_');\n}\n\nfunction jsonBase64url(obj) {\n  return toBase64url(Buffer.from(JSON.stringify(obj)));\n}\n\n\/\/ Convertir signature DER (ASN.1) vers IEEE P1363 (r||s, 64 octets) pour JWT\nfunction derToP1363(der) {\n  \/\/ Structure DER : 0x30 [longueur-totale] 0x02 [len-r] [r] 0x02 [len-s] [s]\n  let offset = 2;\n  const rLen = der[offset + 1];\n  const rRaw = der.slice(offset + 2, offset + 2 + rLen);\n  offset += 2 + rLen;\n  const sLen = der[offset + 1];\n  const sRaw = der.slice(offset + 2, offset + 2 + sLen);\n\n  \/\/ Normaliser r et s \u00e0 32 octets (supprimer le 0x00 de padding si bit de signe)\n  const pad32 = (buf) => {\n    if (buf.length > 32) return buf.slice(buf.length - 32);\n    if (buf.length < 32) return Buffer.concat([Buffer.alloc(32 - buf.length), buf]);\n    return buf;\n  };\n\n  return Buffer.concat([pad32(rRaw), pad32(sRaw)]);\n}\n\nfunction createES256JWT(payload, privateKeyPem, passphrase) {\n  const header = { alg: 'ES256', typ: 'JWT' };\n  const encodedHeader = jsonBase64url(header);\n  const encodedPayload = jsonBase64url({\n    ...payload,\n    iat: Math.floor(Date.now() \/ 1000),\n    exp: Math.floor(Date.now() \/ 1000) + 3600\n  });\n\n  const signingInput = `${encodedHeader}.${encodedPayload}`;\n\n  const privateKey = passphrase\n    ? crypto.createPrivateKey({ key: privateKeyPem, passphrase })\n    : privateKeyPem;\n\n  const signatureDER = crypto.sign('SHA256', Buffer.from(signingInput), privateKey);\n  const signatureP1363 = derToP1363(signatureDER);\n\n  return `${signingInput}.${toBase64url(signatureP1363)}`;\n}\n\nfunction verifyES256JWT(token, publicKeyPem) {\n  const parts = token.split('.');\n  if (parts.length !== 3) throw new Error('JWT malform\u00e9');\n\n  const [headerB64, payloadB64, sigB64] = parts;\n  const payload = JSON.parse(Buffer.from(payloadB64, 'base64url').toString());\n\n  if (payload.exp && payload.exp < Math.floor(Date.now() \/ 1000)) {\n    throw new Error('JWT expir\u00e9');\n  }\n\n  \/\/ Reconvertir P1363 vers DER pour la v\u00e9rification Node.js\n  const sigP1363 = Buffer.from(sigB64, 'base64url');\n  const r = sigP1363.slice(0, 32);\n  const s = sigP1363.slice(32, 64);\n  const rPad = r[0] & 0x80 ? Buffer.concat([Buffer.from([0x00]), r]) : r;\n  const sPad = s[0] & 0x80 ? Buffer.concat([Buffer.from([0x00]), s]) : s;\n  const der = Buffer.concat([\n    Buffer.from([0x30, 4 + rPad.length + sPad.length]),\n    Buffer.from([0x02, rPad.length]), rPad,\n    Buffer.from([0x02, sPad.length]), sPad\n  ]);\n\n  const valid = crypto.verify('SHA256', Buffer.from(`${headerB64}.${payloadB64}`), publicKeyPem, der);\n  return { valid, payload };\n}\n\n\/\/ D\u00e9monstration\nconst keysDir = path.join(__dirname, '..', 'keys');\nconst privateKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-private.pem'), 'utf8');\nconst publicKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-public.pem'), 'utf8');\nconst PASSPHRASE = process.env.KEY_PASSPHRASE;\n\nconst token = createES256JWT(\n  { sub: 'utilisateur-42', email: 'alice@example.fr', role: 'admin' },\n  privateKeyPem,\n  PASSPHRASE\n);\nconsole.log('JWT ES256 :', token.substring(0, 80) + '...');\n\nconst { valid, payload } = verifyES256JWT(token, publicKeyPem);\nconsole.log('JWT valide :', valid);\nconsole.log('Payload :', JSON.stringify(payload, null, 2));<\/code><\/pre>\n\n\n\n
\u00c9tape 9 : Signer des fichiers avec streaming<\/h2>\n\n\n\n
Pour les fichiers volumineux, charger l'int\u00e9gralit\u00e9 du contenu en m\u00e9moire avant de signer est inefficace. crypto.createSign()<\/code> supporte l'API Writable stream et traite les donn\u00e9es par morceaux. Cette approche fonctionne sur des fichiers de plusieurs Go sans contrainte de m\u00e9moire.<\/p>\n\n\n\n
\/\/ scripts\/sign-file.js\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nasync function signFile(filePath, privateKeyPem, passphrase) {\n  const privateKey = crypto.createPrivateKey({ key: privateKeyPem, passphrase });\n\n  return new Promise((resolve, reject) => {\n    const signer = crypto.createSign('SHA256');\n    fs.createReadStream(filePath)\n      .on('data', chunk => signer.update(chunk))\n      .on('end', () => resolve(signer.sign(privateKey, 'hex')))\n      .on('error', reject);\n  });\n}\n\nasync function verifyFile(filePath, signatureHex, publicKeyPem) {\n  return new Promise((resolve, reject) => {\n    const verifier = crypto.createVerify('SHA256');\n    fs.createReadStream(filePath)\n      .on('data', chunk => verifier.update(chunk))\n      .on('end', () => {\n        try { resolve(verifier.verify(publicKeyPem, signatureHex, 'hex')); }\n        catch { resolve(false); }\n      })\n      .on('error', reject);\n  });\n}\n\nasync function main() {\n  const keysDir = path.join(__dirname, '..', 'keys');\n  const privateKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-private.pem'), 'utf8');\n  const publicKeyPem = fs.readFileSync(path.join(keysDir, 'ecdsa-public.pem'), 'utf8');\n  const PASSPHRASE = process.env.KEY_PASSPHRASE;\n\n  \/\/ Cr\u00e9er un fichier de test\n  fs.writeFileSync('document.pdf.test', 'Contenu binaire simul\u00e9 pour la signature de fichier.');\n\n  const sig = await signFile('document.pdf.test', privateKeyPem, PASSPHRASE);\n  fs.writeFileSync('document.pdf.test.sig', sig);\n  console.log('Signature sauvegard\u00e9e dans document.pdf.test.sig');\n\n  const isValid = await verifyFile('document.pdf.test', sig, publicKeyPem);\n  console.log('Int\u00e9grit\u00e9 v\u00e9rifi\u00e9e :', isValid); \/\/ true\n\n  \/\/ Simuler une alt\u00e9ration\n  fs.appendFileSync('document.pdf.test', ' (modifi\u00e9)');\n  const isValidAfterMod = await verifyFile('document.pdf.test', sig, publicKeyPem);\n  console.log('Int\u00e9grit\u00e9 apr\u00e8s alt\u00e9ration :', isValidAfterMod); \/\/ false\n}\n\nmain().catch(console.error);<\/code><\/pre>\n\n\n\n
\u00c9tape 10 : Benchmark ECDSA vs Ed25519<\/h2>\n\n\n\n
Avant de choisir l'algorithme pour un syst\u00e8me en production, mesurer les performances sur le mat\u00e9riel cible. Les r\u00e9sultats varient significativement selon le CPU (pr\u00e9sence d'instructions AES-NI, fr\u00e9quence, nombre de c\u0153urs).<\/p>\n\n\n\n
\/\/ scripts\/benchmark.js\nconst crypto = require('crypto');\n\nconst ITERATIONS = 10000;\nconst data = Buffer.from('benchmark: performance des signatures num\u00e9riques Node.js 2026');\n\n\/\/ G\u00e9n\u00e9rer les cl\u00e9s pour le test\nconst { privateKey: ecPriv, publicKey: ecPub } = crypto.generateKeyPairSync('ec', {\n  namedCurve: 'P-256',\n  publicKeyEncoding: { type: 'spki', format: 'pem' },\n  privateKeyEncoding: { type: 'pkcs8', format: 'pem' }\n});\nconst { privateKey: ed25519Priv, publicKey: ed25519Pub } = crypto.generateKeyPairSync('ed25519', {\n  publicKeyEncoding: { type: 'spki', format: 'pem' },\n  privateKeyEncoding: { type: 'pkcs8', format: 'pem' }\n});\n\n\/\/ Pr\u00e9-calculer les signatures pour les benchmarks de v\u00e9rification\nconst ecSig = crypto.sign('SHA256', data, ecPriv);\nconst edSig = crypto.sign(null, data, ed25519Priv);\n\nfunction bench(label, fn) {\n  const start = process.hrtime.bigint();\n  for (let i = 0; i < ITERATIONS; i++) fn();\n  const ms = Number(process.hrtime.bigint() - start) \/ 1e6;\n  const ops = Math.round(ITERATIONS \/ (ms \/ 1000));\n  console.log(`${label.padEnd(32)}: ${ops.toLocaleString('fr-FR').padStart(10)} ops\/s`);\n  return ops;\n}\n\nconsole.log(`\\nBenchmark Node.js 22 \/ ${ITERATIONS.toLocaleString('fr-FR')} it\u00e9rations\\n`);\n\nconst ecSignOps = bench('ECDSA P-256 signature',    () => crypto.sign('SHA256', data, ecPriv));\nconst ecVerOps  = bench('ECDSA P-256 v\u00e9rification', () => crypto.verify('SHA256', data, ecPub, ecSig));\nconst edSignOps = bench('Ed25519 signature',         () => crypto.sign(null, data, ed25519Priv));\nconst edVerOps  = bench('Ed25519 v\u00e9rification',      () => crypto.verify(null, data, ed25519Pub, edSig));\n\nconsole.log(`\\nEd25519 est ${(edSignOps \/ ecSignOps).toFixed(1)}x plus rapide que ECDSA pour la signature`);\nconsole.log(`Ed25519 est ${(edVerOps \/ ecVerOps).toFixed(1)}x plus rapide que ECDSA pour la v\u00e9rification`);<\/code><\/pre>\n\n\n\n
R\u00e9sultats typiques sur un serveur Linux Node.js 22 (Intel Xeon Platinum 8375C, 2 vCPU) :<\/p>\n\n\n\n
Op\u00e9ration<\/th>R\u00e9sultat mesur\u00e9<\/th>Ratio vs ECDSA sign<\/th><\/tr><\/thead>
ECDSA P-256 signature<\/td>~33 000 ops\/s<\/td>1x (r\u00e9f\u00e9rence)<\/td><\/tr>
ECDSA P-256 v\u00e9rification<\/td>~11 000 ops\/s<\/td>0.33x<\/td><\/tr>
Ed25519 signature<\/td>~115 000 ops\/s<\/td>3.5x plus rapide<\/strong><\/td><\/tr>
Ed25519 v\u00e9rification<\/td>~44 000 ops\/s<\/td>4x plus rapide<\/strong><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Pour une API REST qui valide 1 000 JWT par seconde, passer d'ES256 (ECDSA P-256) \u00e0 EdDSA (Ed25519) lib\u00e8re environ 75% de la charge CPU consacr\u00e9e aux v\u00e9rifications cryptographiques. Sur un microservice \u00e0 fort d\u00e9bit, c'est la diff\u00e9rence entre 1 instance et 4 instances.<\/p>\n\n\n\n
\u00c9tape 11 : Construire un service REST de signature<\/h2>\n\n\n\n
Le service Express 5 expose trois endpoints : POST \/sign<\/code>, POST \/verify<\/code>, et GET \/public-key<\/code>. Les cl\u00e9s sont charg\u00e9es une fois au d\u00e9marrage et r\u00e9utilis\u00e9es pour toutes les requ\u00eates, \u00e9vitant l'overhead de d\u00e9chiffrement \u00e0 chaque requ\u00eate.<\/p>\n\n\n\n
\/\/ server.js\nconst express = require('express');\nconst crypto = require('crypto');\nconst fs = require('fs');\nconst path = require('path');\n\nconst app = express();\napp.use(express.json({ limit: '64kb' }));\n\nconst PASSPHRASE = process.env.KEY_PASSPHRASE;\nif (!PASSPHRASE) { console.error('KEY_PASSPHRASE manquante'); process.exit(1); }\n\n\/\/ Charger et d\u00e9chiffrer les cl\u00e9s au d\u00e9marrage (une seule fois)\nconst KEYS_DIR = path.join(__dirname, 'keys');\nlet privateKeyObj, publicKeyPem;\ntry {\n  const rawPrivate = fs.readFileSync(path.join(KEYS_DIR, 'ecdsa-private.pem'), 'utf8');\n  publicKeyPem = fs.readFileSync(path.join(KEYS_DIR, 'ecdsa-public.pem'), 'utf8');\n  privateKeyObj = crypto.createPrivateKey({ key: rawPrivate, passphrase: PASSPHRASE });\n  console.log('Cl\u00e9s ECDSA charg\u00e9es');\n} catch (err) {\n  console.error('Chargement des cl\u00e9s \u00e9chou\u00e9 :', err.message); process.exit(1);\n}\n\n\/\/ POST \/sign \u2014 Signer un message\napp.post('\/sign', (req, res) => {\n  const { data } = req.body;\n  if (!data || typeof data !== 'string') return res.status(400).json({ error: '\"data\" requis (string)' });\n  if (data.length > 65536) return res.status(413).json({ error: 'Donn\u00e9es trop volumineuses (max 64 Ko)' });\n\n  try {\n    const sig = crypto.sign('SHA256', Buffer.from(data, 'utf8'), privateKeyObj);\n    res.json({ data, signature: sig.toString('base64'), algorithm: 'ECDSA-P256-SHA256', ts: new Date().toISOString() });\n  } catch { res.status(500).json({ error: 'Erreur de signature' }); }\n});\n\n\/\/ POST \/verify \u2014 V\u00e9rifier une signature\napp.post('\/verify', (req, res) => {\n  const { data, signature } = req.body;\n  if (!data || !signature) return res.status(400).json({ error: '\"data\" et \"signature\" requis' });\n\n  try {\n    const valid = crypto.verify('SHA256', Buffer.from(data, 'utf8'), publicKeyPem,\n      Buffer.from(signature, 'base64'));\n    res.json({ valid, data });\n  } catch { res.status(400).json({ valid: false, error: 'Signature invalide ou malform\u00e9e' }); }\n});\n\n\/\/ GET \/public-key \u2014 Distribuer la cl\u00e9 publique\napp.get('\/public-key', (_req, res) => res.type('text').send(publicKeyPem));\n\napp.listen(3000, () => console.log('Service de signature sur http:\/\/localhost:3000'));\n<\/code><\/pre>\n\n\n\n
Tester avec curl :<\/p>\n\n\n\n
# D\u00e9marrer le service\nKEY_PASSPHRASE=mon-secret-fort node server.js\n\n# Signer un document\nSIGNATURE=$(curl -s -X POST http:\/\/localhost:3000\/sign \\\n  -H 'Content-Type: application\/json' \\\n  -d '{\"data\":\"Bon de commande #FR-2026-042\"}' | python3 -c \"import json,sys; print(json.load(sys.stdin)['signature'])\")\n\necho \"Signature : $SIGNATURE\"\n\n# V\u00e9rifier la signature\ncurl -s -X POST http:\/\/localhost:3000\/verify \\\n  -H 'Content-Type: application\/json' \\\n  -d \"{\\\"data\\\":\\\"Bon de commande #FR-2026-042\\\",\\\"signature\\\":\\\"$SIGNATURE\\\"}\" | python3 -m json.tool\n\n# Sortie :\n# { \"valid\": true, \"data\": \"Bon de commande #FR-2026-042\" }<\/code><\/pre>\n\n\n\n
\u00c9tape 12 : S\u00e9curiser les cl\u00e9s et d\u00e9ployer en production<\/h2>\n\n\n\n
Le stockage des cl\u00e9s priv\u00e9es est le point le plus critique de l'architecture. Une cl\u00e9 priv\u00e9e compromise invalide r\u00e9trospectivement toutes les signatures \u00e9mises depuis cette cl\u00e9. Cinq r\u00e8gles non n\u00e9gociables pour la production :<\/p>\n\n\n\n