ECDSA et ECDH en Python pur

condition coverage mutation score

Il s'agit d'une implémentation facile à utiliser de l'ECC (cryptographie sur courbes elliptiques) prenant en charge l'ECDSA (algorithme de signature numérique à courbe elliptique), l'EdDSA (algorithme de signature numérique à courbe d'Edwards) et l'ECDH (échange de Diffie-Hellman à courbe elliptique), implémentée purement en Python et publiée sous licence MIT. Avec cette bibliothèque, vous pouvez rapidement créer des paires de clés (clé de signature et clé de vérification), signer des messages et vérifier les signatures. Vous pouvez également convenir d'une clé secrète partagée basée sur les clés publiques échangées. Les clés et les signatures sont très courtes, ce qui les rend faciles à manipuler et à intégrer dans d'autres protocoles.

REMARQUE : cette bibliothèque ne doit pas être utilisée en environnement de production, voir Sécurité pour plus de détails.

Fonctionnalités

Cette bibliothèque fournit la génération de clés, la signature, la vérification et la dérivation de secret partagé pour cinq courbes GF(p) (corps premier) NIST « Suite B » populaires, avec des longueurs de clé de 192, 224, 256, 384 et 521 bits. Les « noms courts » de ces courbes, connus de l'outil OpenSSL (openssl ecparam -list_curves), sont : prime192v1, secp224r1, prime256v1, secp384r1 et secp521r1. Cela inclut la courbe de 256 bits secp256k1 utilisée par Bitcoin. Il existe également une prise en charge des variantes régulières (non torsadées) des courbes Brainpool de 160 à 512 bits. Les « noms courts » de ces courbes sont : brainpoolP160r1, brainpoolP192r1, brainpoolP224r1, brainpoolP256r1, brainpoolP320r1, brainpoolP384r1, . Quelques petites courbes de la norme SEC sont également incluses (principalement pour accélérer les tests de la bibliothèque) : , , et . La génération de clés, la signature et la vérification sont également prises en charge pour les courbes Ed25519 et Ed448. Aucune autre courbe n'est incluse, mais il n'est pas trop difficile d'ajouter la prise en charge d'autres courbes sur corps premiers.

Dépendances

Cette bibliothèque n'utilise que Python et le paquet « six ». Elle est compatible avec Python 2.6, 2.7 et 3.6+. Elle prend également en charge l'exécution sur des implémentations alternatives comme pypy et pypy3.

Si gmpy2 ou gmpy est installé, ils seront utilisés pour un calcul plus rapide. L'un ou l'autre peut être installé après l'installation de cette bibliothèque, python-ecdsa détectera leur présence au démarrage et les utilisera automatiquement. Vous devriez préférer gmpy2 sur Python 3 pour des performances optimales.

Pour exécuter les tests de compatibilité OpenSSL, l'outil « openssl » doit être dans votre PATH. Cette version a été testée avec succès avec OpenSSL 0.9.8o, 1.0.0a, 1.0.2f, 1.1.1d et 3.0.1 (entre autres).

Installation

Cette bibliothèque est disponible sur PyPI, il est recommandé de l'installer avec pip :``` pip install ecdsa

Dans le cas où des performances supérieures sont souhaitées et que l'utilisation de code natif ne pose pas de problème,
il est possible de spécifier l'installation avec `gmpy2` :```
pip install ecdsa[gmpy2]

