def test_merkle_tree():
sender_key = ECC.generate(curve='P-256')
sender_address = Address(bytes(sender_key.public_key().export_key(format='DER')))
receiver_key = ECC.generate(curve='P-256')
receiver_address = Address(bytes(receiver_key.public_key().export_key(format='DER')))
transaction1 = Transaction(sender_address, receiver_address, 100, b'random', None)
transaction1.sign(sender_key)
transaction2 = Transaction(sender_address, receiver_address, 50, b'random', None)
transaction2.sign(sender_key)
transaction3 = Transaction(receiver_address, sender_address, 10, b'random', None)
transaction3.sign(receiver_key)
transaction4 = Transaction(sender_address, receiver_address, 60, b'random', None)
transaction4.sign(sender_key)
transaction5 = Transaction(receiver_address, sender_address, 80, b'random', None)
transaction5.sign(receiver_key)
tree = MerkleTree([transaction1, transaction2, transaction3, transaction4, transaction5])
assert tree.root.left is not None
assert tree.root.left.left.left.hash == bytes(transaction1.hash().digest())
assert tree.root.left.left.right.hash == bytes(transaction2.hash().digest())
assert tree.root.left.right.left.hash == bytes(transaction3.hash().digest())
assert tree.root.left.right.right.hash == bytes(transaction4.hash().digest())
assert tree.root.right.hash == bytes(transaction5.hash().digest())
def test_deep_pki():
root_key = ECC.generate(curve='P-256')
root = Issuer(bytes(root_key.export_key(format='DER')))
issuer2_key = ECC.generate(curve='P-256')
issuer2_key_bytes = bytes(issuer2_key.export_key(format='DER'))
issuer2_public_key_bytes = bytes(
issuer2_key.public_key().export_key(format='DER'))
issuer2 = Issuer(issuer2_key_bytes, root.issue(issuer2_public_key_bytes))
issuer3_key = ECC.generate(curve='P-256')
issuer3_key_bytes = bytes(issuer3_key.export_key(format='DER'))
issuer3_public_key_bytes = bytes(
issuer3_key.public_key().export_key(format='DER'))
issuer3 = Issuer(issuer3_key_bytes,
issuer2.issue(issuer3_public_key_bytes))
holder_key = ECC.generate(curve='P-256')
holder = Holder(bytes(holder_key.export_key(format='DER')))
certs = issuer3.issue(holder.public_key())
holder.set_cert(certs)
verifier = Verifier(root.public_key())
nonce = b'20201111'
certs, sign = holder.present(nonce)
assert len(root.cert_chain) == 0
assert len(issuer2.cert_chain) == 1
assert len(issuer3.cert_chain) == 2
assert len(holder.cert) == 3
assert verifier.verify(certs, holder.public_key(), nonce, sign)
def test_merkle_root():
sender_key = ECC.generate(curve='P-256')
sender_address = Address(bytes(sender_key.public_key().export_key(format='DER')))
receiver_key = ECC.generate(curve='P-256')
receiver_address = Address(bytes(receiver_key.public_key().export_key(format='DER')))
transaction1 = Transaction(sender_address, receiver_address, 100, b'random', None)
transaction1.sign(sender_key)
transaction2 = Transaction(sender_address, receiver_address, 50, b'random', None)
transaction2.sign(sender_key)
transaction3 = Transaction(receiver_address, sender_address, 10, b'random', None)
transaction3.sign(receiver_key)
transaction4 = Transaction(sender_address, receiver_address, 60, b'random', None)
transaction4.sign(sender_key)
tree = MerkleTree([transaction1, transaction2, transaction3, transaction4])
h1 = SHA256.new()
h1.update(transaction1.hash().digest())
h1.update(transaction2.hash().digest())
h2 = SHA256.new()
h2.update(transaction3.hash().digest())
h2.update(transaction4.hash().digest())
h3 = SHA256.new()
h3.update(h1.digest())
h3.update(h2.digest())
root = h3.digest()
assert tree.merkle_root() == root
def _derive_key(pw, sa, for_):
"""derives the ECC public key from the password using the salt.
@pw (byte string): password
@sa (byte string): salt (must be >= 16 bytes long)
@for_ (string): allowed values, ('encryption', 'decryption',
'verify', 'sign', 'both)
@Returns: the pwhash and one or two ECC element (depending on the for_)
"""
curve = 'secp256r1' #
intermediate_hash = PBKDF2(pw, sa, dkLen=16, count=HASH_CNT) # SLOW
pwhash = hash256(
intermediate_hash) # The last hash to be stored in the cache
seed_enc = hash256(intermediate_hash, b'encryption|decryption')
seed_sgn = hash256(intermediate_hash, b'sign|verify')
prg_enc = RandomWSeed(seed_enc, 1024)
prg_sgn = RandomWSeed(seed_sgn, 1024)
if for_ == 'both':
return (pwhash, (ECC.generate(curve=curve,
randfunc=prg_enc.get_random_bytes),
ECC.generate(curve=curve,
randfunc=prg_sgn.get_random_bytes)))
elif for_ in ('encryption', 'decryption'):
return pwhash, ECC.generate(curve=curve,
randfunc=prg_enc.get_random_bytes)
elif for_ in ('sign', 'verify'):
return pwhash, ECC.generate(curve=curve,
randfunc=prg_sgn.get_random_bytes)
def test_generate(self):
key = ECC.generate(curve="P-256")
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, EccPoint(_curve.Gx, _curve.Gy) * key.d)
# Other names
ECC.generate(curve="secp256r1")
ECC.generate(curve="prime256v1")
def test_generate(self):
key = ECC.generate(curve="P-256")
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, EccPoint(_curve.Gx, _curve.Gy) * key.d)
# Other names
ECC.generate(curve="secp256r1")
ECC.generate(curve="prime256v1")
def test_generate(self):
curve = _curves['p521']
key = ECC.generate(curve="P-521")
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, EccPoint(curve.Gx, curve.Gy, "p521") * key.d)
# Other names
ECC.generate(curve="secp521r1")
ECC.generate(curve="prime521v1")
def test_generate(self):
curve = _curves['p521']
key = ECC.generate(curve="P-521")
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, EccPoint(curve.Gx, curve.Gy, "p521") * key.d)
# Other names
ECC.generate(curve="secp521r1")
ECC.generate(curve="prime521v1")
def test_generate(self):
curve = _curves['p384']
key = ECC.generate(curve="P-384")
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, EccPoint(curve.Gx, curve.Gy, "p384") * key.d)
# Other names
ECC.generate(curve="secp384r1")
ECC.generate(curve="prime384v1")
def test_generate(self):
key = ECC.generate(curve="P-256")
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, EccPoint(_curves['p256'].Gx,
_curves['p256'].Gy) * key.d,
"p256")
# Other names
ECC.generate(curve="secp256r1")
ECC.generate(curve="prime256v1")
def test_generate(self):
key = ECC.generate(curve="P-256")
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, EccPoint(_curves['p256'].Gx,
_curves['p256'].Gy) * key.d,
"p256")
# Other names
ECC.generate(curve="secp256r1")
ECC.generate(curve="prime256v1")
def test_generate(self):
key = ECC.generate(curve="P-192")
self.assertTrue(key.has_private())
self.assertEqual(
key.pointQ,
EccPoint(_curves['p192'].Gx, _curves['p192'].Gy, "P-192") * key.d,
"p192")
# Other names
ECC.generate(curve="secp192r1")
ECC.generate(curve="prime192v1")
def test_pki():
root_key = ECC.generate(curve='P-256')
root = Issuer(bytes(root_key.export_key(format='DER')))
holder_key = ECC.generate(curve='P-256')
holder = Holder(bytes(holder_key.export_key(format='DER')))
certs = root.issue(holder.public_key())
holder.set_cert(certs)
verifier = Verifier(root.public_key())
nonce = b'123'
certs, sign = holder.present(nonce)
assert verifier.verify(certs, holder.public_key(), nonce, sign)
def test_mix(self):
p1 = ECC.generate(curve='P-256').pointQ
p2 = ECC.generate(curve='P-384').pointQ
try:
p1 + p2
assert(False)
except ValueError as e:
assert "not on the same curve" in str(e)
try:
p1 += p2
assert(False)
except ValueError as e:
assert "not on the same curve" in str(e)
def generate_keys():
key = ECC.generate(curve='P-256')
private_key = key.export_key(format='PEM')
public_key = key.public_key().export_key(format='PEM')
return private_key, public_key
def test_no_ca():
holder_key = ECC.generate(curve='P-256')
holder = Holder(bytes(holder_key.export_key(format='DER')))
verifier = Verifier(b'')
nonce = b'20201111'
certs, sign = holder.present(nonce)
assert not verifier.verify(certs, holder.public_key(), nonce, sign)
def verify(self, message):
key = ECC.generate(
curve='P-521'
) #Genera una nueva llave privada usando la curva definida por P-521
h = SHA512.new(message) #Genera la función Hash del mensaje.
signer = DSS.new(
key, 'fips-186-3') #Crea un objeto signature para hacer la firma.
signature = signer.sign(h) #Genera la firma del mensaje.
pubKey = key.public_key(
) #Obtiene la llave pública del par generado almacenado en "key".
start_time = timer() #Función que permite iniciar una toma de tiempo.
verifier = DSS.new(
pubKey, 'fips-186-3'
) #Crea un objeto signature para hacer la validación de la firma.
try:
verifier.verify(
h, signature
) #Hace la comparación entre el hash del mensaje y la firma.
print("La firma se pudo validar, es correcta.")
self.executionTime = timer(
) - start_time #Fin de la toma de tiempo.
return 1
except (
ValueError
): #Accede en caso de que los valores no sean correctos, es decir, la firma no es válida.
print("La firma no se pudo validar, no es correcta")
self.executionTime = timer(
) - start_time #Fin de la toma de tiempo.
return 0
def test():
key = ECC.generate(curve='secp256r1')
print key.public_key()
x = key.public_key().pointQ.x
y = key.public_key().pointQ.y
hx=hex(int(str(x)))
bytearray.fromhex(hx[2:64])[::-1]
reversed_arr=result[::-1]
x=key.public_key().pointQ.x
hx=hex(int(str(x)))
rx = bytearray.fromhex(hx[2:66])[::-1]
y=key.public_key().pointQ.y
hy=hex(int(str(y)))
ry = bytearray.fromhex(hy[2:66])[::-1]
''.join('{:02x}'.format(x) for x in rx+ry)
addr=SHA256.new(rx+ry).hexdigest()[:40]
"".join("{:02x}".format(ord(c)) for c in pps)
p = ECC.construct(curve='secp256r1',d=70054409939411066367955879351487264564474994114056648764946442729447023254584)
signer = DSS.new(p, 'fips-186-3')
pps=signer.sign(h)
def __gen_sym_key(device_public_key_string_xy):
_ECC_CURVE = 'secp256r1'
# Construct ECC point from device public key
device_kpub_int_x = int.from_bytes(device_public_key_string_xy[:32], byteorder='big')
device_kpub_int_y = int.from_bytes(device_public_key_string_xy[32:], byteorder='big')
device_kpub_p = ECC.construct(curve=_ECC_CURVE, point_x=device_kpub_int_x, point_y=device_kpub_int_y)
# Create user private / public key pair
user_key_pair = ECC.generate(curve=_ECC_CURVE)
# The shared secret is calculated using the device public point and the private key.
# The secret is the x-coordinate of the resulting point
shared_secret_int = (device_kpub_p.pointQ * user_key_pair.d).x
# Calculate symmetric key from shared secret using hmac-sha256 and static data "config"
shared_secret_string = int(shared_secret_int).to_bytes(32, byteorder='big')
h = HMAC.new(shared_secret_string, msg=b'config', digestmod=SHA256)
# Truncate to get shared private key (16 bytes)
symmetric_key = h.digest()[0:16]
# Create public key byte strings
user_kpub_string_x = int(user_key_pair.pointQ.x).to_bytes(32, byteorder='big')
user_kpub_string_y = int(user_key_pair.pointQ.y).to_bytes(32, byteorder='big')
return symmetric_key, user_kpub_string_x + user_kpub_string_y
def generate_from_pw(pw, salt, curve='P-256'):
"""Generates a ECC key pair using the randomness derived from pw, salt.
"""
rand_seed = PBKDF2(pw, salt, dkLen=16, count=HASH_CNT)
rand_num_generator = RandomWSeed(rand_seed, 1024)
return ECC.generate(curve=curve,
randfunc=rand_num_generator.get_random_bytes)
def setUpFiles(cls):
cls.test_file_dir = os.path.join(os.path.dirname(__file__), "..",
"testfiles")
cls.test_file_dir = os.path.realpath(cls.test_file_dir)
if not os.path.exists(cls.test_file_dir):
os.mkdir(cls.test_file_dir)
cls.private_key_passphrase = 'test-passphrase'
cls.rsa_key_path = os.path.join(cls.test_file_dir, 'rsa.pem')
cls.rsa4096_key_path = os.path.join(cls.test_file_dir, 'rsa4096.pem')
cls.ec_p521_key_path = os.path.join(cls.test_file_dir, 'ecP521.pem')
if not os.path.exists(cls.rsa_key_path):
with open(cls.rsa_key_path, 'w') as f:
f.write(RSA_TEST_PRIVATE_KEY)
if not os.path.exists(cls.rsa4096_key_path):
key = RSA.generate(4096)
private_key = key.export_key(passphrase=cls.private_key_passphrase,
protection='PEM')
with open(cls.rsa4096_key_path, "wb") as f:
f.write(private_key)
if not os.path.exists(cls.ec_p521_key_path):
key = ECC.generate(curve='P-521')
private_key = key.export_key(
format='PEM',
passphrase=cls.private_key_passphrase,
use_pkcs8=True,
protection='PBKDF2WithHMAC-SHA1AndAES128-CBC')
with open(cls.ec_p521_key_path, "wt") as f:
f.write(private_key)
def ecc_pem_generate(length: int) -> tuple:
ecc = ECC.generate(curve=f"P-{length}")
private_pem = ecc.export_key(format="PEM")
public_pem = ecc.public_key().export_key(format="PEM")
return public_pem, private_pem
def create_key(algo, algotype):
#algo is type <str> can be "RSA" or "ECC"
#algotype is type <str> could be "P-256" for ECC algo, or "2048" for RSA algo
#returns 2 encodings of the same generated keys
if algo == "RSA":
key = RSA.generate(int(algotype))
private_key_der = key.export_key(format='DER')
private_key_pem = key.export_key(format='PEM')
public_key_PEM = key.publickey().export_key(format='PEM')
public_key_DER = key.publickey().export_key(format='DER')
elif algo == "ECC":
key = ECC.generate(curve=algotype)
private_key_der = key.export_key(format='DER')
private_key_pem = key.export_key(format='PEM')
public_key = ECC.import_key(private_key_der).public_key()
public_key_PEM = public_key.export_key(format='PEM')
public_key_DER = public_key.export_key(format='DER')
else:
print("This crypto is not implemented, try 'RSA' or 'ECC' ")
return False
return {
'pubkDER': public_key_DER,
'pkeyDER': private_key_der,
'pubkPEM': public_key_PEM,
'pkeyPEM': private_key_pem,
'algo': algo,
'algotype': algotype
}
def create_ecc_pair(curve_type: str):
while True:
ecc_key_pair = ECC.generate(curve=curve_type)
private_key = ecc_key_pair.d.to_bytes()
if len(private_key) == 32:
break
return ecc_key_pair
def sign_up(request):
if request.method == "POST":
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
email = request.POST.get('email')
password = request.POST.get('password')
user_obj = User.objects.create(first_name=first_name, last_name=last_name, username=email, email=email)
user_obj.set_password(password)
user_obj.save()
user_details_obj = UserDetail.objects.create(user=user_obj)
# Generate Private key
name = "{}_{}".format(user_obj.first_name, user_obj.last_name)
key = ECC.generate(curve='P-256')
private_key = key.export_key(format='PEM')
print('**********************')
print(private_key)
print('**********************')
# Generate Public Key
f = open('utils/public_' + name + '.pem', 'wt')
f.write(key.public_key().export_key(format='PEM'))
f.close()
user_details_obj.public_key = key.public_key().export_key(format='PEM')
user_details_obj.save()
messages.success(request, 'User Sign Up success..!')
return redirect('/')
elif request.method == "GET":
return render(request, 'welcome/sign_up.html')
def process_request_alias(author: AccountId, message: str, server: Server, **kwargs):
"""Processes a request for an alias code."""
account = assert_is_account(author, server)
split_msg = message.split()
if len(split_msg) != 2:
raise CommandException('Incorrect formatting. Expected `request-alias ALIAS_ACCOUNT_NAME`.')
_, alias_name = split_msg
alias_id = parse_account_id(alias_name)
if server.has_account(alias_id):
raise CommandException(
'An account has already been associated with %s, so it cannot be an alias for this account.' %
alias_id.readable())
# To generate an alias code, we generate an ECC public/private key pair, use the
# private key to generate a signed version of the aliased account name and associate
# the public key with the account.
key = ECC.generate(curve='P-256')
signature = sign_message(str(alias_id), key)
server.add_public_key(account, key.public_key())
# At this point we will allow the private key to be forgotten.
# Compose a helpful message for as to how the bot can be contacted to link accounts.
if isinstance(alias_id, RedditAccountId):
contact_message = 'Send me that exact command as a Reddit Private Message (not a direct chat) from %s.' % alias_id.readable()
elif isinstance(alias_id, DiscordAccountId):
contact_message = 'Send me that exact command prefixed with a mention of my name via Discord from account %s.' % alias_id
else:
contact_message = ''
return ('I created an alias request code for you. '
'Make {0} an alias for this account ({2}) by sending me the following message from {3}.\n\n```\nadd-alias {4} {1}\n```\n\n{5}').format(
str(alias_id), signature, author.readable(), alias_id.readable(), str(author), contact_message)
def fill_key_pool(self):
num_needed = self.key_poll_len - len(self.key_pool)
if num_needed > 0:
self.logger.info("Filling session key pool, %d" % num_needed)
for _ in range(num_needed):
key = ECC.generate(curve='P-256')
self.key_pool.append(key)
def generate_key_pair(passphrase):
key = ECC.generate(curve='P-256')
private_key = key.export_key(passphrase=passphrase,
format='PEM',
protection="PBKDF2WithHMAC-SHA1AndAES128-CBC")
public_key = key.public_key().export_key(format='OpenSSH')
return (public_key, private_key)
def ECDSA_521(data):
times = []
key = ECC.generate(curve='P-521')
h = SHA512.new(data)
controler = DSS.new(key, 'fips-186-3')
start = time.clock()
signature = controler.sign(h)
end = time.clock()
print(signature.hex())
times.append(end - start)
try:
start = time.clock()
controler.verify(h, signature)
end = time.clock()
print('The message is authentic')
except ValueError:
print('The message is not authentic')
times.append(end - start)
return times
def make_address(prefix: 'string') -> 'string':
"""
generates a Helium address from a ECC public key in PEM format.
prefix is a single numeric character which describes the type of
the address. This prefix must be '1'
"""
key = ECC.generate(curve='P-256')
__private_key = key.export_key(format='PEM')
public_key = key.public_key().export_key(format='PEM')
val = make_SHA256_hash(public_key)
val = make_RIPEMD160_hash(val)
tmp = prefix + val
# make a checksum
checksum = make_SHA256_hash(tmp)
checksum = checksum[len(checksum) - 4:]
# add the checksum to the tmp result
address = tmp + checksum
# encode addr as a base58 sequence of bytes
address = base58.b58encode(address.encode())
# The decode function converts a byte sequence to a string
address = address.decode("ascii")
return address
def make_p256_keys_pbkdf2_branched(password, salt, key_amount = 1, branches = [410]):
'''
Make P-256 multiple key pairs at once from any string
Brances implements additional layer of security. Branch is better be an integer, but, for real, it may be any string
Returns a list
'''
# password = sha000(password, 50)
# salt = SHA256.new(password.encode()).digest()
#print('salt',benc.encode(salt))
count = int(str(int(benc.encode(salt),16))[0:5])
master_key = PBKDF2(password, salt = str(salt), count=count)
def my_rand(n):
my_rand.counter += 1
return PBKDF2(master_key, "my_rand:%d" % my_rand.counter, dkLen=n, count=1)
my_rand.counter = 0
keys = []
with progressbar.ProgressBar(max_value=key_amount) as bar_small:
for tymes in range(key_amount):
bar_small.update(tymes)
key = PBKDF2(password, salt = (str(salt) + str(branches[tymes%len(branches)])), count = count)
keys.append(ECC.generate(curve = 'P-256', randfunc=my_rand))
password = key
return list(enumerate(keys, start=1))
def test_mix(self):
p1 = ECC.generate(curve='P-256').pointQ
p2 = ECC.generate(curve='P-384').pointQ
try:
p1 + p2
assert (False)
except ValueError as e:
assert "not on the same curve" in str(e)
try:
p1 += p2
assert (False)
except ValueError as e:
assert "not on the same curve" in str(e)
def encrypt(_pk_dict, msg):
"""
@pk_dict (dict): is a dictionary of id->pk, which will be used to encrypt
a message. pk's in the dict can be EccKey or basestring
@msg (byte string): a message to be encrypted
"""
# make a semi-deep copy of the pks
pk_dict = {k: v for k, v in _pk_dict.items()}
# First AES-128 encrypt the message with a random key
aes_k = os.urandom(32) # 32 byte = 256 bit
# IV is not required for EAX mode
nonce = os.urandom(16) # the key is generated random every time so, small
# nonce is OK
ctx, tag = AES.new(key=aes_k, mode=AES.MODE_EAX, nonce=nonce)\
.encrypt_and_digest(msg)
serialized_msgctx = nonce + tag + ctx
# In case pks are serialized, convert them to ecc keys
for k, v in pk_dict.items():
if not isinstance(v, ECC.EccKey):
pk_dict[k] = ECC.import_key(v)
# Now encrypt the key with pks in pk_dict
assert len(pk_dict) > 0
assert len(set((pk.curve for pk in pk_dict.values()))) == 1
sample_pk = pk_dict.values()[0]
rand_point = ECC.generate(curve=sample_pk.curve)
# It is always 161 bytes, extra few bytes in case we run into issues
serialized_rand_point = serialize_pub_key(rand_point.public_key())
def _encrypt_w_one_pk(pk):
if isinstance(pk, basestring):
pk = ECC.import_key(pk)
new_point = pk.pointQ * rand_point.d
ki = hash256(str(new_point.x), str(new_point.y))
return aes1block(ki, aes_k, op='encrypt') # iv = 32 '0'-s
# Hash the ids and take first four bytes, just in case ids are too big.
# CAUTION: this is valid only if the size of pk_dict is <= 65536
pkctx = {
hash256(unicode(_id))[:4]: _encrypt_w_one_pk(pk)
for _id, pk in pk_dict.items()
}
assert all(map(lambda v: len(v) == 32, pkctx.values()))
serialized_pkctx = ''.join(k + v for k, v in pkctx.items())
# each id|pkctx is 36 bytes
assert len(serialized_pkctx) == 36 * len(pk_dict)
assert len(serialized_rand_point) == 170
# CTX-format:
# 2 4 32 4 32 4 32 170 32 32 var
# <npks><id1><pkctx1><id2><pkctx2>....<idn><pkctxn><rand_point_pk><nonce><tag><ctx>
return struct.pack('<I', len(pk_dict)) + \
serialized_pkctx + \
serialized_rand_point + \
serialized_msgctx
def setKeys():
global keys
with open("keys/ca_pub_key_ECC.pem", "r") as f:
keys["CA_pub"] = ECC.import_key(f.read())
keys["priv"] = ECC.generate(curve="p256")
keys["pub"] = keys["priv"].public_key()
def generate_from_pw(pw, salt, curve='P-256'):
"""Generates a ECC key pair using the randomness derived from pw, salt.
"""
rand_seed = PBKDF2(pw, salt, dkLen=16, count=HASH_CNT)
rand_num_generator = RandomWSeed(rand_seed, 1024)
return ECC.generate(
curve=curve,
randfunc=rand_num_generator.get_random_bytes
)
def test_compute_id_w_saltctx():
pwtypo = 'asdfadsfadf'
list_keys = {
i: ECC.generate(curve='P-256')
for i in xrange(10)
}
pk_dict = {k: v.public_key() for k,v in list_keys.items()}
salt = os.urandom(32)
saltctx = encrypt(pk_dict, salt)
id1 = compute_id_w_saltctx(pwtypo, dict([list_keys.popitem()]), saltctx)
id2 = compute_id_w_saltctx(pwtypo, dict([list_keys.popitem()]), saltctx)
assert isinstance(id1, int)
assert id1 == id2
def test_functionality():
# generate a set of pk,sk pairs
list_keys = {
i: ECC.generate(curve='P-256')
for i in xrange(10)
}
pk_dict = {k: v.public_key() for k,v in list_keys.items()}
msg = 'HI Multiuser! in (test_functionality)'
ctx = encrypt(pk_dict, msg)
while list_keys:
sk_dict = dict([list_keys.popitem()])
_msg = decrypt(sk_dict, ctx)
assert msg == _msg, "\n_msg={}\n msg={}\n".format(_msg, msg)
def get_private_key():
"""
Set the private key from a file or by creating a new one
:return: ECC private key object
"""
ensure_data_dir() # ensure directory exists
try: # get existing private key
key = ECC.import_key(open(_PRIVATE_KEY_PATH, 'rt').read())
except FileNotFoundError: # create public key
key = ECC.generate(curve='P-256')
# write private key to file
file = open(_PRIVATE_KEY_PATH, 'wt')
file.write(key.export_key(format='PEM'))
file.close()
return key
def encrypt_with_ecc(public_ecc_key, message, nonce=None):
"""Takes elliptic curve isntance (public_ecc_key) and a byte string
(message), and outputs a ciphertext
"""
assert isinstance(public_ecc_key, ECC.EccKey),\
"public_ecc_key should be ECC key. Got {}".format(type(public_ecc_key))
random_ecc_key = ECC.generate(curve=public_ecc_key.curve)
new_point = public_ecc_key.pointQ * random_ecc_key.d
h = SHA256.new(str(new_point.x))
h.update('XXX' + str(new_point.y)) # 'XXX' is a delimiter
key = h.digest()
if not nonce:
nonce = os.urandom(16)
aes_engine = AES.new(key=key, mode=AES.MODE_EAX, nonce=nonce)
ctx, tag = aes_engine.encrypt_and_digest(message)
# Return: <ephemeral_pub_key>, <nonce>, <ciphertext>, <tag>
return (random_ecc_key.public_key().export_key(format='OpenSSH'),
aes_engine.nonce, ctx, tag)
def generate(pwhash, curve='secp256r1'):
rand_num_generator = RandomWSeed(pwhash, 1024)
return ECC.generate(
curve=curve,
randfunc=rand_num_generator.get_random_bytes
)
def generate_key_pair():
private_key = ECC.generate(curve='P-256')
public_key = private_key.public_key()
return public_key, private_key
