def eccGenerate(self):
'''Generates Elliptic Curve Public/Private Keys'''
ecc = ECC.generate()
publicKey = ecc._public
privateKey = ecc._private
curve = ecc._curve
return privateKey, publicKey, curve
def eccGenerate(self):
'''Generates Elliptic Curve Public/Private Keys'''
ecc = ECC.generate()
publicKey = ecc._public
privateKey = ecc._private
curve = ecc._curve
return privateKey, publicKey, curve
def __init__(self, address):
self.ecc = ECC.generate()
self.publicKey = self.ecc._public
self.privateKey = self.ecc._private
self.curve = self.ecc._curve
self.node_id = hashlib.sha1(publicKey).digest()
self.node_id_hex = binascii.b2a_hex(self.node_id_b)
self.socket_path = os.path.join("nodes", node_id)
self.address = address
def __init__(self, key = None):
if key is None:
self.key = ASymKey()
else:
self.key = key
private = ''
self.no_private = True
if isinstance(self.key.private, str):
private = self.key.private
self.no_private = False
self.ecc = ECC(public=self.key.public,
private=private,
curve=self.key.curve)
class ASymEnc:
def __init__(self, key = None):
if key is None:
self.key = ASymKey()
else:
self.key = key
private = ''
self.no_private = True
if isinstance(self.key.private, str):
private = self.key.private
self.no_private = False
self.ecc = ECC(public=self.key.public,
private=private,
curve=self.key.curve)
def encrypt(self, data):
if self.no_private:
raise Exception("Encryption requires a private key")
encrypted = self.ecc.encrypt(data)
encrypted = ASymEncData(self.key.curve, encrypted)
encrypted = EncResult(encrypted, self.key.hmac_key)
return encrypted
def decrypt(self, data):
decrypted = EncResult(data, self.key.hmac_key)
if decrypted.verify():
decrypted = self.ecc.decrypt(data.enc_data.data)
return decrypted
else:
raise Exception('HMAC invalid')
def sign(self, data):
if self.no_private:
raise Exception("Signing requires a private key")
signature = self.ecc.sign(data)
return base64.b64encode(signature)
def verify(self, data, signature):
return self.ecc.verify(data, base64.b64decode(signature))
def __init__(self, key = None):
if key is None:
self.ecc = ECC.generate()
self.public = self.ecc._public
self.private = self.ecc._private
self.curve = self.ecc._curve
else:
self.public = key['public']
self.private = key['private']
self.curve = key['curve']
self.hmac_key = None
if isinstance(self.private, str):
h = SHA256.new()
h.update(self.private)
self.hmac_key = h.digest()
return [ Node.factory(y[0], y[1]) for y in [ x.split(':') for x in val.split(' ') ] ]
def generate_response(self, val):
val = binascii.a2b_hex(val)
closeness = [(binascii.b2a_hex(xor_str(val, self.node.node_id)), node) for node in known_nodes]
closeness = sorted(closeness, key=lambda x: x[0])
nodelist = (' '.join(["%s:%s" % (x[1], known_nodes[x[1]]) for x in closeness]))
return nodelist
class AUTH:
def __init__(self, node):
self.node = node
def do(self, node):
# Should research how good this is
ecc = ECC.generate()
publicKey = ecc._public
privateKey = ecc._private
curve = ecc._curve
print("Priv",privateKey)
print("Pub",publicKey)
print("Curve:",curve)
# maybe sha512?
node_id = hashlib.sha1(publicKey).hexdigest()
print("Node ID:", node_id)
socket_path = os.path.join("nodes", node_id)
print("Socket:", socket_path)
def not_str(s):
return ''.join(chr(0xFF & ~ord(a)) for a in s)
def eccVerify(self, publicKey, curve, data, signature):
'''Verifies ECC Signature based on Data received - Returns a Boolean Value'''
ecc = ECC(1, public=publicKey, private='', curve=curve)
return ecc.verify(data, signature)
def eccSign(self, privateKey, curve, data):
'''ECC Signing - Returns an ECC Signature'''
ecc = ECC(1, public='', private=privateKey, curve=curve)
signature = ecc.sign(data)
return signature
def eccDecrypt(self, privateKey, curve, data):
'''Decrypts Data with ECC private key'''
ecc = ECC(1, public='', private=privateKey, curve=curve)
decrypted = ecc.decrypt(data)
return decrypted
def eccEncrypt(self, publicKey, curve, data):
'''Encrypts Data with ECC using public key'''
ecc = ECC(1, public=publicKey, private='', curve=curve)
encrypted = ecc.encrypt(data)
return encrypted
def eccVerify(self, publicKey, curve, data, signature):
'''Verifies ECC Signature based on Data received - Returns a Boolean Value'''
ecc = ECC(1, public=publicKey, private='', curve=curve)
return ecc.verify(data, signature)
def eccSign(self, privateKey, curve, data):
'''ECC Signing - Returns an ECC Signature'''
ecc = ECC(1, public='', private=privateKey, curve=curve)
signature = ecc.sign(data)
return signature
def eccDecrypt(self,privateKey, curve, data):
'''Decrypts Data with ECC private key'''
ecc = ECC(1, public='', private=privateKey, curve=curve)
decrypted = ecc.decrypt(data)
return decrypted
def eccEncrypt(self,publicKey, curve, data):
'''Encrypts Data with ECC using public key'''
ecc = ECC(1, public=publicKey, private='', curve=curve)
encrypted = ecc.encrypt(data)
return encrypted
