def serialize(self): return json.dumps({ 'lts': self.lts.serialize(), 'sts': self.sts.serialize(), 'k_c': serialize(self.k_c), 's': serialize(self.s) })
def eval(self, k, input1): if type(k) == integer: h = hmac.new(serialize(k), b'', hashlib.sha1) else: h = hmac.new(serialize(integer(k)), b'', hashlib.sha1) h.update(input1) return Conversion.bytes2integer(h.hexdigest())
def genKeyPair(bcp, keyPairPath='keyPair'): pk, sk = bcp.KeyGen() file = open(keyPairPath, 'w') file.write(serialize(pk) + '\n') file.write(serialize(sk)) file.close() return pk, sk
def serialize(self): return json.dumps({ 'p': serialize(self.p), 'q': serialize(self.q), 'g': serialize(self.g), 'r': str(self.r), 'num_bits': str(self.num_bits) })
def store(self, recordType, msg): if recordType.lower() == "general": ID = self.General[0] elif recordType.lower() == "medical": ID = self.Medical[0] elif recordType.lower() == "training": ID = self.Training[0] else: print("Please enter the correct record type") return ct = self.pre.encrypt(self.params, ID, msg) # Serialise the ct for storage in MySql using appropriate charm API for each element type # Differentiate between the Integer element and the PairingGroup elements (Otherwise cannot seialise) # After serialisation, type is byte db = Database() ctI = serialize(ct['C']['C']) # type of ctI is Integer. Use serialise API del ct['C']['C'] ctPg = objectToBytes(ct, self.group) # type of ctPG is PairingGroup. Use objectToBytes API ################### #MD: Todo: Add date to signature ###################### # Get the mastser public key from the SignKeys table # mPK_bytes = db.getSignPubKey("master") # bytes of the master public key # mPK = bytesToObject(mPK_bytes, self.signGroup) # de-serialize the key before usage date = time.strftime("%Y-%m-%d %H:%M:%S") signature = objectToBytes(self.waters.sign(self.masterPK, self.signK, ''.join(msg + date)), self.signGroup) db.insertRecord(ID, ctI, ctPg, signature, date, self.ID) db.done()
def addKey(self, ID1, ID2, rk): keystring = ID1 + ":" + ID2 n = serialize(rk['N']) r = objectToBytes(rk['R'], self.group) self.reEncryptionKeys[keystring] = rk
def serialize(self): return json.dumps({ 'ltp': self.ltp.serialize(), 'stp': self.stp.serialize(), 'r': serialize(self.r), 'kgcPk': self.kgcPk.serialize() })
def get_vote(): vote = raw_input("Enter your vote: ") #get vote from user vote = long(vote) #Initial setup for Paillier group = RSAGroup() pai = pkenc_paillier99.Pai99(group) #Get public voting public key f=open("./pyssss/VotingPublic") data = f.read() public_key = bytesToObject(data,group) #Encryption with Paillier vote = pai.encode(public_key['n'],vote) ciphervote = pai.encrypt(public_key,vote) # ciphervotestr = str(str(ciphervote['c']).split('mod')[0]) # print ciphervote['c'] ciphervote = specialInt.serialize(ciphervote['c']) #pad vote while (len(ciphervote) < voteSize): ciphervote += " " print ciphervote return ciphervote
def b64encode(d): if isinstance(d, (list, tuple)): return [b64encode(a) for a in d] if isinstance(d, dict): return { k: b64encode(v) if k not in ["cmd", "status", "msg", "name"] else v for k, v in d.items() } return base64.b64encode(serialize(d)).decode('UTF-8')
def keyGen(secparam=1024, paramPath='param', mkPath='mk'): bcp = BCP(secparam) MK = bcp.GetMK() param = bcp.GetParam() file = open(paramPath, 'w') file.write(serialize(param.N2) + '\n') file.write(serialize(param.N) + '\n') file.write(serialize(param.k) + '\n') file.write(serialize(param.g)) file.close() file2 = open(mkPath, 'w') file2.write(serialize(MK['pp']) + '\n') file2.write(serialize(MK['qq'])) file2.close()
def get_vote(): vote = 2 group = RSAGroup() pai = pkenc_paillier99.Pai99(group) f=open('./pyssss/VotingPublic','rb') data = f.read() public_key = bytesToObject(data,group) vote = pai.encode(public_key['n'],vote) ciphervote = pai.encrypt(public_key,vote) print ciphervote['c'] ciphertext= specialInt.serialize(ciphervote['c']) print ciphertext # ciphervote['c'] = Conversion.bytes2integer(Conversion.IP2OS(7092577248503691820499926901328776752053429606540181306976)) f=open('./pyssss/VotingPrivate','rb') data = f.read() secret_key = bytesToObject(data,group) ciphertext = specialInt.deserialize(ciphertext) #plaintext=pai.decrypt(public_key, secret_key,ciphervote) n, n2 = public_key['n'], public_key['n2'] plaintext = ((pai.L(ciphertext ** secret_key['lamda'],n) % n) * secret_key['u']) %n print plaintext ciphervote=42 return ciphervote
def serialize(self): return json.dumps({'t': serialize(self.t)})
def serialize(self, object): assert type(object) == integer, "cannot serialize non-integer types" return serialize(object)
def verify(u, m, s): print("VERIFY:") print("1. Compute c'") d_1_1 = (u['a_0']**s['c']) * s['T_1']**(s['s_1'] - s['c'] * (2**gamma_1)) d_1_2 = (u['a']**(s['s_2'] - s['c'] * (2**lambda_1))) * u['y']**s['s_3'] d_1 = (d_1_1 / d_1_2) % u['n'] d_2 = ((s['T_2']**(s['s_1'] - s['c'] * (2**gamma_1))) / u['g']**s['s_3']) % u['n'] d_3 = (s['T_2']**s['c'] * u['g']**s['s_4']) % u['n'] d_4 = (s['T_3']**s['c'] * u['g']**(s['s_1'] - s['c'] * (2**gamma_1)) * u['h']**s['s_4']) % u['n'] c = integer( int( hashlib.sha1( serialize(u['g']) + serialize(u['h']) + serialize(u['y']) + serialize(u['a_0']) + serialize(u['a']) + serialize(s['T_1']) + serialize(s['T_2']) + serialize(s['T_3']) + serialize(d_1) + serialize(d_2) + serialize(d_3) + serialize(d_4) + m.encode()).hexdigest(), 16)) print("2. Accept if and only if c = c'") if c == s['c']: print("ACCEPT") return True else: print("NOT ACCEPTED") return False
def sign(u, m): print("SIGN:") print("1. Generate random value w") w = random(2**l_p) T_1 = (u['A'] * u['y']**w) % u['n'] T_2 = (u['g']**w) % u['n'] T_3 = ((u['g']**u['e']) * (u['h']**w)) % u['n'] print("2. Randomly choose r_1, r_2, r_3, and r_4") r_1 = random(2**(eps * (gamma_2 + k))) r_2 = random(2**(eps * (lambda_2 + k))) r_3 = random(2**(eps * (gamma_1 + 2 * l_p + k + 1))) r_4 = random(2**(eps * (2 * l_p + k))) print("(a) d_1, d_2, d_3, d_4") d_1 = ((T_1**r_1) / ((u['a']**r_2) * (u['y']**r_3))) % u['n'] d_2 = ((T_2**r_1) / (u['g']**r_3)) % u['n'] d_3 = (u['g']**r_4) % u['n'] d_4 = ((u['g']**r_1) * (u['h']**r_4)) % u['n'] print("(b) c = HASH()") c = integer( int( hashlib.sha1( serialize(u['g']) + serialize(u['h']) + serialize(u['y']) + serialize(u['a_0']) + serialize(u['a']) + serialize(T_1) + serialize(T_2) + serialize(T_3) + serialize(d_1) + serialize(d_2) + serialize(d_3) + serialize(d_4) + m.encode()).hexdigest(), 16)) print("(c) s_1, s_2, s_3, s_4") s_1 = integer(r_1) - c * (integer(u['e']) - 2**gamma_1) s_2 = integer(r_2) - c * (integer(u['x']) - 2**lambda_1) s_3 = integer(r_3) - c * integer(u['e']) * integer(w) s_4 = integer(r_4) - c * integer(w) print("3. Output signature") return { "c": c, "s_1": s_1, "s_2": s_2, "s_3": s_3, "s_4": s_4, "T_1": T_1, "T_2": T_2, "T_3": T_3 }
from charm.core.math.integer import serialize, deserialize print 'begin()' # start = time.clock() # keyGen() # print 'generator done, cost %s seconds',time.clock() - start start = time.clock() bcp = genBCPContext(paramPath='param') # pk,sk = genKeyPair(bcp, keyPairPath = 'keyPair') pk, sk = readKeyPairFromFile(keyPairPath='keyPair') ciphertext1 = bcp.Encrypt(pk, 12) file = open('Cipher', 'w') file.write(serialize(ciphertext1['A'])) #file.write(serialize(ciphertext1['A'])+'\n'+'\n') file.write(serialize(ciphertext1['B'])) ciphertext2 = bcp.Encrypt(pk, 18) #for index in range(1000): ciphertext1 = bcp.multiply(ciphertext1, ciphertext2) m = bcp.Decrypt(ciphertext1, sk) print 'm is ', m print 'generator done, cost %s seconds' % (time.clock() - start) start1 = time.clock() pk, sk = genKeyPair(bcp, keyPairPath='keyPair') print 'The time of generate keypair is: %s' % (time.clock() - start1) start2 = time.clock() bcp = BCP(1024) mk = bcp.GetMK() print 'The time of generate Mainkey is: %s' % (time.clock() - start2)
def serialize(self): return json.dumps({'x': serialize(self.x)})
def serialize(self): return json.dumps({'y': serialize(self.y)})
def serialize(self): return json.dumps({'r': serialize(self.r), 's': serialize(self.s)})
def serialize(self): return json.dumps({'u': serialize(self.u)})