ou (option plus lente, héritée) :``` pip install ecdsa[gmpy]

## Vitesse

Le tableau suivant indique le temps mis par cette bibliothèque pour générer des paires de clés
(`keygen`), pour signer des données (`sign`), pour vérifier ces signatures (`verify`),
pour dériver un secret partagé (`ecdh`), et
pour vérifier les signatures sans précalcul spécifique à la clé (`no PC verify`).
Toutes ces valeurs sont en secondes.
Pour plus de commodité, les inverses de ces valeurs sont également fournis :
combien de clés par seconde peuvent être générées (`keygen/s`), combien de signatures
peuvent être créées par seconde (`sign/s`), combien de signatures peuvent être vérifiées
par seconde (`verify/s`), combien de secrets partagés peuvent être dérivés par seconde
(`ecdh/s`), et combien de signatures sans précalcul spécifique à la clé
peuvent être vérifiées par seconde (`no PC verify/s`). La taille de la signature
brute (généralement la plus petite
façon dont une signature peut être encodée) est également fournie dans la colonne `siglen`.
Utilisez `tox -e speed` pour générer ce tableau sur votre propre ordinateur.
Sur un Intel Core i7 4790K @ 4.0GHz, j'obtiens les performances suivantes :```
                  siglen    keygen   keygen/s      sign     sign/s    verify   verify/s  no PC verify  no PC verify/s
        NIST192p:     48   0.00032s   3134.06   0.00033s   2985.53   0.00063s   1598.36       0.00129s         774.43
        NIST224p:     56   0.00040s   2469.24   0.00042s   2367.88   0.00081s   1233.41       0.00170s         586.66
        NIST256p:     64   0.00051s   1952.73   0.00054s   1867.80   0.00098s   1021.86       0.00212s         471.27
        NIST384p:     96   0.00107s    935.92   0.00111s    904.23   0.00203s    491.77       0.00446s         224.00
        NIST521p:    132   0.00210s    475.52   0.00215s    464.16   0.00398s    251.28       0.00874s         114.39
       SECP256k1:     64   0.00052s   1921.54   0.00054s   1847.49   0.00105s    948.68       0.00210s         477.01
 BRAINPOOLP160r1:     40   0.00025s   4003.88   0.00026s   3845.12   0.00053s   1893.93       0.00105s         949.92
 BRAINPOOLP192r1:     48   0.00033s   3043.97   0.00034s   2975.98   0.00063s   1581.50       0.00135s         742.29
 BRAINPOOLP224r1:     56   0.00041s   2436.44   0.00043s   2315.51   0.00078s   1278.49       0.00180s         556.16
 BRAINPOOLP256r1:     64   0.00053s   1892.49   0.00054s   1846.24   0.00114s    875.64       0.00229s         437.25
 BRAINPOOLP320r1:     80   0.00073s   1361.26   0.00076s   1309.25   0.00143s    699.29       0.00322s         310.49
 BRAINPOOLP384r1:     96   0.00107s    931.29   0.00111s    901.80   0.00230s    434.19       0.00476s         210.20
 BRAINPOOLP512r1:    128   0.00207s    483.41   0.00212s    471.42   0.00425s    235.43       0.00912s         109.61
       SECP112r1:     28   0.00015s   6672.53   0.00016s   6440.34   0.00031s   3265.41       0.00056s        1774.20
       SECP112r2:     28   0.00015s   6697.11   0.00015s   6479.98   0.00028s   3524.72       0.00058s        1716.16
       SECP128r1:     32   0.00018s   5497.65   0.00019s   5272.89   0.00036s   2747.39       0.00072s        1396.16
       SECP160r1:     42   0.00025s   3949.32   0.00026s   3894.45   0.00046s   2153.85       0.00102s         985.07
         Ed25519:     64   0.00076s   1324.48   0.00042s   2405.01   0.00109s    918.05       0.00344s         290.50
           Ed448:    114   0.00176s    569.53   0.00115s    870.94   0.00282s    355.04       0.01024s          97.69

                       ecdh     ecdh/s
        NIST192p:   0.00104s    964.89
        NIST224p:   0.00134s    748.63
        NIST256p:   0.00170s    587.08
        NIST384p:   0.00352s    283.90
        NIST521p:   0.00717s    139.51
       SECP256k1:   0.00154s    648.40
 BRAINPOOLP160r1:   0.00082s   1220.70
 BRAINPOOLP192r1:   0.00105s    956.75
 BRAINPOOLP224r1:   0.00136s    734.52
 BRAINPOOLP256r1:   0.00178s    563.32
 BRAINPOOLP320r1:   0.00252s    397.23
 BRAINPOOLP384r1:   0.00376s    266.27
 BRAINPOOLP512r1:   0.00733s    136.35
       SECP112r1:   0.00046s   2180.40
       SECP112r2:   0.00045s   2229.14
       SECP128r1:   0.00054s   1868.15
       SECP160r1:   0.00080s   1243.98

