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 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))