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 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 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 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)})
