def freqdist(length, record): #define Frequency Distribution function
from keygen import keygen #Importing keygen module from keygen.py
import sys #Importing sys module
import random #Importing random module
f1 = open(record, 'a') #Opening the record.txt file in append mode
fd = [0] * pow(
2, int(length)) #Initializing an array to store the key frequency
for i in range(5000): #Iterating 5000 times
keygen(length, '../data/temp.txt'
) #Calling keygen function to generate a key of given length
f2 = open(
'../data/temp.txt',
'r') #Opening the temp.txt file that contains the generated key
tk = f2.readline() #Reading the generated Key value
f2.close() #Closing the temp.txt file
r = int(tk, 2)
fd[r] = fd[r] + 1 #Counting the no. of occurences of key
f1.write(
tk +
'\n') #Collecting the generated key value into record.txt file
f1.close() #Closing the record.txt file
for i in range(0, len(fd)): #Iterating the frequency distribution array
f1 = open(record, 'a') #Opening the record.txt file in append mode
f1.write('Value:' + ' ' + 'No. of Occurences\n')
print('Value:' + ' ' + 'No. of Occurences')
f1.write(
str(i) + ' ' + str(fd[i]) + '\n'
) #Writing the KeyValue and its no. of occurences to record.txt file
print(str(i) + ' ' + str(fd[i]))
def keyToMySQL():
mysql = MySQLConn.MySQLConn()
mysql.newConnection(
host="localhost",
user="******",
passwd="wyhwyh22",
defaultdb="test"
)
#建表
sqlText = """CREATE TABLE IF NOT EXISTS `test`.`key` ( `id` INT(8) NOT NULL , `key` TEXT NULL , `time` TIMESTAMP NOT NULL , PRIMARY KEY (`id`)) ENGINE = InnoDB;"""
mysql.execute(sqlText)
#生成待插入数据
args = []
for i in range(1,201):
new_list = (i,keygen.keygen(20))
print time.time()
args.append(new_list)
#执行插入
sqlText3 = """ INSERT INTO `key`(`id`, `key`) VALUES (%s,%s)"""
try:
mysql.execute(sqlText3, args, mode=MySQLConn.DICTCURSOR_MODE, many=True)
mysql.conn.commit()
except Exception,e:
print e
def testRSA ():
e, d, n = keygen.keygen()
m = BigInt.random_big(n-10)
c = myRSA.encrypt(m,e,n)
data = myRSA.decrypt(c,d,n)
assert m == data
def main():
print(
"Dieses Programm ist zur Schlüsselerzeugung, Verschlüsselung und Entschlüsselung \n des RSA Codes"
)
while wahl:
auswahl = 0
while not auswahl:
print("Welche Aktion wollen Sie durchführen?")
print(
"1. RSA Schlüssel erzeugen;\n2. Text chiffrieren;\n3. Text dechiffrieren;\n4.Das Programm beenden; "
)
print(
" Wählen Sie mit den NUM - Tasten und bestätigen mit ENTER"
)
auswahl = int(input())
if auswahl < 1 or auswahl > 4:
auswahl = 0
print("War Ihre Auswahl %s?. Bestätigen Sie mit ENTER." % auswahl)
if auswahl == 1:
keygen.keygen()
if auswahl == 2:
scrambler.scrambler()
if auswahl == 3:
descrambler.descrambler()
if auswahl == 4:
break
tempwahl = ord(raw_input())
if tempwahl == 121 or tempwahl == 89:
wahl = True
else:
wahl = False
print("Das Programm wird nun beendet\n Bye, Bye")
def main():
key = keygen.keygen("printable", 100)
print("key = ", key)
message = (input("Enter a message : "))
print("message = ", message)
encrypted_text = substitute_encrypt(message, key)
print("encrypted text = ", encrypted_text)
decrypted_text = substitute_decrypt(encrypted_text, key)
print("decrypted text = ", decrypted_text)
def avgruntime(length, key, plaintext,
ciphertext): #define Average Run Time for Encryption function
from keygen import keygen #Importing keygen module from keygen.py
from enc import enc #Importing enc module from enc.py
import time #Importing time module
a = [0] * 5 #Initializing an array of 5 integers
for i in range(len(a)): #Iterating the array
keygen(length, key) #Calling keygen function
start = time.time() #Noting the Start time
enc(key, plaintext, ciphertext) #Calling enc function
end = time.time() #Noting the end time
a[i] = end - start #Calculate the time elapsed for Encryption function
print('Time Taken = ' + str(a[i]) +
' seconds') #Printing the elapsed time on Command Prompt
averageRunTime = sum(a) / float(
len(a)) #Calculating the average time elapsed for Encryption function
print(
'Average Run time for lambda=' + length + ' is:' + ' ' +
str(averageRunTime)
) #Printing the length of a Secret Key and time elapsed for Encryption function on Command Prompt
def main():
parser=argparse.ArgumentParser()
parser.add_argument('action',help='encrypt or decrypt?',choices=['encrypt','decrypt'])
parser.add_argument('ipfile')
parser.add_argument('opfile')
args=parser.parse_args()
with open(args.ipfile,'rb') as f:
inp=np.fromfile(f,dtype=np.uint8)
k1,k2=keygen()
if args.action=='encrypt':
op=encrypt(inp,k1,k2)
else:
op=decrypt(inp,k1,k2)
with open(args.opfilie,'wb') as f:
op.tofile(f)
def keys():
mk = ""
f = open("key.txt", "r")
enkey = f.readline()
f.close()
f = open("dfkeyrec.txt", "r")
dfkey = f.readline()
f.close()
enkey = enkey.replace(",", "")
enkey = enkey.replace(" ", "")
enkey = enkey.replace("[", "")
enkey = enkey.replace("]", "")
dfkey = list(dfkey)
enkey = list(enkey)
#print(dfkey,end=" ")
#print(type(dfkey))
#print(enkey,end=" ")
#print(type(enkey))
for i in range(0, len(enkey)):
mk = mk + str((int(enkey[i]) ^ int(dfkey[i])))
k1, ke1 = kg.keygen(mk)
k2, ke2 = kg.keygen2(ke1)
return k1, k2
sg = np.dot(keys.SK, g) % keys.q
div = np.rint((msg / sg).astype(np.float)).astype(np.int64)
modes = np.unique(div, return_counts=True)
modes = sorted(zip(modes[0], modes[1]), key=lambda t: -t[1])
best_num = 0
best_dist = float('inf')
for mu, count in modes:
dist = (msg - mu * sg) % keys.q
dist = np.minimum(dist, keys.q - dist)
#dist = np.linalg.norm(dist)
dist = np.dot(dist, dist)
if dist < best_dist:
best_num = mu
best_dist = dist
return best_num
if __name__ == '__main__':
from keygen import keygen
from enc import encrypt
keys = keygen(28)
for idx in [34, 117, 62]:
c = encrypt(keys, idx)
m = decrypt(keys, c)
print(" " * 12 + "Expected %d" % idx)
print(" " * 12 + "Received %d" % m)
if idx == m:
print(" " * 12 + "\x1B[32;1mPassed\x1B[0m")
else:
print(" " * 12 + "\x1B[31;1mFailed\x1B[0m")
print("(0) - Exit")
try:
userIn = input("\nPlease choose operation: ")
userIn = int(userIn)
except KeyboardInterrupt:
print("")
break
except ValueError:
print("Please enter only Numbers between 0 and 4")
continue
if userIn == 1:
keys = keygen.keygen()
print("*** Keypairs ***")
print("- Private Key: (N={},d={})".format(keys.private.RSA,
keys.private.exponent))
print("- Public Key: (N={},e={})".format(keys.public.RSA,
keys.public.exponent))
elif userIn == 2 or userIn == 3:
question = str()
if(userIn == 2):
question = "Please enter public key: "
else:
question = "Please enter private key: "
Key = input_parser.InputParser(input(question))
"""
this code will test the keygen function for randomness
it will generate a 1000 and each time counting the occurrence of bit 0
it should be close to 0.5
Students:
Leen Kilani 0154493
Mostafa Al-Mohtaseb 0154526
"""
import keygen
count_list = []
for i in range(0,1000):
count = 0
k = keygen.keygen("DES")
if len(k) != 16:
print("wrong length {}",format(len(k)))
exit()
binary_k = bin(int(k, 16))[2:].zfill(64)
for j in binary_k:
if j == '0':
count += 1
count = count/64
count_list.append(count)
avg = sum(count_list)/len(count_list)
print("average is {}\n".format(avg))
from enc import enc #importing Encryption module
from dec import dec #importing Decryption module
from keygen import keygen #importing Key Generation module
from freqdist import freqdist #importing Frequency Distribution module
from avgruntime import avgruntime #importing Average Run Time for encryption module
if __name__ == '__main__': #calling main function
import sys #importing sys module
import os #importing os module
#First argument i.e sys.argv[0] is always otp.py
#Second argument i.e sys.argv[1] is the called function
#Comparing the second command line argument with respective functions to call
if sys.argv[1] == 'enc': #Comparing with enc
enc(sys.argv[2], sys.argv[3], sys.argv[4]) #Calling enc function
elif sys.argv[1] == 'dec': #Comparing with dec
dec(sys.argv[2], sys.argv[3], sys.argv[4]) #Calling dec function
elif sys.argv[1] == 'keygen': #Comparing with keygen
keygen(sys.argv[2], sys.argv[3]) #Calling keygen function
elif sys.argv[1] == 'freqdist': #Comparing with freqdist
freqdist(sys.argv[2], sys.argv[3]) #Calling freqdist function
elif sys.argv[1] == 'avgruntime': #Comparing with avgruntime
avgruntime(sys.argv[2], sys.argv[3], sys.argv[4],
sys.argv[5]) #Calling avgruntime function
#coding:utf-8
import keygen
import MySQLdb
print keygen.keygen(20)
STORE_RESULT_MODE = 0
USE_RESULT_MODE = 1
CURSOR_MODE = 0
DICTCURSOR_MODE = 1
SSCURSOR_MODE = 2
SSDICTCURSOR_MODE = 3
FETCH_ONE = 0
FETCH_MANY = 1
FETCH_ALL = 2
class MySQLConn:
def __init__(self):
self.conn = None
pass
def newConnection(self,host,user,passwd,defaultdb):
"""
建立一个新的连接，指定host、用户名、密码、默认数据库
:param host:
:param user:
:param passwd:
:param defaultdb:
:return:
def test_LEDAKem(self):
self.category = [1, 2, 3, 4, 5]
self.n0 = [2, 3, 4]
self.test_parameters = []
for i in self.category:
for j in self.n0:
self.test_parameters.append(ledakem_session(i, j))
n_test = 0
for session in self.test_parameters:
i_max = 20
LEDAkem_GLOBAL_PARAMS.p = session.p
LEDAkem_GLOBAL_PARAMS.n0 = session.n0 # number of circulant blocks
LEDAkem_GLOBAL_PARAMS.t = session.t
LEDAkem_GLOBAL_PARAMS.m = session.m
LEDAkem_GLOBAL_PARAMS.dv = session.dv
LEDAkem_GLOBAL_PARAMS.TRNG_byte_len = session.TRNG_byte_len
LEDAkem_GLOBAL_PARAMS.sha3_version = session.sha3_version
n_test += 1
print("\nLEDAKem Testing n:", n_test)
print("Parameters:\nCATEGORY:{}\nn0:{}\np:{}\nt:{}".format(
session.category, LEDAkem_GLOBAL_PARAMS.n0,
LEDAkem_GLOBAL_PARAMS.p, LEDAkem_GLOBAL_PARAMS.t))
pseed = quasi_trng(LEDAkem_GLOBAL_PARAMS.TRNG_byte_len)
LEDAkem_GLOBAL_PARAMS.irr_poly = np.array(
[1] + (LEDAkem_GLOBAL_PARAMS.p - 1) * [0] + [1], dtype="uint8")
print("Beginning Key Generation")
t0 = time.time()
H, Q, M = keygen(pseed)
print("Private and Public Keys have been generared in: {:3f} s".
format(time.time() - t0))
print("Beginning Encryption")
t0 = time.time()
Ks_Alice, c_Alice = leda_enc(M)
print("Time taken for Encryption: {:3f} s".format(time.time() -
t0))
thresh_lut = choose_threshold_lut(session.category,
LEDAkem_GLOBAL_PARAMS.n0)
print("Beginning Decryption")
t0 = time.time()
flag, Ks_Bob = leda_dec(c_Alice, thresh_lut, i_max, pseed)
print("Time taken for Decryption: {:3f} s".format(time.time() -
t0))
self.assertEqual(flag, True)
assert Ks_Alice == Ks_Bob
print("Decoding succeded!!\n\n")
this code will test the given encryption mode for the most occurring byte
Students:
Leen Kilani 0154493
Mostafa Al-Mohtaseb 0154526
"""
import encrypt
import keygen
import sys
encryption = sys.argv[1]
mode = sys.argv[2]
with open("textb.txt", 'r') as A:
text = bytes(A.read(), encoding='utf-8')
ctext = encrypt.encrypt(keygen.keygen(encryption), text, encryption, mode)
bytelist = [byte for byte in ctext]
from collections import Counter
bytedict = Counter(bytelist)
maximum = 0
maxkey = 0
for k, v in bytedict.items():
if v > maximum:
maximum = v
maxkey = k
frequency = maximum / len(bytelist)
print("most occurring byte is :{} with frequency: {}\n".format(bytes([maxkey]), frequency))
# the error vector [e] is an m-dimensional vector
#
# the matrix [A] is an (n-1)×m matrix (n-1 rows, m = n×l columns)
#
# the public key [B] is ( A ) which is an n×m matrix
# ( sA+e )
#
g = 2**np.arange(l)
return block_diag(*[g for null in range(n)])
def encrypt(keys, message):
stat("Encrypting message")
#
# the gadget matrix [G] is an n×m matrix (n rows, m = n×l columns)
#
# the matrix R is an m×m matrix (n×l rows, n×l columns)
#
# the ciphertext is (n×m)⋅(m×m) => an n×m matrix
#
R = np.random.randint(2, size=(keys.m, keys.m),
dtype=np.int64).astype(keys.datatype)
G = buildGadget(keys.l, keys.n)
return (np.dot(keys.PK, R) + message * G) % keys.q
if __name__ == '__main__':
from keygen import keygen
keys = keygen(16)
encrypt(keys, 1)
from keygen import keygen
import socket
pub_key, priv_key, n = keygen()
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('', 8000))
s.listen(1)
print("Server listening on localhost at port 8000")
try:
while True:
conn, addr = s.accept()
print("Got connection from client {}".format(str(addr)))
msg = str(n) + "DELIM" + str(pub_key)
conn.send(str(msg).encode())
# Get the encrypted message from the server
code = int(str(conn.recv(100).decode()))
print("Received encrypted message: {}".format(code))
# Decrypt it using private key
msg = pow(code, priv_key, n)
print("Original message: {}".format(msg))
# Close the connection
conn.close()
except KeyboardInterrupt:
s.close()
import encrypt
import decrypt
# prompt user to choose
done = False
encrypted = False
ciphertext = []
pubkey = {}
while not done:
res = input("\n\nPlease choose one of the following options:\n1. key generation\n2. encrypt\n3. decrypt\n4. exit\n\n")
if res == "1":
print("Generating keys ... \n\n")
pubkey, d = keygen.keygen()
elif res == "2":
if not bool(pubkey):
print("Please generate keys first.\n\n")
else:
print("Encryption started ... \n\n")
pFile = open("plaintext.txt", "r")
plaintext = pFile.read()
pFile.close()
res = plaintext.split('\n')
newplain = res[0]
ciphertext = encrypt.encrypt(newplain, pubkey)
nbits -= 1
message_b64 = base64.b64encode(message)
message_number = []
for char in message_b64:
message_number.append(str(ord(char)-30))
message_str = ''.join(message_number)
result = []
while True:
if len(message_str) > nbits:
result.append(long(message_str[:nbits]))
message_str = message_str[nbits:]
else:
result.append(long(message_str))
return result
def main():
pass
if __name__ == "__main__":
import keygen
start = time.time()
pk, sk = keygen.keygen()
tag_block(pk, sk, '../file/test.txt')
end = time.time()
print("process cost %s" % (end - start))
''' This file is an implementation of Gentry-Sahai-Waters (GSW) fully-
homomorphic encryption scheme. GSW transforms a plaintext bit into a
ciphertext matrix and relies on the Decisional Learning With Errors
assumption for computational security.
Authors: Nolan Hedglin, Kade Phillips, Andrew Reilley '''
import numpy as np
from util import *
from keygen import keygen
from enc import encrypt, buildGadget
from dec import decrypt
keys = keygen(24)
for a, b in [(1, 1), (17, 19), (34, 62)]:
ca = encrypt(keys, a)
cb = encrypt(keys, b)
a_b = a + b
ca_cb = (ca + cb) % keys.q
d_ca_cb = decrypt(keys, ca_cb)
print(" " * 12 + "Expected %d" % a_b)
print(" " * 12 + "Received %d" % d_ca_cb)
if a_b == d_ca_cb:
print(" " * 12 + "\x1B[32;1mPassed\x1B[0m")
else:
print(" " * 12 + "\x1B[31;1mFailed\x1B[0m")
ca = encrypt(keys, a)
cb = encrypt(keys, b)
mk = input()
f = open("dfkeysend.txt", "r")
key = f.readline()
f.close()
#print(key)
#print(type(key))
msk = list(mk)
#print(len(msk))
for i in range(0, len(msk)):
enkey.append((int(msk[i]) ^ int(key[i])))
#print(enkey)
f = open("key.txt", "w")
f.write(str(enkey))
f.close()
k1, ke1 = kg.keygen(mk)
print(k1)
k2, ke2 = kg.keygen2(ke1)
print(k2)
print(" ~~~:Round Keys generated:~~~")
for i in range(2):
print()
def enc(data):
data = pb.ip(data)
data = fun(data, 1)
for i in range(0, len(data)):
data[i] = str(data[i])
#print(data)
l = data
def expand_link(controller, link):
prefix = "rt" + str(int(time.time()))
rga = link.router_group_a
rgb = link.router_group_b
private_ipA = controller.reserve_vpc_ip(rga.region, "int-" + prefix + "a")
private_ipB = controller.reserve_vpc_ip(rgb.region, "int-" + prefix + "b")
public_ipA = controller.reserve_vpc_ip(rga.region,
"ext-" + prefix + "a",
is_internal=False)
public_ipB = controller.reserve_vpc_ip(rgb.region,
"ext-" + prefix + "b",
is_internal=False)
pprint(private_ipA)
pprint(public_ipA)
pprint(private_ipB)
pprint(public_ipB)
print('Creating instances.')
#TODO maybe put this somewhere else
imageID = "just-wireguard"
vcpus = 4
script = "startup-script.py"
internalApublic, internalAprivate = keygen()
internalBpublic, internalBprivate = keygen()
externalApublic, externalAprivate = keygen()
externalBpublic, externalBprivate = keygen()
clientsA = json.dumps([c.data() for c in rga.clients])
clientsB = json.dumps([c.data() for c in rgb.clients])
script_paramsA = {
"my_internal_wg_ip": "192.168.0.2",
"their_internal_wg_ip": "192.168.0.3",
"their_external_wg_ip": "192.168.0.4",
"my_external_wg_ip": "192.168.0.5",
"my_internal_port": "3005",
"their_internal_port": "3005",
"my_external_port": "3002",
"my_internal_private_key": internalAprivate,
"their_internal_public_key": internalBpublic,
"my_external_private_key": externalAprivate,
"their_vpc_address": private_ipB,
"our_clients": clientsA,
"their_clients": clientsB
}
script_paramsB = {
"my_internal_wg_ip": "192.168.0.3",
"their_internal_wg_ip": "192.168.0.2",
"their_external_wg_ip": "192.168.0.5",
"my_external_wg_ip": "192.168.0.4",
"my_internal_port": "3005",
"their_internal_port": "3005",
"my_external_port": "3002",
"my_internal_private_key": internalBprivate,
"their_internal_public_key": internalApublic,
"my_external_private_key": externalBprivate,
"their_vpc_address": private_ipA,
"our_clients": clientsB,
"their_clients": clientsA
}
instanceA_name = prefix + "a"
instanceB_name = prefix + "b"
operationA = controller.create_instance(rga.zone, instanceA_name,
private_ipA, public_ipA, imageID,
vcpus, script, script_paramsA)
operationB = controller.create_instance(rgb.zone, instanceB_name,
private_ipB, public_ipB, imageID,
vcpus, script, script_paramsB)
controller.wait_for_zone_operation(rga.zone, operationA['name'])
controller.wait_for_zone_operation(rgb.zone, operationB['name'])
import socket
from keygen import keygen
pub_key, pri_key, N = keygen()
s = socket.socket()
s.bind(('', 6969))
s.listen(1)
try:
while True:
conn, addr = s.accept()
pubKey = str(pub_key) + "DELIM" + str(N)
conn.send(str(pubKey).encode())
#receving
cipher = int(str(conn.recv(1024).decode("utf-8")))
print("received measage ", cipher)
plain = pow(cipher, pri_key, N)
print("Decrypted message : ", plain)
except KeyboardInterrupt:
s.close()