Pour tester les performances avec gmpy2 Sur la même machine, j'obtiens les performances suivantes avec tox -e speedgmpy2. node="[object Object]">gmpy2 :``` no PC verify/s 0.00067s 1502.41 0.00089s 1126.90 0.00098s 1016.82 0.00172s 581.43 0.00312s 320.40 0.00094s 1068.32 0.00057s 1769.81 0.00069s 1453.19 0.00087s 1149.87 0.00098s 1015.60 0.00136s 737.34 0.00178s 562.85 0.00281s 355.83 0.00033s 3020.83 0.00032s 3094.28 0.00036s 2760.88 0.00057s 1768.35 0.00153s 654.02 0.00350s 285.62

                   ecdh     ecdh/s
    NIST192p:   0.00050s   1985.70
    NIST224p:   0.00066s   1524.16
    NIST256p:   0.00071s   1413.07
    NIST384p:   0.00127s    788.89
    NIST521p:   0.00230s    434.85
   SECP256k1:   0.00071s   1409.95

BRAINPOOLP160r1: 0.00042s 2374.65 BRAINPOOLP192r1: 0.00051s 1960.01 BRAINPOOLP224r1: 0.00066s 1518.37 BRAINPOOLP256r1: 0.00071s 1399.90 BRAINPOOLP320r1: 0.00100s 997.21 BRAINPOOLP384r1: 0.00129s 777.51 BRAINPOOLP512r1: 0.00210s 475.99 SECP112r1: 0.00022s 4457.70 SECP112r2: 0.00024s 4252.33 SECP128r1: 0.00028s 3589.31 SECP160r1: 0.00043s 2305.02

(il existe aussi une version `gmpy`, exécutez-la avec `tox -e speedgmpy`)

