ECDSA P-384 vs RSA-2048
pour la signature de licences

Pourquoi changer de RSA ?

IronLock v1 utilisait RSA-2048 pour signer les licences. C'est une cryptographie solide, mais elle souffre de trois problèmes pratiques pour le licensing embarqué : la clé publique pèse 294 bytes (embarquée dans le loader), la vérification de signature prend ~2ms sur CPU modeste, et la taille des signatures RSA-2048 est de 256 bytes par licence.

IronLock v2 migre vers ECDSA P-384. La clé publique fait 97 bytes, la vérification prend < 0.5ms et la sécurité est équivalente à RSA-7680 — bien au-delà des besoins actuels.

ECDSA P-384 offre une sécurité de 192 bits. RSA-2048 offre ~112 bits. Pour une sécurité équivalente à RSA, une clé ECC est 4 à 6 fois plus courte.

Les courbes elliptiques

La cryptographie sur courbes elliptiques (ECC) repose sur le problème du logarithme discret sur une courbe elliptique définie sur un corps fini. Ce problème est considérablement plus difficile que la factorisation de grands entiers (RSA) pour une taille de clé donnée.

Une courbe elliptique est définie par l'équation y² = x³ + ax + b (mod p). Les opérations (addition de points) sont associatives et forment un groupe cyclique. La clé privée est un scalaire k ; la clé publique est le point k×G sur la courbe (G = générateur).

P-384 spécifiquement

P-384 (aussi appelée secp384r1) est une courbe standardisée par le NIST. Elle offre :

• 192 bits de sécurité — équivalent RSA-7680 en termes de résistance aux attaques connues.
• Clé privée : 48 bytes. Clé publique compressée : 49 bytes, non compressée : 97 bytes.
• Signature : 96 bytes (deux entiers r et s de 48 bytes).
• Support matériel : accélération native sur Intel/AMD via l'instruction PCLMULQDQ.

Comparatif RSA-2048 vs ECDSA P-384

Note : RSA est légèrement plus rapide en vérification (exposant public e=65537 petit). ECDSA est largement supérieur en génération de clés et en taille. Pour le licensing embarqué, la taille est le facteur décisif.

Implémentation Python

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric.utils import (
    decode_dss_signature, encode_dss_signature
)
from cryptography.hazmat.primitives import hashes, serialization
import json, base64

# Génération des clés (une seule fois, clé privée hors ligne)
private_key = ec.generate_private_key(ec.SECP384R1())
public_key  = private_key.public_key()

# Sérialisation clé publique (embarquée dans le loader)
pub_pem = public_key.public_bytes(
    serialization.Encoding.PEM,
    serialization.PublicFormat.SubjectPublicKeyInfo
)  # 97 bytes en DER, ~170 bytes en PEM

def sign_licence(licence_data: dict, private_key) -> dict:
    payload = json.dumps(licence_data, sort_keys=True).encode()
    signature = private_key.sign(payload, ec.ECDSA(hashes.SHA384()))
    licence_data['signature'] = base64.b64encode(signature).decode()
    return licence_data

def verify_licence(licence_data: dict, public_key) -> bool:
    sig_b64 = licence_data.pop('signature')
    payload  = json.dumps(licence_data, sort_keys=True).encode()
    sig      = base64.b64decode(sig_b64)
    try:
        public_key.verify(sig, payload, ec.ECDSA(hashes.SHA384()))
        return True
    except: return False

Dans IronLock v2

La clé privée ECDSA P-384 reste hors ligne — elle n'est jamais distribuée. La clé publique est embarquée dans le loader chiffré. Le workflow :

# 1. Générer les clés (une seule fois, côté éditeur)
ironlock keygen --algo ecdsa-p384 --output keys/

# 2. Packager avec la clé publique embarquée
ironlock encrypt app.py --pubkey keys/public.pem --output dist/

# 3. Signer une licence pour un client
ironlock license   --privkey keys/private.pem   --fingerprint CLIENT_HW_HASH   --expires 2027-06-01   --output licence_client.lic

Conclusion

ECDSA P-384 est le bon choix pour signer des licences logicielles en 2026 : sécurité supérieure à RSA-2048, clés 4× plus petites, adapté aux loaders embarqués. La migration d'IronLock v1 (RSA-2048) vers v2 (ECDSA P-384) apporte aussi un gain de 160 bytes sur la taille du loader — ce qui compte quand le loader est distribué dans chaque installation client.