def _hashKey(self, z1, z2, keyType):
h = sha256()
z1bytes = int2Bytes(z1)
z2bytes = int2Bytes(z2)
#import binascii
#print 'z1=', binascii.hexlify(z1bytes)
#print 'z2=', binascii.hexlify(z2bytes)
h.update(z1bytes)
h.update(z2bytes)
return h.digest()
def decryptSecondLevel(self, params, skid, IDsrc, ID, cid):
K = pair(group.hash(IDsrc, G1), skid['skid'])
sigma = cid['B'] * pair(cid['A'], group.hash((K, IDsrc, ID, cid['N']), G1))
m = cid['C'] ^ h.hashToZn(sigma)
r = h.hashToZr(sigma,m)
if (cid['A'] != params['g'] ** r):
if debug: print("Decryption second level Failed")
return None
if(debug):
print('\nDecrypting Second Level...')
print('K => %s' % K)
print('sigma => %s' % sigma)
print(int2Bytes(m))
return int2Bytes(m)
def decryptSecondLevel(self, params, skid, IDsrc, ID, cid):
K = pair(group.hash(IDsrc, G1), skid['skid'])
sigma = cid['B'] * pair(cid['A'], group.hash((K, IDsrc, ID, cid['N']), G1))
m = cid['C'] ^ h.hashToZn(sigma)
r = h.hashToZr(sigma,m)
if (cid['A'] != params['g'] ** r):
if debug: print("Decryption second level Failed")
return None
if(debug):
print('\nDecrypting Second Level...')
print('K => %s' % K)
print('sigma => %s' % sigma)
print int2Bytes(m)
return int2Bytes(m)
def decryptFirstLevel(self, params, skid, cid, ID):
H = group.hash((ID, cid['C']), G1)
t = group.random(ZR)
sigma = cid['C']['B'] / (pair(cid['C']['A'], skid['skid'] * H ** t)/pair(params['g'] ** t, cid['S']))
m = cid['C']['C'] ^ h.hashToZn(sigma)
r = h.hashToZr(sigma,m)
if (cid['S'] != H**r) or (cid['C']['A'] != params['g'] ** r):
if debug: print("Decryption Failed")
return None
if(debug):
print('\nDecrypting...')
print('H => %s' % H)
print('t => %s' % t)
print('r => %s' % r)
print('sigma => %s' % sigma)
print(int2Bytes(m))
return int2Bytes(m)
def decryptFirstLevel(self, params, skid, cid, ID):
H = group.hash((ID, cid['C']), G1)
t = group.random(ZR)
sigma = cid['C']['B'] / (pair(cid['C']['A'], skid['skid'] * H ** t)/pair(params['g'] ** t, cid['S']))
m = cid['C']['C'] ^ h.hashToZn(sigma)
r = h.hashToZr(sigma,m)
if (cid['S'] != H**r) or (cid['C']['A'] != params['g'] ** r):
if debug: print("Decryption Failed")
return None
if(debug):
print('\nDecrypting...')
print('H => %s' % H)
print('t => %s' % t)
print('r => %s' % r)
print('sigma => %s' % sigma)
print int2Bytes(m)
return int2Bytes(m)
def hashToZn(self, value):
if type(value) == pc_element:
h = hashlib.new(self.hash_type)
h.update(self.group.serialize(value))
#print "digest => %s" % h.hexdigest()
# get raw bytes of digest and hash to Zr
val = h.digest()
return integer(int(self.group.hash(val, ZR)))
# do something related to that
if type(value) == integer:
str_value = int2Bytes(value)
#print("str_value =>", str_value)
#val = self.group.hash(str_value, ZR)
#print("hash =>", val)
return integer(int(self.group.hash(str_value, ZR)))
return None
def hashToZn1(self, value):
if type(value) == pc_element:
h = hashlib.new(self.hash_type)
h.update(self.group.serialize(value))
#print "digest => %s" % h.hexdigest()
# get raw bytes of digest and hash to Zr
val = h.digest()
return integer(int(unicode(self.group.hash(val, ZR))))
# do something related to that
if type(value) == integer:
str_value = int2Bytes(value)
#print("str_value =>", str_value)
#val = self.group.hash(str_value, ZR)
#print("hash =>", val)
return integer(int(unicode(self.group.hash(str_value, ZR))))
return None
def hashToZr(self, *args):
if isinstance(args, tuple):
#print("Hashing =>", args)
strs = ""
for i in args:
if type(i) == str:
strs += str(base64.encodebytes(bytes(i, 'utf8')))
elif type(i) == bytes:
strs += str(base64.encodebytes(i))
elif type(i) == integer:
strs += str(base64.encodebytes(int2Bytes(i)))
elif type(i) == pc_element:
strs += str(base64.encodebytes(self.group.serialize(i)))
if len(strs) > 0:
return self.group.hash(strs, ZR)
return None
def hashToZr1(self, *args):
if isinstance(args, tuple):
#print("Hashing =>", args)
strs = ""
for i in args:
if type(i) == unicode:
strs += unicode(base64.encodestring(i))
elif type(i) == bytes:
strs += unicode(base64.encodestring(i))
elif type(i) == integer:
strs += unicode(base64.encodestring(int2Bytes(i)))
elif type(i) == pc_element:
strs += unicode(base64.encodestring(self.group.serialize(i)))
if len(strs) > 0:
return self.group.hash(strs, ZR)
return None
def hashToZr(self, *args):
if isinstance(args, tuple):
#print("Hashing =>", args)
strs = ""
for i in args:
if type(i) == str:
strs += str(base64.encodebytes(bytes(i, 'utf8')))
elif type(i) == bytes:
strs += str(base64.encodebytes(i))
elif type(i) == integer:
strs += str(base64.encodebytes(int2Bytes(i)))
elif type(i) == pairing:
strs += str(base64.encodebytes(self.group.serialize(i)))
if len(strs) > 0:
return self.group.hash(strs, ZR)
return None
def hashToZr(self, *args):
if isinstance(args, tuple):
#print("Hashing =>", args)
strs = ""
for i in args:
if type(i) == unicode:
strs += unicode(base64.encodestring(i))
elif type(i) == bytes:
strs += unicode(base64.encodestring(i))
elif type(i) == integer:
strs += unicode(base64.encodestring(int2Bytes(i)))
elif type(i) == pairing:
strs += unicode(
base64.encodestring(self.group.serialize(i)))
if len(strs) > 0:
return self.group.hash(strs, ZR)
return None
def i2v(self, CList, kunodes):
Package = namedtuple('Package', 'destination payload flag')
dataStream = []
candidate = []
pseuIDs = []
flags = []
tempRunner = []
for ct in CList:
U = ct[0]
V = ct[1]
pseuID = self.group.deserialize( int2Bytes( V ^ integer(self.group.serialize(pair(U, self.sk)))))
symKey = hashlib.sha256(self.group.serialize(pair(pseuID, self.sk))).digest()
cipherRuner = AuthenticatedCryptoAbstraction(symKey)
tempRunner.append(cipherRuner)
pathList = json.loads(cipherRuner.decrypt(ct[2]))
pathValue = [int(x) for x in pathList]
tempFlag = set(pathValue) & kunodes
flags.append(bool(tempFlag))
pseuIDs.append(pseuID)
if tempFlag:
candidate.append(str(self.group.serialize(pseuID), encoding = 'utf-8'))
# dataStream.append(Package(pseuID, '', set(pathValue) & kunodes))
for index, pid in enumerate(pseuIDs):
if flags[index]:
payload = tempRunner[index].encrypt(json.dumps(candidate))
dataStream.append(Package(pid, payload, flags[index]))
else:
dataStream.append(Package(pid, 'You are blocked', flags[index]))
return dataStream
def __init__(self, secparam=1024, param=None):
if param:
self.N2 = param.N2
self.N = param.N
self.g = param.g
self.k = param.k
else:
self.p, self.q = randomPrime(int(secparam / 2), True), randomPrime(
int(secparam / 2), True)
self.pp = (self.p - 1) / 2
self.qq = (self.q - 1) / 2
self.N = self.p * self.q
while True: # choose a good N
if bitsize(self.N) == secparam and len(int2Bytes(
self.N)) == int(
secparam / 8) and int2Bytes(self.N)[0] & 128 != 0:
break
self.p, self.q = randomPrime(int(secparam / 2),
True), randomPrime(
int(secparam / 2), True)
self.pp = (self.p - 1) / 2
self.qq = (self.q - 1) / 2
self.N = self.p * self.q
self.N2 = self.N**2
self.g = random(self.N2)
one = integer(1) % self.N2
while True: #choose a good g
self.g = random(self.N2)
self.g = integer(
(int(self.g) - 1) * (int(self.g) - 1)) % self.N2
if self.g == one:
continue
tmp = self.g**self.p % self.N2
if tmp == one:
continue
tmp = self.g**self.pp % self.N2
if tmp == one:
continue
tmp = self.g**self.q % self.N2
if tmp == one:
continue
tmp = self.g**self.qq % self.N2
if tmp == one:
continue
tmp = self.g**(self.p * self.pp) % self.N2
if tmp == one:
continue
tmp = self.g**(self.p * self.q) % self.N2
if tmp == one:
continue
tmp = self.g**(self.p * self.qq) % self.N2
if tmp == one:
continue
tmp = self.g**(self.pp * self.q) % self.N2
if tmp == one:
continue
tmp = self.g**(self.pp * self.qq) % self.N2
if tmp == one:
continue
tmp = self.g**(self.q * self.qq) % self.N2
if tmp == one:
continue
tmp = self.g**(self.q * self.qq) % self.N2
if tmp == one:
continue
tmp = self.g**(self.p * self.pp * self.q) % self.N2
if tmp == one:
continue
tmp = self.g**(self.p * self.pp * self.qq) % self.N2
if tmp == one:
continue
tmp = self.g**(self.p * self.q * self.qq) % self.N2
if tmp == one:
continue
tmp = self.g**(self.pp * self.q * self.qq) % self.N2
if tmp == one:
continue
break
self.k = integer(
(int(self.g**(self.pp * self.qq)) - 1)) / self.N % self.N
self.MK = {"pp": self.pp, "qq": self.qq}
