Comment faire pour signer et vérifier la signature ecdsa en python

J'ai besoin de signer un hachage de 256 bits avec ECDSA à l'aide d'une clé privée de 256 bits, tout comme le bitcoin fait, et je suis le désespoir qui atteint en raison de l'insuffisance de la documentation ecdsa en python.

J'ai trouvé un grand nombre de codes sur internet, mais il n'y a rien d'aussi facile que de simplement ecdsa.sign(msg, privkey) ou similaire, tout ce que j'ai trouvé, c'est beaucoup de code de mathématique des choses que je ne comprends pas, mais encore ils utilisent le ecdsa bibliothèque (je ne sais pas pourquoi ils ne voulaient pas l'ajout d'une signature de fonction dans une bibliothèque qui va être utilisé pour signer des trucs, au lieu d'une page de code est nécessaire lors de l'utilisation de la bibliothèque?).

C'est le meilleur code que j'ai trouvé jusqu'à présent:

def ecdsa_sign(val, secret_exponent):
"""Return a signature for the provided hash, using the provided
random nonce. It is absolutely vital that random_k be an unpredictable
number in the range [1, self.public_key.point.order()-1].  If
an attacker can guess random_k, he can compute our private key from a
single signature. Also, if an attacker knows a few high-order
bits (or a few low-order bits) of random_k, he can compute our private
key from many signatures. The generation of nonces with adequate
cryptographic strength is very difficult and far beyond the scope
of this comment.
May raise RuntimeError, in which case retrying with a new
random value k is in order.
"""
G = ecdsa.SECP256k1
n = G.order()
k = deterministic_generate_k(n, secret_exponent, val)
p1 = k * G
r = p1.x()
if r == 0: raise RuntimeError("amazingly unlucky random number r")
s = ( ecdsa.numbertheory.inverse_mod( k, n ) * ( val + ( secret_exponent * r ) % n ) ) % n
if s == 0: raise RuntimeError("amazingly unlucky random number s")
return signature_to_der(r, s)
def deterministic_generate_k(generator_order, secret_exponent, val, hash_f=hashlib.sha256):
"""
Generate K value according to https://tools.ietf.org/html/rfc6979
"""
n = generator_order
order_size = (bit_length(n) + 7) // 8
hash_size = hash_f().digest_size
v = b'\x01' * hash_size
k = b'\x00' * hash_size
priv = intbytes.to_bytes(secret_exponent, length=order_size)
shift = 8 * hash_size - bit_length(n)
if shift > 0:
val >>= shift
if val > n:
val -= n
h1 = intbytes.to_bytes(val, length=order_size)
k = hmac.new(k, v + b'\x00' + priv + h1, hash_f).digest()
v = hmac.new(k, v, hash_f).digest()
k = hmac.new(k, v + b'\x01' + priv + h1, hash_f).digest()
v = hmac.new(k, v, hash_f).digest()
while 1:
t = bytearray()
while len(t) < order_size:
v = hmac.new(k, v, hash_f).digest()
t.extend(v)
k1 = intbytes.from_bytes(bytes(t))
k1 >>= (len(t)*8 - bit_length(n))
if k1 >= 1 and k1 < n:
return k1
k = hmac.new(k, v + b'\x00', hash_f).digest()
v = hmac.new(k, v, hash_f).digest()

Mais je ne peux pas faire confiance à un code comme ça parce que je n'ai aucune idée de ce qu'il fait. Aussi, les commentaires de l'ecdsa_sign dit que renvoie une signature compte tenu de la valeur, le secret de l'exposant, et un nonce. Cela dit il est très important d'avoir un nonce, mais j'ai juste ne peut pas trouver que le nonce est.

Est là, toute simple, d'une ligne de chemin à signer et vérifier ECDSA signatures à l'aide de quelque confiance bibliothèque python sur windows?

OriginalL'auteur Jorky10 | 2015-12-24