initial commit

Author: paukerspinner

__pycache__/client.cpython-38.pyc

@@ -0,0 +1,44 @@
+import fm
+from paillier import PublicKey, PrivateKey, encrypt, decrypt
+import env
+import server
+
+
+pub_key = PublicKey(env.n, env.g)
+priv_key = PrivateKey(env.p, env.q)
+
+def insert_employee():
+    print('*** Insert employee ***')
+    id = int(input('Id: '))
+    name = fm.convertTextToBigInt(input('Name: '))
+    salary = int(input('Salary: '))
+    bonus = int(input('Bonus: '))
+    record = {
+        'id': id,
+        'name': encrypt(name, pub_key),
+        'salary': encrypt(salary, pub_key),
+        'bonus': encrypt(bonus, pub_key)
+    }
+    server.insert('employees', record)
+    print("Successfully insert!")
+    print(record)
+
+def select_employee():
+    print('*** Select employee ***')
+    id = int(input('Id: '))
+    record = server.select('employees', id)
+    name = fm.convertBigIntToText(decrypt(int(record[1]), pub_key, priv_key))
+    salary = decrypt(int(record[2]), pub_key, priv_key)
+    bonus = decrypt(int(record[3]), pub_key, priv_key)
+    print('(id, name, salary, bonus) = ')
+    return (id, name, salary, bonus)
+
+def select_employee_earning():
+    ''' Get information (id, name, earning = salary + bonus) '''
+    print('*** Compute the total earning (salary + bonus) ***')
+    id = int(input('Id: '))
+    earning_cp = server.compute_add('employees', id, 'salary', 'bonus')
+    earning = decrypt(earning_cp, pub_key, priv_key)
+    return earning
+
+

__pycache__/config.cpython-36.pyc

@@ -0,0 +1,5 @@
+class DB_INFO():
+    HOST = 'localhost'
+    USER = 'pauker'
+    PASSWORD = 'Canh1997'
+    DATABASE = 'vkr'

__pycache__/config.cpython-38.pyc

@@ -0,0 +1,34 @@
+import pymysql
+from config import DB_INFO
+
+class DB:
+    def __init__(self, table_name):
+        self.table_name = table_name
+        self.db = pymysql.connect(host=DB_INFO.HOST, user=DB_INFO.USER, password=DB_INFO.PASSWORD, database=DB_INFO.DATABASE)
+        self.cursor = self.db.cursor()
+
+    def insert(self, record):
+        # record as dictionary, for example record = { 'id': '163388383', 'firstname': 'Canh', 'lastname': 'Pham'}
+        cols = ','.join([key for key in record.keys()])
+        values = ','.join(["'%s'" % record[key] for key in record.keys()])
+        self.cursor.execute("insert into %s(%s) values(%s)" % (self.table_name, cols, values))
+        self.db.commit()
+        self.db.close()
+
+    def select(self, record_id, cols_fm):
+        self.cursor.execute("select %s from %s where id=%d" % (cols_fm, self.table_name, record_id))
+        record = self.cursor.fetchone()
+        return record
+
+    def update(self, record):
+        pass
+
+# id = input('id: ')
+# fn = input('fn: ')
+# ln = input('ln: ')
+# people_table = DB('people')
+# people_table.create({
+#     'id': id,
+#     'firstname': fn,
+#     'lastname': ln
+# })

__pycache__/db.cpython-38.pyc

@@ -0,0 +1,8 @@
+n = 7596238295992501343379984544921854753427452278211909359118871971667995208239296651618176087957127116930070597713367091167783114499854597260903224370068527
+g = 7596238295992501343379984544921854753427452278211909359118871971667995208239296651618176087957127116930070597713367091167783114499854597260903224370068528
+l = 7596238295992501343379984544921854753427452278211909359118871971667995208239121722500271097772284204892417914243128252357026642344249010237270160072879960
+m = 1999609890005243941104387215857132045082910494179242740406745949914304042451544646303689119220714376581379362826108686102169857326572572901658889022530870
+
+
+p = 94800141871526686020399314340878561844414115309419113448886350995911249316411
+q = 80128976033463498822512723311804908394424695447053042156700672637153047872157

__pycache__/env.cpython-36.pyc

@@ -0,0 +1,15 @@
+def convertTextToBin(text):
+    return ''.join(format(ord(x), 'b').zfill(8) for x in text)
+
+def convertTextToBigInt(text):
+    text_as_bin = convertTextToBin(text)
+    return int(text_as_bin, 2)
+
+def convertBigIntToText(num):
+    num_as_bin = bin(num)[2:]
+    text = ''
+    while num_as_bin != '':
+        last_8_bit = num_as_bin[-8:]
+        num_as_bin = num_as_bin[:-8]
+        text += chr(int(last_8_bit, 2))
+    return text[::-1]

