def test_crack_k_from_sigs(self):
k = 105
se = 181919191
gen_k = make_gen_k_const(k)
val1 = 488819181819384
val2 = 588819181819384
sig1 = secp256k1_generator.sign(se, val1, gen_k=gen_k)
sig2 = secp256k1_generator.sign(se, val2, gen_k=gen_k)
cracked_k = crack_k_from_sigs(secp256k1_generator, sig1, val1, sig2, val2)
self.assertEqual(cracked_k, k)
def test_crack_k_from_sigs(self):
k = 105
se = 181919191
gen_k = make_gen_k_const(k)
val1 = 488819181819384
val2 = 588819181819384
sig1 = secp256k1_generator.sign(se, val1, gen_k=gen_k)
sig2 = secp256k1_generator.sign(se, val2, gen_k=gen_k)
cracked_k = crack_k_from_sigs(secp256k1_generator, sig1, val1, sig2,
val2)
self.assertEqual(cracked_k, k)
def _create_script_signature(
self, secret_exponent, signature_for_hash_type_f, signature_type, script):
sign_value = signature_for_hash_type_f(signature_type, script)
order = secp256k1_generator.order()
r, s = secp256k1_generator.sign(secret_exponent, sign_value)
if s + s > order:
s = order - s
return der.sigencode_der(r, s) + int2byte(signature_type)
def test_crack_secret_exponent_from_k(self):
k = 105
se = 181919191
gen_k = make_gen_k_const(k)
val = 488819181819384
sig = secp256k1_generator.sign(se, val, gen_k=gen_k)
cracked_se = crack_secret_exponent_from_k(secp256k1_generator, val, sig, k)
self.assertEqual(cracked_se, se)
def test_custom_k(self):
secret_exponent = 1
sig_hash = 1
gen_k = lambda *args: 1
signature = secp256k1_generator.sign(secret_exponent, sig_hash, gen_k)
self.assertEqual(signature, (
55066263022277343669578718895168534326250603453777594175500187360389116729240,
55066263022277343669578718895168534326250603453777594175500187360389116729241
))
def test_crack_secret_exponent_from_k(self):
k = 105
se = 181919191
gen_k = make_gen_k_const(k)
val = 488819181819384
sig = secp256k1_generator.sign(se, val, gen_k=gen_k)
cracked_se = crack_secret_exponent_from_k(secp256k1_generator, val,
sig, k)
self.assertEqual(cracked_se, se)
def sign(self, h):
"""
Return a der-encoded signature for a hash h.
Will throw a RuntimeError if this key is not a private key
"""
if not self.is_private():
raise RuntimeError("Key must be private to be able to sign")
val = from_bytes_32(h)
r, s = secp256k1_generator.sign(self.secret_exponent(), val)
return sigencode_der(r, s)
def sign(self, h):
"""
Return a der-encoded signature for a hash h.
Will throw a RuntimeError if this key is not a private key
"""
if not self.is_private():
raise RuntimeError("Key must be private to be able to sign")
val = from_bytes_32(h)
r, s = secp256k1_generator.sign(self.secret_exponent(), val)
return sigencode_der(r, s)
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 sigmake(a_key, a_hash_for_sig, a_sig_type=SIGHASH_ALL):
"""
Signs a_hash_for_sig with a_key and returns a DER-encoded signature
with a_sig_type appended.
"""
order = secp256k1_generator.order()
r, s = secp256k1_generator.sign(a_key.secret_exponent(), a_hash_for_sig)
if s + s > order:
s = order - s
return sigencode_der(r, s) + int2byte(a_sig_type)
def sigmake(a_key, a_hash_for_sig, a_sig_type):
"""
Signs a_hash_for_sig with a_key and returns a DER-encoded signature
with a_sig_type appended.
"""
order = secp256k1_generator.order()
r, s = secp256k1_generator.sign(a_key.secret_exponent(), a_hash_for_sig)
if s + s > order:
s = order - s
return sigencode_der(r, s) + int2byte(a_sig_type)
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 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 signECDSAsecp256k1(msg, privKey): msgHash = sha3_256Hash(msg) signature = secp256k1_generator.sign(privKey, msgHash) return signature
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))
