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 bytes.hex(self.public_key)
def encrypt(self, message, pubkey):
res = self.eck.encrypt_message(message.encode('utf-8'),
bytes.fromhex(pubkey))
return res.decode('utf-8')
def decrypt(self, message):
return self.eck.decrypt_message(message)
def hash(self, text, algorithm='sha224'):
h = hashlib.new(algorithm)
h.update(text.encode('utf-8'))
return h.digest()
class Crypto:
""" Functions related to cryptography """
def __init__(self):
self.G = generator_secp256k1
self._r = self.G.order()
self.private_key, self.eck, self.public_key = None, None, None
def generate_key_pair(self):
""" generate encryption/decryption pair """
self.private_key = ecdsa.util.randrange(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_private_key(self):
""" Export private key as hex string """
if self.private_key:
return bytes.hex(number_to_string(self.private_key, self._r))
else:
return None
def restore_from_privkey(self, secret_string):
"restore key pair from private key expressed in a hex form"
self.private_key = string_to_number(bytes.fromhex(secret_string))
self.eck = EC_KEY(bytes.fromhex(secret_string))
self.public_key = point_to_ser(self.private_key * self.G, True)
def export_public_key(self):
""" serialization of public key """
return bytes.hex(self.public_key)
def encrypt(self, message, pubkey):
""" encrypt message with pubkey """
try:
res = self.eck.encrypt_message(message.encode('utf-8'),
bytes.fromhex(pubkey))
return res.decode('utf-8')
except Exception as e: # grrr.. bitcoin.py raises 'Exception' :/
raise EncryptError(
"Bitcoin.py raised '{}' during Crypto.encrypt".format(
type(e).__name__), e, pubkey, message) from e
def decrypt(self, message):
""" decrypt message """
try:
return self.eck.decrypt_message(message)
except (InvalidPassword, Exception) as e:
raise DecryptError(
"Bitcoin.py raised '{}' during Crypto.decrypt".format(
type(e).__name__), e, self.private_key, message) from e
@staticmethod
def hash(text):
''' Returns sha256(sha256(text)) as bytes. text may be bytes or str. '''
return Hash(text) # bitcoin.Hash is sha256(sha256(x))
class Crypto(object):
"""
This class used for tasks related to cryptography
"""
def __init__(self):
self.G = generator_secp256k1
self._r = self.G.order()
def generate_key_pair(self):
"generate encryption/decryption pair"
self.private_key = ecdsa.util.randrange(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_private_key(self):
"Export private key as hex string"
if self.private_key:
return bytes.hex(number_to_string(self.private_key, self._r))
else:
return None
def restore_from_privkey(self, secret_string):
"restore key pair from private key expressed in a hex form"
self.private_key = string_to_number(bytes.fromhex(secret_string))
self.eck = EC_KEY(bytes.fromhex(secret_string))
self.public_key = point_to_ser(self.private_key * self.G, True)
def export_public_key(self):
"""
serialization of public key
"""
return bytes.hex(self.public_key)
def encrypt(self, message, pubkey):
"encrypt message with pubkey"
res = self.eck.encrypt_message(message.encode('utf-8'),
bytes.fromhex(pubkey))
return res.decode('utf-8')
def decrypt(self, message):
"decrypt message"
return self.eck.decrypt_message(message)
def hash(self, text, algorithm='sha224'):
"method for hashing the text"
h = hashlib.new(algorithm)
h.update(text.encode('utf-8'))
return h.digest()
class Crypto_cheater(Crypto):
"""
This class is faking the Crypto. It needs for cheating on encryption decryption phase
"""
def generate_fake_key_pair(self):
self.fake_private_key = ecdsa.util.randrange( pow(2,256) ) %self._r
self.fake_eck = EC_KEY(number_to_string(self.fake_private_key, self._r))
self.fake_public_key = point_to_ser(self.fake_private_key*self.G,True)
def export_fake_public_key(self):
return bytes.hex(self.fake_public_key)
def decrypt(self, message):
try:
return self.eck.decrypt_message(message)
except InvalidPassword:
return self.fake_eck.decrypt_message(message)
def __init__(self, window, wallet, network_settings,
period = 10.0, logger = None, password=None, timeout=60.0,
typ=Messages.DEFAULT # NB: Only DEFAULT is currently supported
):
super().__init__()
cls = type(self)
self.daemon = True
self.timeout = timeout
self.version = cls.PROTOCOL_VERSION + (1 if networks.net.TESTNET else 0)
self.type = typ
assert self.type == Messages.DEFAULT, "BackgroundShufflingThread currently only supports DEFAULT shuffles"
cls.latest_shuffle_settings = cls.ShuffleSettings(self.type, Messages.TYPE_NAME_DICT[self.type], self.version, 0, 0, self.FEE)
# set UPPER_BOUND and LOWER_BOUND from config keys here. Note all instances will see these changes immediately.
cls.update_lower_and_upper_bound_from_config()
self.period = period
self.logger = logger
self.wallet = wallet
self.window = window
self.host = network_settings.get("host", None)
self.info_port = network_settings.get("info", None)
self.port = 1337 # default value -- will get set to real value from server's stat port in run() method
self.poolSize = 3 # default value -- will get set to real value from server's stat port in run() method
self.banScore = 0 # comes from stats port -- our own personal ban score
self.banned = False # comes from stats port. True if our IP is banned (default ban duration: 30 mins)
self.ssl = network_settings.get("ssl", None)
self.lock = threading.RLock()
self.password = password
self.threads = {scale:None for scale in self.scales}
self.shared_chan = Channel(switch_timeout=None) # threads write a 3-tuple here: (killme_flg, thr, msg)
self.stop_flg = threading.Event()
self.last_idle_check = 0.0 # timestamp in seconds unix time
self.done_utxos = dict()
self._paused = False
self._coins_busy_shuffling = set() # 'prevout_hash:n' (name) set of all coins that are currently being shuffled by a ProtocolThread. Both wallet locks should be held to read/write this.
self._last_server_check = 0.0 # timestamp in seconds unix time
self._dummy_address = Address.from_pubkey(EC_KEY(number_to_string(1337, generator_secp256k1.order())).get_public_key()) # dummy address
# below 4 vars are related to the "delayed unreserve address" mechanism as part of the bug #70 & #97 workaround and the complexity created by it..
self._delayed_unreserve_addresses = dict() # dict of Address -> time.time() timestamp when its shuffle ended
self._last_delayed_unreserve_check = 0.0 # timestamp in seconds unix time
self._delayed_unreserve_check_interval = 60.0 # check these addresses every 60 seconds.
self._delayed_unreserve_timeout = 600.0 # how long before the delayed-unreserve addresses expire; 10 minutes
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 __init__(self):
G = generator_secp256k1
_r = G.order()
pvk = ecdsa.util.randrange( pow(2,256) ) %_r
eck = EC_KEY.__init__(self, number_to_string(pvk,_r))
def restore_from_privkey(self, secret_string):
self.private_key = string_to_number(bytes.fromhex(secret_string))
self.eck = EC_KEY(bytes.fromhex(secret_string))
self.public_key = point_to_ser(self.private_key * self.G, True)
def restore_from_privkey(self, secret_string):
"restore key pair from private key expressed in a hex form"
self.private_key = string_to_number(bytes.fromhex(secret_string))
self.eck = EC_KEY(bytes.fromhex(secret_string))
self.public_key = point_to_ser(self.private_key * self.G, True)
def generate_key_pair(self):
""" generate encryption/decryption pair """
self.private_key = ecdsa.util.randrange(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 generate_random_sk():
G = generator_secp256k1
_r = G.order()
pvk = ecdsa.util.randrange( _r )
eck = EC_KEY(number_to_string(pvk, _r))
return eck
def generate_fake_key_pair(self):
self.fake_private_key = ecdsa.util.randrange(self._r)
self.fake_eck = EC_KEY(number_to_string(self.fake_private_key,
self._r))
self.fake_public_key = point_to_ser(self.fake_private_key * self.G,
True)