__pycache__/env.cpython-38.pyc

@@ -0,0 +1,4 @@
+import paillier
+
+a = paillier.generateNewKeys()
+print(a)

__pycache__/fm.cpython-38.pyc

@@ -0,0 +1,20 @@
+import random
+
+def invmod(num, mod):
+    if mod == 1:
+        raise ValueError('Modulo can not be 1.')
+
+    r0 = num
+    r1 = mod
+    s0 = 1
+    s1 = 0
+
+    while r1:
+        q = r0 // r1
+        [r0, r1] = [r1, r0 - q * r1]
+        [s0, s1] = [s1, s0 - q * s1]
+    
+    if r0 == 1:
+        return s0
+    else:
+        raise ValueError('%d has no inverse mod %d' % (num, mod))

__pycache__/modulo.cpython-36.pyc

@@ -0,0 +1,81 @@
+import primes
+import random
+import modulo
+import math
+import time
+
+import env
+
+
+class PublicKey:
+    def __init__(self, n = None, g = None):
+        self.n = n
+        self.g = g
+        self.n_sq = n * n if n else None
+    def generate(self, p, q):
+        self.n = p * q
+        self.g = self.n + 1
+        self.n_sq = self.n * self.n
+    def show(self):
+        print('n = %d' % self.n)
+        print('g = %d' % self.g)
+
+class PrivateKey:
+    def __init__(self, p, q):
+        self.l = (p - 1) * (q - 1)
+        n = p * q
+        self.m = modulo.invmod(self.l, n)
+    def show(self):
+        print('l = %d' % self.l)
+        print('m = %d' % self.m)
+
+
+def generateNewKeys(size):
+    p =primes.generatePrime(size >> 1)
+    q = primes.generatePrime(size >> 1)
+    print(p)
+    print(q)
+    pub_key = PublicKey()
+    pub_key.generate(p, q)
+    pri_key = PrivateKey(p, q)
+    return [pub_key, pri_key]
+
+def encrypt(plain, pub_key: PublicKey):
+    r = random.randint(1, pub_key.n)
+    # c = g^m * r^n % n^2 = ((g^m % n^2) * (r^n % n^2)) % n^2 = (c1 * c2) % n^2
+    c1 = pow(pub_key.g, plain, pub_key.n_sq)
+    c2 = pow(r, pub_key.n, pub_key.n_sq)
+    cipher = c1 * c2 % pub_key.n_sq
+    return cipher
+
+def decrypt(cipher, pub_key: PublicKey, pri_key: PrivateKey):
+    x = pow(cipher, pri_key.l, pub_key.n_sq)
+    Lx = (x - 1) // pub_key.n
+    plain = Lx * pri_key.m % pub_key.n
+    return plain
+
+def e_add(cipher_1, cipher_2, pub_key: PublicKey):
+    return cipher_1 * cipher_2 % pub_key.n_sq
+
+def getBitOfPos(num, pos):
+    return (num >> pos) & 1
+
+
+
+# t0 = time.perf_counter()
+# pub_key, pri_key = generateNewKeys(512)
+# print("Time of key generation: ", time.perf_counter() - t0)
+# pub_key.show()
+# pri_key.show()
+# print("Key was generated!")
+# for i in range(10):
+#     t0 = time.perf_counter()
+
+#     m = random.randint(0, pub_key.n)    
+#     c = encrypt(m, pub_key)
+#     res_m = decrypt(c, pub_key, pri_key)
+#     if (m != res_m):
+#         print("error")
+#     print(c)
+
+#     print(time.perf_counter() - t0)

__pycache__/modulo.cpython-38.pyc

@@ -0,0 +1,33 @@
+import random, math
+import time
+
+def isPropbablyPrime(n, k=128):
+    k = int(math.log2(n))
+    # find s and m such that n - 1 = 2^s * m, m is odd
+    m = n - 1
+    s = 0
+    while not m & 1:
+        m >>= 1
+        s += 1
+
+    for i in range(k):
+        a = random.randint(2, n - 1)
+        b = pow(a, m, n)
+        if b % n == 1:
+            break
+        else:
+            for j in range(s+1):
+                if b % n == n - 1:
+                    break
+                b = pow(b, 2, n)
+                if j == s:
+                    return False
+    return True
+
+
+def generatePrime(size=1024):
+    while True:
+        num = random.getrandbits(size)
+        num |= (1 << size - 1) | 1
+        if isPropbablyPrime(num):
+            return num

