def encrypt(mpk, M, id):
global c0
global c2
global c4
global c3
global c1
global cpr
input = [mpk, M, id]
omega, g, h, gl, hl, v1, v2, v3, v4, n, l = mpk
s = group.random(ZR)
s1 = group.random(ZR)
s2 = group.random(ZR)
hID1 = stringToInt(id, 5, 32)
hashID1DotProd = dotprod2(range(0,n), lam_func2, gl, hID1)
hashID1 = (gl[0] * hashID1DotProd)
cpr = ((omega ** s) * M)
c0 = (hashID1 ** s)
c1 = (v1 ** (s - s1))
c2 = (v2 ** s1)
c3 = (v3 ** (s - s2))
c4 = (v4 ** s2)
ct = [c0, c1, c2, c3, c4, cpr]
output = ct
return output
def extract(self, level, mpk, mk, ID):
j = level
assert j >= 1 and j <= mpk['l'], "invalid level: 1 - %d" % mpk['l']
I = Waters(group, j, mpk['z']).hash(ID)
r = [group.random(ZR) for i in range(j)]
g_b = [mpk['gb'] ** r[i] for i in range(j)]
hashID = mk['g0b'] * dotprod2(range(j), hash_func, mpk['g1b'], I, mpk['hb'], r)
return { 'ID':ID, 'j':j }, { 'd0':hashID, 'dn':g_b }
def extract(self, level, mpk, mk, ID):
j = level
assert j >= 1 and j <= mpk['l'], "invalid level: 1 - %d" % mpk['l']
I = Waters(group, j, mpk['z']).hash(ID)
r = [group.random(ZR) for i in range(j)]
g_b = [mpk['gb']**r[i] for i in range(j)]
hashID = mk['g0b'] * dotprod2(range(j), hash_func, mpk['g1b'], I,
mpk['hb'], r)
return {'ID': ID, 'j': j}, {'d0': hashID, 'dn': g_b}
def derive(self, mpk, pk):
j = pk['j'] # pk[j-1]
assert pk['j'] + 1 <= mpk['l'], "invalid level: 1 - %d" % mpk['l']
I = Waters(group, j, mpk['z']).hash(pk['ID'])
r = [group.random(ZR) for i in range(j)]
g_b = [pk['dn'][i] * (mpk['gb'] ** r[i]) for i in range(j)] # j-1
g_b.append( pk['gb'] ** r[j] ) # represents j
hashID = dID['d0'] * dotprod2(range(j+1), hash_func, mpk['g1b'], I, mpk['hb'], r)
return { 'ID':ID, 'j':j }, { 'd0':hashID, 'dn':g_b}
def derive(self, mpk, pk):
j = pk['j'] # pk[j-1]
assert pk['j'] + 1 <= mpk['l'], "invalid level: 1 - %d" % mpk['l']
I = Waters(group, j, mpk['z']).hash(pk['ID'])
r = [group.random(ZR) for i in range(j)]
g_b = [pk['dn'][i] * (mpk['gb']**r[i]) for i in range(j)] # j-1
g_b.append(pk['gb']**r[j]) # represents j
hashID = dID['d0'] * dotprod2(range(j + 1), hash_func, mpk['g1b'], I,
mpk['hb'], r)
return {'ID': ID, 'j': j}, {'d0': hashID, 'dn': g_b}
def encrypt(self, mpk, ID, msg):
s, s1, s2 = group.random(ZR, 3)
hID = waters.hash(ID)
hashID1 = mpk['g_l'][0] * dotprod2(range(1,mpk['n']), lam_func, mpk['g_l'], hID)
c = {}
c_pr = (mpk['omega'] ** s) * msg
c[0] = hashID1 ** s
c[1] = mpk['v1'] ** (s - s1)
c[2] = mpk['v2'] ** s1
c[3] = mpk['v3'] ** (s - s2)
c[4] = mpk['v4'] ** s2
return {'c':c, 'c_prime':c_pr }
def extract(self, mpk, msk, ID):
r1, r2 = group.random(ZR, 2) # should be params of extract
hID = waters.hash(ID)
hashID2 = mpk['h_l'][0] * dotprod2(range(1,mpk['n']), lam_func, mpk['h_l'], hID)
d = {}
d[0] = mpk['h'] ** ((r1 * msk['t1'] * msk['t2']) + (r2 * msk['t3'] * msk['t4']))
d[1] = (mpk['h'] ** (-msk['alpha'] * msk['t2'])) * (hashID2 ** (-r1 * msk['t2']))
d[2] = (mpk['h'] ** (-msk['alpha'] * msk['t1'])) * (hashID2 ** (-r1 * msk['t1']))
d[3] = hashID2 ** (-r2 * msk['t4'])
d[4] = hashID2 ** (-r2 * msk['t3'])
return { 'd':d }
def encrypt(self, mpk, ID, msg):
s, s1, s2 = group.random(ZR, 3)
hID = waters.hash(ID)
hashID1 = mpk['g_l'][0] * dotprod2(range(1, mpk['n']), lam_func,
mpk['g_l'], hID)
c = {}
c_pr = (mpk['omega']**s) * msg
c[0] = hashID1**s
c[1] = mpk['v1']**(s - s1)
c[2] = mpk['v2']**s1
c[3] = mpk['v3']**(s - s2)
c[4] = mpk['v4']**s2
return {'c': c, 'c_prime': c_pr}
def extract(self, mpk, msk, ID):
r1, r2 = group.random(ZR, 2) # should be params of extract
hID = waters.hash(ID)
hashID2 = mpk['h_l'][0] * dotprod2(range(1, mpk['n']), lam_func,
mpk['h_l'], hID)
d = {}
d[0] = mpk['h']**((r1 * msk['t1'] * msk['t2']) +
(r2 * msk['t3'] * msk['t4']))
d[1] = (mpk['h']**(-msk['alpha'] * msk['t2'])) * (hashID2
**(-r1 * msk['t2']))
d[2] = (mpk['h']**(-msk['alpha'] * msk['t1'])) * (hashID2
**(-r1 * msk['t1']))
d[3] = hashID2**(-r2 * msk['t4'])
d[4] = hashID2**(-r2 * msk['t3'])
return {'d': d}
def extract(mpk, msk, id):
global d4
global d2
global d0
global d3
global d1
input = [mpk, msk, id]
blindingFactord0Blinded = group.random(ZR)
blindingFactord1Blinded = group.random(ZR)
blindingFactord2Blinded = group.random(ZR)
blindingFactor0Blinded = group.random(ZR)
blindingFactor1Blinded = group.random(ZR)
idBlinded = id
zz = group.random(ZR)
omega, g, h, gl, hl, v1, v2, v3, v4, n, l = mpk
alpha, t1, t2, t3, t4 = msk
r1 = group.random(ZR)
r2 = group.random(ZR)
hID = stringToInt(id, 5, 32)
hashIDDotProd = dotprod2(range(0,n), lam_func1, hl, hID)
hashID = (hl[0] * hashIDDotProd)
d0 = (h ** ((r1 * (t1 * t2)) + (r2 * (t3 * t4))))
d0Blinded = (d0 ** (1 / blindingFactord0Blinded))
halpha = (h ** -alpha)
hashID2r1 = (hashID ** -r1)
d1 = ((halpha ** t2) * (hashID2r1 ** t2))
d1Blinded = (d1 ** (1 / blindingFactord1Blinded))
d2 = ((halpha ** t1) * (hashID2r1 ** t1))
d2Blinded = (d2 ** (1 / blindingFactord2Blinded))
hashID2r2 = (hashID ** -r2)
d3 = (hashID2r2 ** t4)
d3Blinded = (d3 ** (1 / blindingFactor0Blinded))
d4 = (hashID2r2 ** t3)
d4Blinded = (d4 ** (1 / blindingFactor1Blinded))
sk = [idBlinded, d0Blinded, d1Blinded, d2Blinded, d3Blinded, d4Blinded]
skBlinded = [idBlinded, d0Blinded, d1Blinded, d2Blinded, d3Blinded, d4Blinded]
output = (blindingFactord0Blinded, blindingFactord1Blinded, blindingFactord2Blinded, blindingFactor0Blinded, blindingFactor0Blinded, blindingFactor1Blinded, blindingFactor1Blinded, skBlinded)
return output
