def _do_test_crypto(self, message):
G = generator_secp256k1
_r = G.order()
pvk = ecdsa.util.randrange( pow(2,256) ) %_r
Pub = pvk*G
pubkey_c = point_to_ser(Pub,True)
#pubkey_u = point_to_ser(Pub,False)
addr_c = public_key_to_bc_address(pubkey_c)
#addr_u = public_key_to_bc_address(pubkey_u)
#print "Private key ", '%064x'%pvk
eck = EC_KEY(number_to_string(pvk,_r))
#print "Compressed public key ", pubkey_c.encode('hex')
enc = EC_KEY.encrypt_message(message, pubkey_c)
dec = eck.decrypt_message(enc)
assert dec == message
#print "Uncompressed public key", pubkey_u.encode('hex')
#enc2 = EC_KEY.encrypt_message(message, pubkey_u)
dec2 = eck.decrypt_message(enc)
assert dec2 == message
signature = eck.sign_message(message, True, addr_c)
#print signature
EC_KEY.verify_message(addr_c, signature, message)
def _do_test_crypto(self, message):
G = generator_secp256k1
_r = G.order()
pvk = ecdsa.util.randrange(pow(2, 256)) % _r
Pub = pvk * G
pubkey_c = point_to_ser(Pub, True)
#pubkey_u = point_to_ser(Pub,False)
addr_c = public_key_to_p2pkh(pubkey_c)
#print "Private key ", '%064x'%pvk
eck = EC_KEY(number_to_string(pvk, _r))
#print "Compressed public key ", pubkey_c.encode('hex')
enc = EC_KEY.encrypt_message(message, pubkey_c)
dec = eck.decrypt_message(enc)
self.assertEqual(message, dec)
#print "Uncompressed public key", pubkey_u.encode('hex')
#enc2 = EC_KEY.encrypt_message(message, pubkey_u)
dec2 = eck.decrypt_message(enc)
self.assertEqual(message, dec2)
signature = eck.sign_message(message, True)
#print signature
EC_KEY.verify_message(eck, signature, message)
def test_000_positive_test(self):
begin_phase = Phase('Announcement')
amount = 1000
fee = 1
# generate fake signing keys
G = generator_secp256k1
_r = G.order()
number_of_players = 4
players_pvks = [
ecdsa.util.randrange(pow(2, 256)) % _r
for i in range(number_of_players)
]
players_ecks = [
EC_KEY(number_to_string(pvk, _r)) for pvk in players_pvks
]
players_new_pvks = [
ecdsa.util.randrange(pow(2, 256)) % _r
for i in range(number_of_players)
]
players_change_pvks = [
ecdsa.util.randrange(pow(2, 256)) % _r
for i in range(number_of_players)
]
players_changes = [
public_key_to_p2pkh(point_to_ser(pvk * G, True))
for pvk in players_change_pvks
]
players_new_addresses = [
public_key_to_p2pkh(point_to_ser(pvk * G, True))
for pvk in players_new_pvks
]
players_pks = [eck.get_public_key(True) for eck in players_ecks]
players = dict(zip(range(number_of_players), players_pks))
print("\n")
# serverThread = fakeServerThread(HOST, PORT, number_of_players = number_of_players)
#( host, port, vk, amount, fee, sk, addr_new, change)
playerThreads = [
protocolThread(HOST, PORT, players[player], amount, fee,
players_ecks[player], players_new_addresses[player],
players_changes[player]) for player in players
]
# serverThread.start()
for thread in playerThreads:
thread.start()
# serverThread.join()
self.assertTrue(True)
def generate_key_pair(self):
self.private_key = ecdsa.util.randrange(pow(2, 256)) % self._r
self.eck = EC_KEY(number_to_string(self.private_key, self._r))
self.public_key = point_to_ser(self.private_key * self.G, True)
def verify_signature(self, sig, message, vk):
pk, compressed = pubkey_from_signature(sig, Hash(msg_magic(message)))
address_from_signature = public_key_to_p2pkh(point_to_ser(pk.pubkey.point, compressed))
address_from_vk = self.address(vk)
return address_from_signature == address_from_signature