Pour comparaison, une implémentation hautement optimisée (incluant de l'assembleur spécifique à certaines courbes), comme celle d'OpenSSL 1.1.1d, fournit les chiffres de performance suivants sur la même machine.
Exécutez `openssl speed ecdsa` et `openssl speed ecdh` pour la reproduire :```
                              sign    verify    sign/s verify/s
 192 bits ecdsa (nistp192)   0.0002s   0.0002s   4785.6   5380.7
 224 bits ecdsa (nistp224)   0.0000s   0.0001s  22475.6   9822.0
 256 bits ecdsa (nistp256)   0.0000s   0.0001s  45069.6  14166.6
 384 bits ecdsa (nistp384)   0.0008s   0.0006s   1265.6   1648.1
 521 bits ecdsa (nistp521)   0.0003s   0.0005s   3753.1   1819.5
 256 bits ecdsa (brainpoolP256r1)   0.0003s   0.0003s   2983.5   3333.2
 384 bits ecdsa (brainpoolP384r1)   0.0008s   0.0007s   1258.8   1528.1
 512 bits ecdsa (brainpoolP512r1)   0.0015s   0.0012s    675.1    860.1

                              sign    verify    sign/s verify/s
 253 bits EdDSA (Ed25519)   0.0000s   0.0001s  28217.9  10897.7
 456 bits EdDSA (Ed448)     0.0003s   0.0005s   3926.5   2147.7

                               op      op/s
 192 bits ecdh (nistp192)   0.0002s   4853.4
 224 bits ecdh (nistp224)   0.0001s  15252.1
 256 bits ecdh (nistp256)   0.0001s  18436.3
 384 bits ecdh (nistp384)   0.0008s   1292.7
 521 bits ecdh (nistp521)   0.0003s   2884.7
 256 bits ecdh (brainpoolP256r1)   0.0003s   3066.5
 384 bits ecdh (brainpoolP384r1)   0.0008s   1298.0
 512 bits ecdh (brainpoolP512r1)   0.0014s    694.8

Keys and signature can be serialized in different ways (voir Utilisation, ci-dessous). Pour une clé NIST192p, les trois représentations de base nécessitent des chaînes des longueurs suivantes (en octets) :

to_string:  signkey= 24, verifykey= 48, signature=48
compressed: signkey=n/a, verifykey= 25, signature=n/a
DER:        signkey=106, verifykey= 80, signature=55
PEM:        signkey=278, verifykey=162, (no support for PEM signatures)

Historique

En 2006, Peter Pearson a annoncé son implémentation d'ECDSA en Python pur dans un message à sci.crypt, disponible sur son site de téléchargement. En 2010, Brian Warner a écrit un wrapper autour de ce code, pour le rendre un peu plus facile et plus sûr à utiliser. En 2020, Hubert Kario a inclus une implémentation de la cryptographie sur courbes elliptiques qui utilise des coordonnées jacobiennes en interne, améliorant les performances d'environ 20 fois. Vous lisez actuellement le README de ce wrapper.

Tests

Pour exécuter la suite de tests complète, faites ceci :

tox -e coverage

Sur un Intel Core i7 4790K @ 4.0GHz, les tests mettent environ 18 secondes à s'exécuter. La suite de tests utilise hypothesis, il y a donc une certaine variabilité inhérente dans le temps d'exécution de la suite de tests.

Une partie de test_pyecdsa.py et de test_ecdh.py vérifie la compatibilité avec OpenSSL, en exécutant l'outil CLI "openssl" ; assurez-vous qu'il se trouve dans votre PATH si vous voulez tester la compatibilité avec lui (si OpenSSL est absent, trop ancien, ou ne prend pas en charge toutes les courbes prises en charge dans les versions en amont, vous verrez des tests ignorés lors de l'exécution de coverage ci-dessus).

Sécurité

Cette bibliothèque n'a pas été conçue dans un objectif de sécurité. Si vous traitez des données qui doivent être protégées, nous vous suggérons d'utiliser un wrapper de qualité autour d'OpenSSL. pyca/cryptography est un exemple d'un tel wrapper. Le cas d'utilisation principal de cette bibliothèque est de servir de bibliothèque portable pour les tests d'interopérabilité et d'outil pédagogique.

Cette bibliothèque ne protège pas contre les attaques par canaux auxiliaires.

Ne laissez pas des attaquants mesurer le temps qu'il vous faut pour générer une paire de clés ou signer un message. Ne laissez pas des attaquants exécuter du code sur la même machine physique lorsque la génération d'une paire de clés ou la signature est en cours (cela inclut les machines virtuelles). Ne laissez pas des attaquants mesurer la quantité d'énergie que votre ordinateur consomme pendant la génération de la paire de clés ou la signature d'un message. Ne laissez pas des attaquants mesurer les interférences RF émises par votre ordinateur pendant la génération d'une paire de clés ou la signature d'un message. Remarque : le simple chargement de la clé privée provoque la génération de la paire de clés. D'autres opérations ou vecteurs d'attaque peuvent également être vulnérables. Pour un attaquant sophistiqué, observer une seule opération effectuée avec une clé privée suffira à reconstruire entièrement la clé privée.

Veuillez également noter que toute bibliothèque cryptographique en Python pur sera vulnérable aux mêmes attaques par canaux auxiliaires. Cela vient du fait que Python ne fournit pas de primitives sécurisées contre les canaux auxiliaires (à l'exception de hmac.compare_digest()), ce qui rend impossible toute programmation sécurisée contre les canaux auxiliaires.

Cette bibliothèque dépend d'une source solide de nombres aléatoires. Ne l'utilisez pas sur un système où os.urandom() ne fournit pas de nombres aléatoires cryptographiquement sécurisés.

Utilisation

Vous commencez par créer un SigningKey. Vous pouvez l'utiliser pour signer des données, en passant les données sous forme de chaîne d'octets et en récupérant la signature (également une chaîne d'octets). Vous pouvez également demander à un SigningKey de vous donner la VerifyingKey correspondante. La VerifyingKey peut être utilisée pour vérifier une signature, en lui passant à la fois la chaîne de données et la chaîne d'octets de la signature : soit elle retourne True, soit elle lève BadSignatureError.```python from ecdsa import SigningKey sk = SigningKey.generate() # uses NIST192p vk = sk.verifying_key signature = sk.sign(b"message") assert vk.verify(signature, b"message")

Chaque `SigningKey`/`VerifyingKey` est associé à une courbe spécifique, comme
NIST192p (celle par défaut). Les courbes plus longues sont plus sûres, mais prennent plus de temps à
utiliser, et produisent des clés et des signatures plus longues.```python
from ecdsa import SigningKey, NIST384p
sk = SigningKey.generate(curve=NIST384p)
vk = sk.verifying_key
signature = sk.sign(b"message")
assert vk.verify(signature, b"message")

La SigningKey peut être sérialisée en plusieurs formats différents : le plus court consiste à appeler s=sk.to_string(), puis à la recréer avec SigningKey.from_string(s, curve) . Ce format court n'enregistre pas la courbe, vous devez donc être sûr de passer à from_string() la même courbe que celle utilisée pour la clé d'origine. Le format court d'une clé de signature basée sur NIST192p ne fait que 24 octets de long. Si un encodage de point est invalide ou ne se trouve pas sur la courbe spécifiée, from_string() lèvera MalformedPointError.```python from ecdsa import SigningKey, NIST384p sk = SigningKey.generate(curve=NIST384p) sk_string = sk.to_string() sk2 = SigningKey.from_string(sk_string, curve=NIST384p) print(sk_string.hex()) print(sk2.to_string().hex())

Remarque : bien que les méthodes soient appelées `to_string()`, le type qu'elles renvoient est
en réalité `bytes`, la partie « string » est un reliquat de Python 2.

`sk.to_pem()` et `sk.to_der()` sérialisent la clé de signature dans les mêmes
formats qu'utilise OpenSSL. Le fichier PEM ressemble au format familier à armure ASCII
`"-----BEGIN EC PRIVATE KEY-----"` encodé en base64, et le format DER
est une forme binaire plus courte des mêmes données.
`SigningKey.from_pem()/.from_der()` annule cette sérialisation. Ces
formats incluent le nom de la courbe, vous n'avez donc pas besoin de passer un identifiant de courbe
au désérialiseur. Si le fichier est malformé, `from_der()`
et `from_pem()` lèvent `UnexpectedDER` ou` MalformedPointError`.```python
from ecdsa import SigningKey, NIST384p
sk = SigningKey.generate(curve=NIST384p)
sk_pem = sk.to_pem()
sk2 = SigningKey.from_pem(sk_pem)
# sk and sk2 are the same key

Likewise, the VerifyingKey can be serialized in the same way: vk.to_string()/VerifyingKey.from_string(), to_pem()/from_pem(), and to_der()/from_der(). The same curve= argument is needed for VerifyingKey.from_string().```python from ecdsa import SigningKey, VerifyingKey, NIST384p sk = SigningKey.generate(curve=NIST384p) vk = sk.verifying_key vk_string = vk.to_string() vk2 = VerifyingKey.from_string(vk_string, curve=NIST384p)

vk and vk2 are the same key

from ecdsa import SigningKey, VerifyingKey, NIST384p sk = SigningKey.generate(curve=NIST384p) vk = sk.verifying_key vk_pem = vk.to_pem() vk2 = VerifyingKey.from_pem(vk_pem)

vk and vk2 are the same key

Il existe plusieurs façons de calculer une signature. Fondamentalement,
l'ECDSA prend un nombre qui représente les données à signer et renvoie une
paire de nombres qui représentent la signature. L'argument `hashfunc=` de
`sk.sign()` et `vk.verify()` est utilisé pour transformer une chaîne arbitraire en un
condensat de longueur fixe, qui est ensuite converti en un nombre que l'ECDSA peut signer,
et la signature comme la vérification doivent utiliser la même approche. La valeur par défaut est
`hashlib.sha1`, mais si vous utilisez NIST256p ou une courbe plus longue, vous pouvez utiliser
`hashlib.sha256` à la place.

Il existe également plusieurs façons de représenter une signature. Par défaut,
les méthodes `sk.sign()` et `vk.verify()` la présentent sous la forme d'une chaîne courte, pour
plus de simplicité et une surcharge minimale. Pour utiliser un schéma différent, utilisez les
arguments `sk.sign(sigencode=)` et `vk.verify(sigdecode=)`. Le module `ecdsa.util`
contient des fonctions d'assistance qui peuvent être utiles ici.

Il est également possible de créer une `SigningKey` à partir d'une « graine », de manière
déterministe. Cela peut être utilisé dans des protocoles où vous souhaitez dériver
des clés de signature cohérentes à partir d'un autre secret, par exemple lorsque vous voulez
trois clés distinctes et ne souhaitez stocker qu'un seul secret maître. Vous devez
commencer avec une graine uniformément répartie et impossible à deviner, contenant environ `curve.baselen`
octets d'entropie, puis utiliser l'une des fonctions d'assistance de `ecdsa.util` pour
la convertir en un entier dans la plage correcte, et enfin la passer
à `SigningKey.from_secret_exponent()`, comme ceci :```python
import os
from ecdsa import NIST384p, SigningKey
from ecdsa.util import randrange_from_seed__trytryagain

def make_key(seed):
  secexp = randrange_from_seed__trytryagain(seed, NIST384p.order)
  return SigningKey.from_secret_exponent(secexp, curve=NIST384p)

seed = os.urandom(NIST384p.baselen) # or other starting point
sk1a = make_key(seed)
sk1b = make_key(seed)
# note: sk1a and sk1b are the same key
assert sk1a.to_string() == sk1b.to_string()
sk2 = make_key(b"2-"+seed)  # different key
assert sk1a.to_string() != sk2.to_string()

Dans le cas où l'application vérifiera un grand nombre de signatures effectuées avec une seule clé, il est possible de précalculer certaines des valeurs internes afin de rendre la vérification de signatures nettement plus rapide. Le point d'équilibre se situe à environ 100 signatures vérifiées.

Pour effectuer le précalcul, vous pouvez appeler la méthode precompute() sur l'instance VerifyingKey :```python from ecdsa import SigningKey, NIST384p sk = SigningKey.generate(curve=NIST384p) vk = sk.verifying_key vk.precompute() signature = sk.sign(b"message") assert vk.verify(signature, b"message")

Une fois que `precompute()` a été appelé, toutes les vérifications de signature avec cette clé seront
plus rapides à exécuter.

## Compatibilité OpenSSL

Pour produire des signatures pouvant être vérifiées par les outils OpenSSL, ou pour vérifier
les signatures produites par ces outils, utilisez:```python
# openssl ecparam -name prime256v1 -genkey -out sk.pem
# openssl ec -in sk.pem -pubout -out vk.pem
# echo "data for signing" > data
# openssl dgst -sha256 -sign sk.pem -out data.sig data
# openssl dgst -sha256 -verify vk.pem -signature data.sig data
# openssl dgst -sha256 -prverify sk.pem -signature data.sig data

import hashlib
from ecdsa import SigningKey, VerifyingKey
from ecdsa.util import sigencode_der, sigdecode_der

with open("vk.pem") as f:
   vk = VerifyingKey.from_pem(f.read())

with open("data", "rb") as f:
   data = f.read()

with open("data.sig", "rb") as f:
   signature = f.read()

assert vk.verify(signature, data, hashlib.sha256, sigdecode=sigdecode_der)

with open("sk.pem") as f:
   sk = SigningKey.from_pem(f.read(), hashlib.sha256)

new_signature = sk.sign_deterministic(data, sigencode=sigencode_der)

with open("data.sig2", "wb") as f:
   f.write(new_signature)

# openssl dgst -sha256 -verify vk.pem -signature data.sig2 data

Remarque : si une compatibilité avec OpenSSL 1.0.0 ou une version antérieure est nécessaire, les fonctions sigencode_string et sigdecode_string de ecdsa.util peuvent être utilisées pour écrire et lire respectivement les signatures.

Les clés peuvent également être écrites dans un format qu'openssl peut gérer :```python from ecdsa import SigningKey, VerifyingKey

with open("sk.pem") as f: sk = SigningKey.from_pem(f.read()) with open("sk.pem", "wb") as f: f.write(sk.to_pem())

with open("vk.pem") as f: vk = VerifyingKey.from_pem(f.read()) with open("vk.pem", "wb") as f: f.write(vk.to_pem())

## Entropie

La création d'une clé de signature avec `SigningKey.generate()` nécessite une certaine forme d'
entropie (par opposition à
`from_secret_exponent`/`from_string`/`from_der`/`from_pem`,
qui sont déterministes et ne nécessitent pas de source d'entropie). La source
par défaut est `os.urandom()`, mais vous pouvez passer toute autre fonction qui se comporte
comme `os.urandom` comme argument `entropy=` pour faire quelque chose de différent. Cela
peut être utile dans les tests unitaires, où vous souhaitez obtenir des résultats reproductibles. L'
utilitaire `ecdsa.util.PRNG` est pratique ici : il prend une graine et produit un
flux pseudo-aléatoire robuste à partir de celle-ci :```python
from ecdsa.util import PRNG
from ecdsa import SigningKey
rng1 = PRNG(b"seed")
sk1 = SigningKey.generate(entropy=rng1)
rng2 = PRNG(b"seed")
sk2 = SigningKey.generate(entropy=rng2)
# sk1 and sk2 are the same key

De même, la génération de signature ECDSA nécessite un nombre aléatoire, et chaque signature doit en utiliser un différent (utiliser le même nombre deux fois révélera immédiatement la clé de signature privée). La méthode sk.sign() accepte un argument entropy= qui se comporte comme SigningKey.generate(entropy=).

Signatures déterministes

Si vous appelez SigningKey.sign_deterministic(data) au lieu de .sign(data), le code générera une signature déterministe au lieu d'une signature aléatoire. Cela utilise l'algorithme de RFC6979 pour générer en toute sécurité une valeur k unique, dérivée de la clé privée et du message signé. Chaque fois que vous signez le même message avec la même clé, vous obtiendrez la même signature (en utilisant le même k).

Cela pourrait devenir le comportement par défaut dans une future version, car cela n'est pas vulnérable aux défaillances de la source d'entropie.

Exemples

Créez une paire de clés NIST192p et enregistrez immédiatement les deux sur le disque :```python from ecdsa import SigningKey sk = SigningKey.generate() vk = sk.verifying_key with open("private.pem", "wb") as f: f.write(sk.to_pem()) with open("public.pem", "wb") as f: f.write(vk.to_pem())

Chargez une clé de signature depuis le disque, utilisez-la pour signer un message (en utilisant SHA-1), et écrivez
la signature sur le disque :```python
from ecdsa import SigningKey
with open("private.pem") as f:
    sk = SigningKey.from_pem(f.read())
with open("message", "rb") as f:
    message = f.read()
sig = sk.sign(message)
with open("signature", "wb") as f:
    f.write(sig)

Chargez la clé de vérification, le message et la signature depuis le disque, puis vérifiez la signature (en supposant un hachage SHA-1) :```python from ecdsa import VerifyingKey, BadSignatureError vk = VerifyingKey.from_pem(open("public.pem").read()) with open("message", "rb") as f: message = f.read() with open("signature", "rb") as f: sig = f.read() try: vk.verify(sig, message) print "good signature" except BadSignatureError: print "BAD SIGNATURE"

Créez une paire de clés NIST521p :```python
from ecdsa import SigningKey, NIST521p
sk = SigningKey.generate(curve=NIST521p)
vk = sk.verifying_key

Créez trois clés de signature indépendantes à partir d'une graine maîtresse :```python from ecdsa import NIST192p, SigningKey from ecdsa.util import randrange_from_seed__trytryagain

def make_key_from_seed(seed, curve=NIST192p): secexp = randrange_from_seed__trytryagain(seed, curve.order) return SigningKey.from_secret_exponent(secexp, curve)

sk1 = make_key_from_seed("1:%s" % seed) sk2 = make_key_from_seed("2:%s" % seed) sk3 = make_key_from_seed("3:%s" % seed)

Chargez une clé de vérification depuis le disque et affichez-la en utilisant l'encodage hexadécimal au
format non compressé et compressé (défini dans les normes X9.62 et SEC1) :```python
from ecdsa import VerifyingKey

with open("public.pem") as f:
    vk = VerifyingKey.from_pem(f.read())

print("uncompressed: {0}".format(vk.to_string("uncompressed").hex()))
print("compressed: {0}".format(vk.to_string("compressed").hex()))

Charger une clé de vérification à partir d'une chaîne hexadécimale au format compressé, sortie non compressée :```python from ecdsa import VerifyingKey, NIST256p

comp_str = '022799c0d0ee09772fdd337d4f28dc155581951d07082fb19a38aa396b67e77759' vk = VerifyingKey.from_string(bytearray.fromhex(comp_str), curve=NIST256p) print(vk.to_string("uncompressed").hex())

Échange de clés ECDH avec la partie distante :```python
from ecdsa import ECDH, NIST256p

ecdh = ECDH(curve=NIST256p)
ecdh.generate_private_key()
local_public_key = ecdh.get_public_key()
#send `local_public_key` to remote party and receive `remote_public_key` from remote party
with open("remote_public_key.pem") as e:
    remote_public_key = e.read()
ecdh.load_received_public_key_pem(remote_public_key)
secret = ecdh.generate_sharedsecret_bytes()

python-ecdsa

Populaires

ECDSA et ECDH en Python pur

Fonctionnalités

Dépendances

Installation

Historique

Tests

Sécurité

Utilisation

vk and vk2 are the same key

vk and vk2 are the same key

Signatures déterministes

Exemples