class Crypto(object):
def __init__(self):
self.G = generator_secp256k1
self._r = self.G.order()
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 export_public_key(self):
"""
serialization of public key
"""
return self.public_key.encode('hex')
def encrypt(self, message, pubkey):
return self.eck.encrypt_message(message, pubkey.decode('hex'))
def decrypt(self, message):
return self.eck.decrypt_message(message)
def hash(self, text, algorithm='sha224'):
h = hashlib.new(algorithm)
h.update(text)
return h.digest()
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 _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 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)
# # get encryption keys
# if (self.messages.encryption_keys_count() == self.number_of_players):
# self.encryption_keys = self.messages.get_encryption_keys()
# print('Player '+ str(self.number) + ' recieved all keys for test\n')
# else:
# raise Exception('Not get encryption keys!')
#
time.sleep(10)
self.mailbox.close()
HOST = "localhost"
PORT = 8080
G = generator_secp256k1
_r = G.order()
number_of_players = 3
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_pks = [eck.get_public_key(True) for eck in players_ecks]
players = dict(zip(range(number_of_players), players_pks))
playerThreads = [
protocolThread(HOST, PORT, players[player], players_ecks[player])
for player in players
]
for thread in playerThreads:
thread.start()
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)
