def do_test(secret_exponent, val_list):
public_point = secret_exponent * secp256k1_generator
for v in val_list:
signature = secp256k1_generator.sign(secret_exponent, v)
r = secp256k1_generator.verify(public_point, v, signature)
assert r is True
r = secp256k1_generator.verify(public_point, v, (signature[0], secp256k1_generator.order() - signature[1]))
assert r is True
signature = signature[0],signature[1]+1
r = secp256k1_generator.verify(public_point, v, signature)
assert r is False
def sigcheck(a_key, a_hash_for_sig, a_sig):
"""
Returns True if a_key was used to generate a_sig from a_hash_for_sig;
False otherwise.
"""
r, s = sigdecode_der(a_sig)
return secp256k1_generator.verify(a_key.public_pair(), a_hash_for_sig, (r, s))
def test_sign_simple(self):
secret_exponent = 1
public_pair = secp256k1_generator * secret_exponent
self.assertEqual(public_pair, (
55066263022277343669578718895168534326250603453777594175500187360389116729240,
32670510020758816978083085130507043184471273380659243275938904335757337482424)
)
hash_value = 1
sig = secp256k1_generator.sign(secret_exponent, hash_value)
r = secp256k1_generator.verify(public_pair, hash_value, sig)
self.assertTrue(r)
r = secp256k1_generator.verify(public_pair, hash_value, (sig[0], sig[1] ^ 1))
self.assertFalse(r)
self.assertEqual(sig[0], 46340862580836590753275244201733144181782255593078084106116359912084275628184)
self.assertIn(sig[1], [
81369331955758484632176499244870227132558660296342819670803726373940306621624,
34422757281557710791394485763817680720278903982732084711801436767577854872713
])
def sigcheck(a_key, a_hash_for_sig, a_sig):
"""
Returns True if a_key was used to generate a_sig from a_hash_for_sig;
False otherwise.
"""
r, s = sigdecode_der(a_sig)
return secp256k1_generator.verify(a_key.public_pair(), a_hash_for_sig,
(r, s))
def test_sign(self):
PART1 = ["47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"]
PART2 = [x * 64 for x in "123456789abcde"]
VAL = 28832970699858290
for se in PART1 + PART2:
secret_exponent = int(se, 16)
sig = secp256k1_generator.sign(secret_exponent, VAL)
public_pair = secp256k1_generator * secret_exponent
v = secp256k1_generator.verify(public_pair, VAL, sig)
self.assertTrue(v)
sig1 = (sig[0] + 1, sig[1])
v = secp256k1_generator.verify(public_pair, VAL, sig1)
self.assertFalse(v)
public_pairs = secp256k1_generator.possible_public_pairs_for_signature(VAL, sig)
self.assertIn(public_pair, public_pairs)
def test_verify_simple(self):
public_pair = secp256k1_generator * 1
self.assertEqual(public_pair, (
55066263022277343669578718895168534326250603453777594175500187360389116729240,
32670510020758816978083085130507043184471273380659243275938904335757337482424)
)
hash_value = 1
sig = (46340862580836590753275244201733144181782255593078084106116359912084275628184,
81369331955758484632176499244870227132558660296342819670803726373940306621624)
r = secp256k1_generator.verify(public_pair, hash_value, sig)
self.assertEqual(r, True)
def verify(self, h, sig):
"""
Return whether a signature is valid for hash h using this key.
"""
val = from_bytes_32(h)
pubkey = self.public_pair()
rs = sigdecode_der(sig)
if self.public_pair() is None:
# find the pubkey from the signature and see if it matches
# our key
possible_pubkeys = secp256k1_generator.possible_public_pairs_for_signature(val, rs)
hash160 = self.hash160()
for candidate in possible_pubkeys:
if hash160 == public_pair_to_hash160_sec(candidate, True):
pubkey = candidate
break
if hash160 == public_pair_to_hash160_sec(candidate, False):
pubkey = candidate
break
else:
# signature is using a pubkey that's not this key
return False
return secp256k1_generator.verify(pubkey, val, rs)
def verify(self, h, sig):
"""
Return whether a signature is valid for hash h using this key.
"""
val = from_bytes_32(h)
pubkey = self.public_pair()
rs = sigdecode_der(sig)
if self.public_pair() is None:
# find the pubkey from the signature and see if it matches
# our key
possible_pubkeys = secp256k1_generator.possible_public_pairs_for_signature(
val, rs)
hash160 = self.hash160()
for candidate in possible_pubkeys:
if hash160 == public_pair_to_hash160_sec(candidate, True):
pubkey = candidate
break
if hash160 == public_pair_to_hash160_sec(candidate, False):
pubkey = candidate
break
else:
# signature is using a pubkey that's not this key
return False
return secp256k1_generator.verify(pubkey, val, rs)
def verifyECDSAsecp256k1(msg, signature, pubKey): msgHash = sha3_256Hash(msg) valid = secp256k1_generator.verify(pubKey, msgHash, signature) return valid
Performs some math, based on elliptic curve calculations
Verifying a message signature
verify(public_key, msg, signature) true / false
Performs some math, based on elliptic curve calculations
"""
from pycoin.ecdsa.secp256k1 import secp256k1_generator
import hashlib
def keccak_hash(msg):
hash_bytes = hashlib.sha3_256(msg.encode("utf8")).digest()
return int.from_bytes(hash_bytes, byteorder="big")
msg = "some message"
msg_hash = keccak_hash(msg)
private_key = 9999999999999999999999999999999999999999999999
signature = secp256k1_generator.sign(private_key, msg_hash)
print("signature = ", str(signature))
public_key = secp256k1_generator * private_key
print("public key = ", str(public_key))
valid = secp256k1_generator.verify(public_key, msg_hash, signature)
print("Signature valid? ", str(valid))
tampered_msg_hash = keccak_hash("tampered msg")
valid = secp256k1_generator.verify(public_key, tampered_msg_hash, signature)
print("Signature (tampered msg) valid? ", str(valid))