__pycache__/paillier.cpython-36.pyc

@@ -0,0 +1,23 @@
+import db
+import fm
+from paillier import PublicKey, e_add
+import env
+
+def insert(table_name, record):
+    table_db = db.DB(table_name)
+    table_db.insert(record)
+
+def select(table_name, record_id):
+    pub_key = PublicKey(env.n, env.g)
+    table_db = db.DB(table_name)
+    record = table_db.select(record_id, '*')
+    return record
+
+def compute_add(table_name, record_id, col_1, col_2):
+    pub_key = PublicKey(env.n, env.g)
+    table_db = db.DB(table_name)
+    record = table_db.select(record_id, '%s, %s' % (col_1, col_2))
+    col_1_value = int(record[0])
+    col_2_value = int(record[1])
+    return e_add(col_1_value, col_2_value, pub_key)
+

__pycache__/paillier.cpython-38.pyc

@@ -0,0 +1,39 @@
+import random, sys, time
+from paillier import PublicKey, PrivateKey, encrypt, decrypt, e_add
+import pymysql
+import env
+import fm
+
+db = pymysql.connect(host="localhost", user="pauker", password="Canh1997", database="vkr")
+
+cursor = db.cursor()
+
+# id = int(input('id: '))
+name = fm.convertTextToBigInt(input('Name: '))
+salary = int(input('Salary: '))
+bonus = int(input('Bonus: '))
+
+# fn = fm.convertTextToBigInt(input('fn: '))
+# ln = fm.convertTextToBigInt(input('ln: '))
+
+pub_key = PublicKey(env.p, env.q)
+priv_key = PrivateKey(env.p, env.q)
+
+
+record = {
+    # 'id': id,
+    'name': encrypt(name, pub_key),
+    'salary': encrypt(salary, pub_key),
+    'bonus': encrypt(bonus, pub_key)
+}
+
+
+
+cols = ','.join([key for key in record.keys()])
+values = ','.join(["'%s'" % record[key] for key in record.keys()])
+
+x = cursor.execute("insert into employees(" + cols +  ") values(" + values + ")")
+
+db.commit()
+
+db.close()

__pycache__/primes.cpython-36.pyc

@@ -0,0 +1,14 @@
+import random, sys, time
+from paillier import PublicKey, PrivateKey, encrypt, decrypt
+import pymysql
+import env
+
+pub_key = PublicKey()
+pub_key.generate(env.p, env.q)
+priv_key = PrivateKey(env.p, env.q)
+
+
+
+cipher = 4569029418934595882408894686435184711753241898337409515982294979812425608353688992049953178276903628203193780432273590241137400881179420350617677405349824831881020687930893870322505212474099269434149526411761228619963371596258233105869998301743333446220271984432155548958998995398958269492848420521296521295
+text = decrypt(cipher, pub_key, priv_key)
+print(text)

__pycache__/primes.cpython-38.pyc

@@ -0,0 +1,26 @@
+import db
+import fm
+from paillier import PublicKey, PrivateKey, encrypt, decrypt, e_add
+import env
+
+
+name = fm.convertTextToBigInt(input('Name: '))
+salary = int(input('Salary: '))
+bonus = int(input('Bonus: '))
+
+# fn = fm.convertTextToBigInt(input('fn: '))
+# ln = fm.convertTextToBigInt(input('ln: '))
+
+pub_key = PublicKey(env.n, env.g)
+priv_key = PrivateKey(env.p, env.q)
+
+
+record = {
+    # 'id': id,
+    'name': encrypt(name, pub_key),
+    'salary': encrypt(salary, pub_key),
+    'bonus': encrypt(bonus, pub_key)
+}
+
+employees_db = db.DB('employees')
+employees_db.insert(record)

__pycache__/server.cpython-38.pyc

@@ -0,0 +1,24 @@
+import random, sys, time
+from paillier import PublicKey, PrivateKey, encrypt, decrypt
+import pymysql
+import env
+import fm
+
+
+pub_key = PublicKey(env.p, env.q)
+priv_key = PrivateKey(env.p, env.q)
+
+priv_key.show()
+
+name = fm.convertTextToBigInt(input('Name: '))
+print(name)
+cp_name = encrypt(name, pub_key)
+rv_name = decrypt(cp_name, pub_key, priv_key)
+rv_name = fm.convertBigIntToText(rv_name)
+print(rv_name)
+
+
+# salary = int(input('Salary: '))
+# cp_salary = encrypt(salary, pub_key)
+# rv_salary = decrypt(cp_salary, pub_key, priv_key)
+# print(rv_salary)