def test_passphrase_to_pubkey(self):
self.assertEqual(str(seccure.passphrase_to_pubkey(b'test')),
'*jMVCU^[QC&q*v_8C1ZAFBAgD')
self.assertEqual(str(seccure.passphrase_to_pubkey(b'my private key')),
'8W;>i^H0qi|J&$coR5MFpR*Vn')
self.assertRaises(ValueError, seccure.passphrase_to_pubkey,
six.u('test'))
def test_encrypt(self):
msg = b'My private message'
pw = b'my private key'
pk = str(seccure.passphrase_to_pubkey(pw))
self.assertEqual(seccure.decrypt(seccure.encrypt(msg, pk), pw), msg)
for c in seccure.curves:
self.assertEqual(
seccure.decrypt(
seccure.encrypt(
msg,
str(seccure.passphrase_to_pubkey(pw, curve=c)),
curve=c),
pw, curve=c),
msg)
def test_encrypt(self):
msg = b'My private message'
pw = b'my private key'
self.assertEqual(
seccure.decrypt(
seccure.encrypt(msg, str(seccure.passphrase_to_pubkey(pw))),
b'my private key'), msg)
def create_key():
# Get the latest id
latestPKs = models.PrivateKey.query.all()
priv_id = -1
for priv in reversed(latestPKs):
priv_id = priv.id + 1
break
if(priv_id == -1):
priv_id = 1
# Create private key
randomStr = os.urandom(64)
h = hashlib.sha256()
h.update(randomStr)
privKey = h.hexdigest()
publicKey = seccure.passphrase_to_pubkey(privKey)
# Save private key
pk = models.PrivateKey(
name = 'SKYLOCK-' + str(priv_id),
key = str(privKey))
db.session.add(pk)
db.session.commit()
# Save public key
pubk = models.PublicKey(
id = priv_id,
name = 'SKYLOCK-' + str(priv_id),
key = str(publicKey)
)
db.session.add(pubk)
db.session.commit()
# Display new public key
pubKeyRes = models.PublicKey.query.get(priv_id)
return jsonify(Public_key=[pubKeyRes.serialize])
def test_sign_and_verify(self):
msg = b'This message will be signed\n'
pw = b'my private key'
for c in seccure.curves:
pubkey = str(seccure.passphrase_to_pubkey(pw, curve=c))
self.assertTrue(seccure.verify(msg, seccure.sign(msg, pw, curve=c),
pubkey, curve=c))
def test_sign_and_verify(self):
msg = b'This message will be signed\n'
pw = b'my private key'
for c in seccure.curves:
pubkey = str(seccure.passphrase_to_pubkey(pw, curve=c))
self.assertTrue(seccure.verify(msg, seccure.sign(msg, pw, curve=c),
pubkey, curve=c))
def test_generate_keypair(self):
for curvename in seccure.curves:
privkey, pubkey = seccure.generate_keypair(curve=curvename)
self.assertEqual(
str(seccure.passphrase_to_pubkey(
privkey,
curve=curvename,
)), pubkey)
def accepted(self):
self.conn = sqlite3.connect("Data.db")
self.c = self.conn.cursor()
# key = convertpass(self.passStringAdd)
# iv = Random.new().read(DES3.block_size)
# cipher_encrypt = DES3.new(key, DES3.MODE_OFB, iv)
# passwordpadded = convertToMUL8(self.Password.text())
private_key = self.passStringAdd
public_key = str(seccure.passphrase_to_pubkey(private_key.encode()))
self.c.execute("INSERT INTO PASSES VALUES(?, ?, ?, ?)", [(self.id), (self.Company.text()), (self.Username.text()), (seccure.encrypt(self.Password.text().encode(), public_key.encode()))])
print("A New Password FIELD ADDED.")
self.conn.commit()
self.accept()
def on_click_submit(self):
self.conn = sqlite3.connect("BankDB.db")
self.c = self.conn.cursor()
self.h = hashlib.sha512()
self.h.update(self.PasswordField.text().encode())
self.hash = self.h.digest()
self.publicKey = str(seccure.passphrase_to_pubkey(b'my private key'))
self.date = datetime.datetime.now()
self.c.execute("INSERT INTO USERS(NAME, USERNAME, PASSWORD, ACCOUNT_ID, PubKey) VALUES(?, ?, ?, ?, ?);", [(self.NameField.text()), (self.User_NameField.text()), (self.hash), (self.Account_NumberField.text()), (self.publicKey)])
self.c.execute('INSERT INTO SAMPE VALUES(00001, 00001, ?, ?, ?, ?, ?)', [(self.Account_NumberField.text()), (seccure.encrypt(self.NetBalance.text().encode(), b'8W;>i^H0qi|J&$coR5MFpR*Vn')), (str(self.date.time())), (str(self.date.date())), (hashTransaction(self.date.time(), self.Account_NumberField.text()))])
self.conn.commit()
self.conn.close()
self.close()
def on_click_send(self):
self.conn = sqlite3.connect('BankDB.db')
self.c = self.conn.cursor()
self.date = datetime.datetime.now()
self.id = s.encrypt(
self.hashTransaction(self.date.time(), self.accID).encode(),
str(s.passphrase_to_pubkey(b'my private key')))
self.amt = s.encrypt(self.Amount.text().encode(),
str(s.passphrase_to_pubkey(b'my private key')))
print("Transaction ID : " + str(self.id))
print("\nAmount sent : " + str(self.amt))
self.c.execute('INSERT INTO SAMPE VALUES(?, ?, ?, ?, ?, ?, ?);',
[(self.accID), (self.accID),
(self.ReceiversID.text()), self.amt,
(str(self.date.time())),
(str(self.date.date())), self.id])
print("\nSuccessfully Transferred")
# self.fetchdata = self.c.execute('SELECT NETBALANCE FROM USERS where ACCOUNT_ID = ?', [(self.accID)])
# for i in self.fetchdata:
# self.intbalnow = i[0]
# self.c.execute('UPDATE USERS SET NETBALANCE = ? WHERE ACCOUNT_ID =?',[(self.intbalnow - int(self.Amount.text())), (self.accID)])
self.conn.commit()
self.close()
def __init__(self, _private_key=None, _public_key=None):
"""Generates a new keypair. This object can be serialized to store the pair generated.
To generate a NEW key, set both parameters to None (simply invoke the constructor
w/o arguments). To load/use an existing pair pass them as parameter. You can not
use this object to store ONLY a private or public key.
You may read out the 'private_key' and 'public_key' properties directly.
@param _private_key An existing private key (or None). Should be in base64 format.
@param _public_key An existing public key (or None). Should be in base64 format.
"""
assert (_private_key is None and _public_key is None) or (_private_key is not None and _public_key is not None)
if _private_key is None:
# Although the private key could be (a lot) shorter, I am sticking to a
# private key with the byte length the same as the bit length of the curve for now.
# This won't be easy to guess ...
self._private_key = Key(''.join(random.choice(string.digits + string.ascii_letters + string.punctuation) for x in range(521)).encode("utf-8"), True)
self._public_key = Key(str(seccure.passphrase_to_pubkey(self.raw_private_key)).encode("utf-8"), True)
else:
self._private_key = Key(_private_key)
self._public_key = Key(_public_key)
def test_issue5(self):
self.assertEqual(repr(seccure.passphrase_to_pubkey(b'my private key')),
'<PubKey 8W;>i^H0qi|J&$coR5MFpR*Vn>')
def generate(self, passphrase):
self._eprv = passphrase.encode()
self._epub = str(seccure.passphrase_to_pubkey(self._eprv)).encode()
def generatePublicKey():
private_Key = 'prueba1'
public_key = seccure.passphrase_to_pubkey(private_Key.encode())
print(public_key)
return public_key
#build the key for hmac using scrypt
skey = scrypt.hash('password_goes_here', hashlib.sha256(secret).hexdigest())[:32]
#skey = scrypt.encrypt('password', secret, maxtime=0.5)
print ('SCRYPT: \t{}'.format(hex(bytes_to_long(skey))))
#XOR the scrypt key with the secret to create the hmac key
hashkey = bytes_to_long(secret) ^ bytes_to_long(skey)
print ('HASHKEY: \t{}'.format(hex(hashkey)))
#build the hmac hash from the msg using sha256
hmac = HMAC.new(long_to_bytes(hashkey), msg='foo'.encode(), digestmod=SHA256.new())
hash = hmac.hexdigest()
print ('HMAC: \t\t{}'.format(hash))
#create the ECC private key from the hmac hash
newprv = hash.encode()
newpub = str(seccure.passphrase_to_pubkey(newprv))
print ('ECC PRIVATE: \t{}'.format(newprv))
print ('ECC PUBLIC: \t{}'.format(newpub))
#sign the message
sig = seccure.sign('bar'.encode(), newprv)
print ('ECC SIG: \t{}'.format(sig))
#attempt verification
if seccure.verify('bar'.encode(), sig, newpub):
print('GOOD SIGNATURE')
else :
print('BAD SIGNATURE')
def test_encrypt(self):
msg = b'My private message'
pw = b'my private key'
self.assertEqual(seccure.decrypt(seccure.encrypt(msg,
str(seccure.passphrase_to_pubkey(pw))),
b'my private key'), msg)
def get_pub_key(pass_phrase):
return str(seccure.passphrase_to_pubkey(pass_phrase, curve="brainpoolp384r1"))
# # # using elliptic curve cryptography to encrypt messages. # # use with seccure: https://github.com/MeeSeongIm/py-seccure # # import seccure str(seccure.passphrase_to_pubkey(b'my private key')) # devive the public key ciphertext = seccure.encrypt(b'This is a secret message.\n', b'8W;>i^H0qi|J&$coR5MFpR*Vn') print(ciphertext) seccure.decrypt(ciphertext, b'my private key') seccure.sign(b'This will be a signed message.\n', b'my private key') seccure.verify(b'This will be a signed message.\n', b'', b'8W;>i^H0qi|J&$coR5MFpR*Vn') # to verify the signature
r = []
for x in range(7):
packet.append(byteString[(x * N):((N * (x + 1)))])
#print packet[x]
# Step 2
for y in range(7):
#r.append(random.choice(enc_list))
packet[y] = packet[y] + enc_list[y]
#enc_list.remove(r[y])
#packet[y] = packet[y] + r[y]
#print packet[y]
private_key = '77' #random.choice(string.digits)
#print private_key
public_key = str(seccure.passphrase_to_pubkey(private_key))
ciphertext = []
###Encryption phase
for z in range(7):
t1 = time.time()
ct = seccure.encrypt(packet[z][:-3], public_key)
#print tt
ciphertext.append(ct)
t2 = time.time()
conv = {'ciphertext': ct, 'cloudNo': packet[z][-3:]}
s = json.dumps(conv, ensure_ascii=False)
res = requests.post("http://127.0.0.1:5000/determine_escalation/",
data=ct + packet[z][-3:]).json()
print res
encTime = encTime + (t2 - t1)
#print ciphertext[z]
def publickey(private):
if private not in Private.pubkey_cache:
public = seccure.passphrase_to_pubkey(
private, "secp256r1/nistp256").to_bytes(seccure.SER_COMPACT)
Private.pubkey_cache[private] = public
return Private.pubkey_cache[private]
def gen_public_key(self):
if not self.private_key:
raise ValueError("no private key")
self.public_key = seccure.passphrase_to_pubkey(self.private_key, curve='secp256r1/nistp256').to_bytes()
return self.public_key
def create_pubkey(passphrase):
passphrase_bytes = utf8_encode(passphrase)
pubkey_obj = seccure.passphrase_to_pubkey(passphrase_bytes,
curve=default_curve_name)
return hex_encode(pubkey_obj)
def test_issue5(self):
self.assertEqual(repr(seccure.passphrase_to_pubkey(b"my private key")), "<PubKey 8W;>i^H0qi|J&$coR5MFpR*Vn>")
def generate(self, passphrase):
self._eprv = passphrase.encode()
self._epub = str(seccure.passphrase_to_pubkey(self._eprv)).encode()
def get_pub_key(pass_phrase):
return str(
seccure.passphrase_to_pubkey(pass_phrase, curve="brainpoolp384r1"))
def test_forwards_compatibility_issue_16(self):
msg = b'ttrMWDqBxjC8UAl8X4TRDSSpd1IyYMh4\n'
sig = b'!!!5{LV[=|t~46wS2y<Ub9Ol;uO/fPGU*JYKid+|(JBMspwk7S'
pw = b'my private key'
pubkey = str(seccure.passphrase_to_pubkey(pw))
self.assertTrue(seccure.verify(msg, sig, pubkey))
def test_forwards_compatibility_issue_16(self):
msg = b'ttrMWDqBxjC8UAl8X4TRDSSpd1IyYMh4\n'
sig = b'!!!5{LV[=|t~46wS2y<Ub9Ol;uO/fPGU*JYKid+|(JBMspwk7S'
pw = b'my private key'
pubkey = str(seccure.passphrase_to_pubkey(pw))
self.assertTrue(seccure.verify(msg, sig, pubkey))
def test_generate_keypair(self):
for curvename in seccure.curves:
privkey, pubkey = seccure.generate_keypair(curve=curvename)
self.assertEqual(
str(seccure.passphrase_to_pubkey(privkey)), pubkey)
def __init__(self, private_key, session=db.session):
self.private_key = private_key
self.public_key = str(
seccure.passphrase_to_pubkey(self.private_key.encode('utf-8')))
self.session = session
hashlib.sha256(secret).hexdigest())[:32]
#skey = scrypt.encrypt('password', secret, maxtime=0.5)
print('SCRYPT: \t{}'.format(hex(bytes_to_long(skey))))
#XOR the scrypt key with the secret to create the hmac key
hashkey = bytes_to_long(secret) ^ bytes_to_long(skey)
print('HASHKEY: \t{}'.format(hex(hashkey)))
#build the hmac hash from the msg using sha256
hmac = HMAC.new(long_to_bytes(hashkey),
msg='foo'.encode(),
digestmod=SHA256.new())
hash = hmac.hexdigest()
print('HMAC: \t\t{}'.format(hash))
#create the ECC private key from the hmac hash
newprv = hash.encode()
newpub = str(seccure.passphrase_to_pubkey(newprv))
print('ECC PRIVATE: \t{}'.format(newprv))
print('ECC PUBLIC: \t{}'.format(newpub))
#sign the message
sig = seccure.sign('bar'.encode(), newprv)
print('ECC SIG: \t{}'.format(sig))
#attempt verification
if seccure.verify('bar'.encode(), sig, newpub):
print('GOOD SIGNATURE')
else:
print('BAD SIGNATURE')
