def verifySigsRecursive(verifyArgsDict, groupObj, incorrectIndices,
startSigNum, endSigNum, delta, dotC, dotB):
z = 0
group = groupObj
l = len(verifyArgsDict[z]['L'][bodyKey])
lam_func = lambda i, a, b, c: a[i] * (b[i]**c[i]
) # => u * (pk ** h) for all signers
H1 = lambda x: group.hash(('1', str(x)), G1)
H2 = lambda a, b, c: group.hash(('2', a, b, c), ZR)
__init__(group)
dotC_loopVal = group.init(G1, 1)
dotB_loopVal = group.init(G1, 1)
for index in range(startSigNum, endSigNum):
dotC_loopVal = dotC_loopVal * dotC[index]
dotB_loopVal = dotB_loopVal * dotB[index]
if (pair(dotB_loopVal, verifyArgsDict[z]['mpk'][bodyKey]['Pub']) == pair(
dotC_loopVal, verifyArgsDict[z]['mpk'][bodyKey]['g'])):
return
else:
midWay = int((endSigNum - startSigNum) / 2)
if (midWay == 0):
if startSigNum not in incorrectIndices:
incorrectIndices.append(startSigNum)
return
midSigNum = startSigNum + midWay
verifySigsRecursive(verifyArgsDict, group, incorrectIndices,
startSigNum, midSigNum, delta, dotC, dotB)
verifySigsRecursive(verifyArgsDict, group, incorrectIndices, midSigNum,
endSigNum, delta, dotC, dotB)
def verify(self, mpk, pk, M, sig):
if debug: print("verify...")
(S1, S2) = sig['S1'], sig['S2']
a = H2(M, S1)
if pair(S2, mpk['g2']) == (pair(pk, mpk['P']) ** a) * S1:
return True
return False
def verifySigsRecursive(verifyArgsDict, groupObj, incorrectIndices, startSigNum, endSigNum, a, h, delta, dotA, dotB, dotC):
z = 0
group = groupObj
H3 = lambda a,b: group.hash(('3', str(a), str(b)), ZR)
H = lambda prefix,x: group.hash((str(prefix), str(x)), G1)
__init__(group)
dotA_loopVal = group.init(G1, 1)
dotB_loopVal = group.init(G2, 1)
dotC_loopVal = group.init(G2, 1)
for index in range(startSigNum, endSigNum):
dotA_loopVal = dotA_loopVal * dotA[index]
dotB_loopVal = dotB_loopVal * dotB[index]
dotC_loopVal = dotC_loopVal * dotC[index]
if ( pair( dotA_loopVal , verifyArgsDict[z]['mpk'][bodyKey] [ 'g' ] )==( pair( a , dotB_loopVal ) * pair( h , dotC_loopVal ) ) ):
return
else:
midWay = int( (endSigNum - startSigNum) / 2)
if (midWay == 0):
incorrectIndices.append(startSigNum)
return
midSigNum = startSigNum + midWay
verifySigsRecursive(verifyArgsDict, group, incorrectIndices, startSigNum, midSigNum, a, h, delta, dotA, dotB, dotC)
verifySigsRecursive(verifyArgsDict, group, incorrectIndices, midSigNum, endSigNum, a, h, delta, dotA, dotB, dotC)
def verifySigsRecursive(verifyArgsDict, groupObj, incorrectIndices, startSigNum, endSigNum, delta, dotC, dotB):
z = 0
group = groupObj
l= len( verifyArgsDict[z]['L'][bodyKey] )
lam_func = lambda i,a,b,c: a[i] * (b[i] ** c[i]) # => u * (pk ** h) for all signers
H1 = lambda x: group.hash(('1', str(x)), G1)
H2 = lambda a, b, c: group.hash(('2', a, b, c), ZR)
__init__(group)
dotC_loopVal = group.init(G1, 1)
dotB_loopVal = group.init(G1, 1)
for index in range(startSigNum, endSigNum):
dotC_loopVal = dotC_loopVal * dotC[index]
dotB_loopVal = dotB_loopVal * dotB[index]
if ( pair( dotB_loopVal , verifyArgsDict[z]['mpk'][bodyKey] [ 'Pub' ] )== pair( dotC_loopVal , verifyArgsDict[z]['mpk'][bodyKey] [ 'g' ] ) ):
return
else:
midWay = int( (endSigNum - startSigNum) / 2)
if (midWay == 0):
incorrectIndices.append(startSigNum)
return
midSigNum = startSigNum + midWay
verifySigsRecursive(verifyArgsDict, group, incorrectIndices, startSigNum, midSigNum, delta, dotC, dotB)
verifySigsRecursive(verifyArgsDict, group, incorrectIndices, midSigNum, endSigNum, delta, dotC, dotB)
def run_Ind(verifyArgsDict, groupObjParam, verifyFuncArgs):
global group
global H, debug, H, H3
group = groupObjParam
N = len(verifyArgsDict)
z = 0
incorrectIndices = []
H3 = lambda a, b: group.hash(('3', str(a), str(b)), ZR)
H = lambda prefix, x: group.hash((str(prefix), str(x)), G1)
__init__(group)
for z in range(0, N):
for arg in verifyFuncArgs:
if (group.ismember(verifyArgsDict[z][arg][bodyKey]) == False):
sys.exit("ALERT: Group membership check failed!!!!\n")
pass
a = H(1, verifyArgsDict[z]['M'][bodyKey]['t1'])
h = H(2, verifyArgsDict[z]['M'][bodyKey]['t2'])
b = H3(verifyArgsDict[z]['M'][bodyKey]['str'],
verifyArgsDict[z]['M'][bodyKey]['t3'])
if pair(verifyArgsDict[z]['sig'][bodyKey],
verifyArgsDict[z]['mpk'][bodyKey]['g']) == (
pair(a, verifyArgsDict[z]['pk'][bodyKey]) *
(pair(h, verifyArgsDict[z]['pk'][bodyKey])**b)):
pass
else:
if z not in incorrectIndices:
incorrectIndices.append(z)
return incorrectIndices
def run_Ind(verifyArgsDict, groupObjParam, verifyFuncArgs):
global group
global debug, H1, H2
group = groupObjParam
N = len(verifyArgsDict)
z = 0
incorrectIndices = []
H2 = lambda x, y: group.hash((x, y), ZR)
H1 = lambda x: group.hash(x, G1)
__init__(group)
for z in range(0, N):
#for arg in verifyFuncArgs:
#if (group.ismember(verifyArgsDict[z][arg][bodyKey]) == False):
#sys.exit("ALERT: Group membership check failed!!!!\n")
pass
if debug: print("verify...")
#( S1 , S2 )= verifyArgsDict[z]['sig'][bodyKey]
S1 = verifyArgsDict[z]['sig'][bodyKey]['S1']
S2 = verifyArgsDict[z]['sig'][bodyKey]['S2']
a = H2(verifyArgsDict[z]['M'][bodyKey], S1)
if pair(S2, verifyArgsDict[z]['mpk'][bodyKey]['g2']) == (pair(
verifyArgsDict[z]['pk'][bodyKey],
verifyArgsDict[z]['mpk'][bodyKey]['P'])**a) * S1:
pass
else:
incorrectIndices.append(z)
return incorrectIndices
def run_Ind(verifyArgsDict, groupObjParam, verifyFuncArgs):
global group
global debug, H1, H2
group = groupObjParam
N = len(verifyArgsDict)
z = 0
incorrectIndices = []
H2 = lambda x,y: group.hash((x,y), ZR)
H1 = lambda x: group.hash(x, G1)
__init__(group)
for z in range(0, N):
#for arg in verifyFuncArgs:
#if (group.ismember(verifyArgsDict[z][arg][bodyKey]) == False):
#sys.exit("ALERT: Group membership check failed!!!!\n")
pass
if debug : print( "verify..." )
#( S1 , S2 )= verifyArgsDict[z]['sig'][bodyKey]
S1= verifyArgsDict[z]['sig'][bodyKey][ 'S1' ]
S2= verifyArgsDict[z]['sig'][bodyKey][ 'S2' ]
a= H2( verifyArgsDict[z]['M'][bodyKey] , S1 )
if pair( S2 , verifyArgsDict[z]['mpk'][bodyKey][ 'g2' ] )==( pair( verifyArgsDict[z]['pk'][bodyKey] , verifyArgsDict[z]['mpk'][bodyKey][ 'P' ] ) ** a ) * S1 :
pass
else:
incorrectIndices.append(z)
return incorrectIndices
def verifySigsRecursive(verifyArgsDict, groupObj, incorrectIndices,
startSigNum, endSigNum, delta, dotA, dotB, dotC):
z = 0
group = groupObj
H2 = lambda x, y: group.hash((x, y), ZR)
H1 = lambda x: group.hash(x, G1)
__init__(group)
dotA_loopVal = group.init(G1, 1)
dotB_loopVal = group.init(G1, 1)
dotC_loopVal = group.init(GT, 1)
for index in range(startSigNum, endSigNum):
dotA_loopVal = dotA_loopVal * dotA[index]
dotB_loopVal = dotB_loopVal * dotB[index]
dotC_loopVal = dotC_loopVal * dotC[index]
if (pair(dotA_loopVal, verifyArgsDict[z]['mpk'][bodyKey]['g2']) == (
pair(dotB_loopVal, verifyArgsDict[z]['mpk'][bodyKey]['P']) *
dotC_loopVal)):
return
else:
midWay = int((endSigNum - startSigNum) / 2)
if (midWay == 0):
if startSigNum not in incorrectIndices:
incorrectIndices.append(startSigNum)
return
midSigNum = startSigNum + midWay
verifySigsRecursive(verifyArgsDict, group, incorrectIndices,
startSigNum, midSigNum, delta, dotA, dotB, dotC)
verifySigsRecursive(verifyArgsDict, group, incorrectIndices, midSigNum,
endSigNum, delta, dotA, dotB, dotC)
def verify(self, mpk, pk, M, sig):
a = H(1, M['t1'])
h = H(2, M['t2'])
b = H3(M['str'], M['t3'])
if pair(sig, mpk['g']) == (pair(a, pk) * (pair(h, pk) ** b)):
return True
return False
def verifySigsRecursive(verifyArgsDict, groupObj, incorrectIndices, startSigNum, endSigNum, delta, dotA, dotB, dotC): z = 0 group = groupObj H2 = lambda x,y: group.hash((x,y), ZR) H1 = lambda x: group.hash(x, G1) __init__(group) dotA_loopVal = group.init(G1, 1) dotB_loopVal = group.init(G1, 1) dotC_loopVal = group.init(GT, 1) for index in range(startSigNum, endSigNum): dotA_loopVal = dotA_loopVal * dotA[index] dotB_loopVal = dotB_loopVal * dotB[index] dotC_loopVal = dotC_loopVal * dotC[index] if ( pair( dotA_loopVal , verifyArgsDict[z]['mpk'][bodyKey] [ 'g2' ] )==( pair( dotB_loopVal , verifyArgsDict[z]['mpk'][bodyKey] [ 'P' ] ) * dotC_loopVal ) ): return else: midWay = int( (endSigNum - startSigNum) / 2) if (midWay == 0): incorrectIndices.append(startSigNum) return midSigNum = startSigNum + midWay verifySigsRecursive(verifyArgsDict, group, incorrectIndices, startSigNum, midSigNum, delta, dotA, dotB, dotC) verifySigsRecursive(verifyArgsDict, group, incorrectIndices, midSigNum, endSigNum, delta, dotA, dotB, dotC)
def gen_common(self):
x, v = self.group.random(ZR, 2)
g = self.group.random(G1)
index = self.group.init(ZR, 1) # testing message 0 at index 1
V = (g ** ~(x+index)) ** v
y = g ** x
print("check: lhs = e(V,y) =>", pair(V,y))
print("check: rhs = e(V,g)^-o * e(g,g)^v =>", (pair(V,g) ** -index) * (pair(g,g) ** v))
Protocol.store(self, ('g', g), ('V', V), ('v',v), ('y',y), ('sigma', index) )
return None
def verify(self, pk, x, st):
n, y, pi, pi_0 = pk['n'], st['y'], st['pi'], st['pi0']
# check first index
check1 = pair(pi[0], pk['g2'])
if x[0] == 0 and check1 == pair(pk['g1'], pk['U_t']):
if debug: print("Verify: check 0 successful!\t\tcase:", x[0])
elif x[0] == 1 and check1 == pair(pk['U1'][0], pk['U_t']):
if debug: print("Verify: check 0 successful!\t\tcase:", x[0])
else:
if debug: print("Verify: check 0 FAILURE!\t\t failed case:", x[0])
return False
for i in range(1, len(x)):
check2 = pair(pi[i], pk['g2'])
if x[i] == 0 and check2 == pair(pi[i-1], pk['g2']):
if debug: print("Verify: check", i ,"successful!\t\tcase:", x[i])
elif x[i] == 1 and check2 == pair(pi[i-1], pk['U2'][i]):
if debug: print("Verify: check", i ,"successful!\t\tcase:", x[i])
else:
if debug: print("Verify: check", i ,"FAILURE!\t\tcase:", x[i])
return False
if pair(pi_0, pk['g2']) == pair(pi[n-1], pk['U2'][0]) and pair(pi_0, pk['h']) == y:
if debug: print("Verify: all and final check successful!!!")
return True
else:
return False
def verifier_state4(self, input):
print("VERIFIER 4: ")
(a1, a2, c, W, z, pk) = Sigma.get(self, ['a1','a2','c','W','z','pk'])
g, V, H = pk['g'], pk['V'], pk['H']
if a1 == pair(g,z) * (H ** c) and a2 == pair(V,z) * (W ** c):
print("SUCCESS!!!!!!!"); result = 'OK'
else:
print("Failed!!!"); result = 'FAIL'
Sigma.setState(self, 6)
Sigma.setErrorCode(self, result)
return result
def verify(self, mpk, ID, M, sig):
if debug:
print("Verify...")
k = self.strToId(mpk, ID)
m = self.strToId(mpk, M)
(S1, S2, S3) = sig["S1"], sig["S2"], sig["S3"]
A, g2 = mpk["A"], mpk["g2"]
comp1 = dotprod(group.init(G2), -1, mpk["z"], lam_func, mpk["ub"], k)
comp2 = dotprod(group.init(G2), -1, mpk["z"], lam_func, mpk["ub"], m)
if (pair(S1, g2) * pair(S2, mpk["u1b"] * comp1) * pair(S3, mpk["u2b"] * comp2)) == A:
return True
return False
def verify(self, pk, msg, sig):
M = group.hash(msg, ZR)
sigma1, sigma2 = sig[1], sig[2]
r, s = sig['r'], sig['i']
S = group.init(ZR, s)
U, V, D = pk['U'], pk['V'], pk['D']
rhs_pair = pair(sigma2, (pk['w2'] * self.ceilog(s)) * (pk['z2'] ** S) * pk['h2'])
if( pair(sigma1, pk['g2']) == (U ** M) * (V ** r) * D * rhs_pair ):
return True
else:
return False
def verifier_state4(self, input):
print("VERIFIER 4: ")
(a, c, z1, z2, pk) = Sigma.get(self, ['a','c','z1','z2','pk'])
g, y, V = pk['g'], pk['y'], pk['V']
print("get a =>", a)
if a == (pair(V,y) ** c) * (pair(V,g) ** -z1) * (pair(g,g) ** z2):
print("SUCCESS!!!!!!!"); result = 'OK'
else:
print("Failed!!!"); result = 'FAIL'
Sigma.setState(self, 6)
Sigma.setErrorCode(self, result)
return result
def verify(self, mpk, L, M, sig):
u, S = sig['u'], sig['S']
Lt = self.concat(L)
num_signers = len(L)
h = [group.init(ZR, 1) for i in range(num_signers)]
for i in range(num_signers):
h[i] = H2(M, Lt, u[i])
pk = [ H1(i) for i in L] # get all signers pub keys
result = dotprod(group.init(G1), -1, num_signers, lam_func, u, pk, h)
if pair(result, mpk['Pub']) == pair(S, mpk['g']):
return True
return False
def prover_state1(self):
print("PROVER 1: ")
(g, V) = Sigma.get(self, ['g', 'V'])
r = self.group.random(G2)
a1 = pair(g, r)
a2 = pair(V, r)
print("send r =>", r)
print("send a1 =>", a1)
print("send a2 =>", a2)
pk = Sigma.get(self, ['g','V','H'], dict)
Sigma.store(self, ('r',r) )
Sigma.setState(self, 3)
return { 'a1':a1, 'a2':a2, 'pk':pk }
def prover_state1(self):
print("PROVER 1: ")
(g, V) = Sigma.get(self, ['g', 'V'])
r1, r2 = self.group.random(ZR, 2)
a = (pair(V, g) ** -r1) * (pair(g, g) ** r2)
print("send g =>", g)
print("send V =>", V)
print("send r1 =>", r1)
print("send r2 =>", r2)
print("send a =>", a)
pk = Sigma.get(self, ['g','V','y'], dict)
Sigma.store(self, ('r1',r1), ('r2',r2) )
Sigma.setState(self, 3)
return { 'a':a, 'pk':pk }
def transform(pk, sk, ct): input = [pk, sk, ct] policy_str, Ctl, C, Cr, Cpr, T1 = ct S, D, Dj, Djp = sk policy = createPolicy(policy_str) attrs = prune(policy, S) coeff = getCoefficients(policy) Y = len(attrs) lam_func1 = lambda a,b,c,d,e,f: (pair((b[a] ** -c[a]), d[a]) * pair((e[a] ** c[a]), f[a])) A = dotprod2(range(0, Y), lam_func1, attrs, Cr, coeff, Dj, Djp, Cpr) result0 = (pair(C, D) * A) T0 = Ctl T2 = result0 partCT = [T0, T1, T2] output = partCT return output
def run_Ind(verifyArgsDict, groupObjParam, verifyFuncArgs):
global group
global H, debug, H, H3
group = groupObjParam
N = len(verifyArgsDict)
z = 0
incorrectIndices = []
H3 = lambda a,b: group.hash(('3', str(a), str(b)), ZR)
H = lambda prefix,x: group.hash((str(prefix), str(x)), G1)
__init__(group)
for z in range(0, N):
for arg in verifyFuncArgs:
if (group.ismember(verifyArgsDict[z][arg][bodyKey]) == False):
sys.exit("ALERT: Group membership check failed!!!!\n")
pass
a= H( 1 , verifyArgsDict[z]['M'][bodyKey][ 't1' ] )
h= H( 2 , verifyArgsDict[z]['M'][bodyKey][ 't2' ] )
b= H3( verifyArgsDict[z]['M'][bodyKey][ 'str' ] , verifyArgsDict[z]['M'][bodyKey][ 't3' ] )
if pair( verifyArgsDict[z]['sig'][bodyKey] , verifyArgsDict[z]['mpk'][bodyKey][ 'g' ] )==( pair( a , verifyArgsDict[z]['pk'][bodyKey] ) *( pair( h , verifyArgsDict[z]['pk'][bodyKey] ) ** b ) ) :
pass
else:
if z not in incorrectIndices:
incorrectIndices.append(z)
return incorrectIndices
def setup(self, z, l=32):
alpha, h = group.random(ZR), group.random(G1)
g1, g2 = group.random(G1), group.random(G2)
A = pair(h, g2) ** alpha
y = [group.random(ZR) for i in range(z)]
y1t, y2t = group.random(ZR), group.random(ZR)
u1t = g1 ** y1t
u2t = g1 ** y2t
u = [g1 ** y[i] for i in range(z)]
u1b = g2 ** y1t
u2b = g2 ** y2t
ub = [g2 ** y[i] for i in range(z)]
msk = h ** alpha
mpk = {
"g1": g1,
"g2": g2,
"A": A,
"u1t": u1t,
"u2t": u2t,
"u": u,
"u1b": u1b,
"u2b": u2b,
"ub": ub,
"z": z,
"l": l,
}
return (mpk, msk)
def transform(pk, skBlinded, ct):
input = [pk, skBlinded, ct]
policy_str, Ctl, C, Cr, Cpr, T1 = ct
S, D, Dj, Djp = skBlinded
policy = createPolicy(policy_str)
attrs = prune(policy, S)
coeff = getCoefficients(policy)
Y = len(attrs)
lam_func1 = lambda a, b, c, d, e, f: (pair((b[a] ** -c[a]), d[a]) * pair((e[a] ** c[a]), f[a]))
A = dotprod2(range(0, Y), lam_func1, attrs, Cr, coeff, Dj, Djp, Cpr)
result0 = pair(C, D) * A
T0 = Ctl
T2 = result0
partCT = [T0, T1, T2]
output = partCT
return output
def sign(self, pk, sk, M):
if debug: print("sign...")
h, s = group.random(G1), group.random(ZR)
S1 = pair(h,pk['g2']) ** s
a = H2(M, S1)
S2 = (sk ** a) * (h ** s)
return {'S1':S1, 'S2':S2}
def verifier_state4(self, input):
(g, H, a, c, z) = Sigma.get(self, ['g','H','a','c','z'])
if a == (pair(g,z) * (H ** c)):
print("SUCCESS!!!!!!!"); result = 'OK'
else:
print("Failed!!!"); result = 'FAIL'
Sigma.setState(self, 6)
Sigma.setErrorCode(self, result)
return result
def decrypt(self, pk, sk, ct):
U, V, W = ct['U'], ct['V'], ct['W']
sig = V ^ h.hashToZn(pair(sk['id'], U))
dec_M = W ^ h.hashToZn(sig)
M = self.decodeFromZn(dec_M)
r = h.hashToZr(sig, M)
if(debug):
print('\nDecrypt....')
print('V =>', V)
print("V' =>", pair(sk['id'], U))
print('sig => %s' % sig)
print('r => %s' % r)
if U == r * pk['P']:
if debug: print("Successful Decryption!!!")
return M
if debug: print("Decryption Failed!!!")
return None
def PEKS(self, word):
g, h = self.pub
r = self.group.random(ZR)
print('PKS(A_pub,W): Public Key: %s' % h)
t = pair(self.group.hash(word, G2), h**r)
print('PKS(A_pub,W): MAP t: %s' % t)
return (g**r, t)
def setup(self):
s = 0
g1, a = group.random(G1), group.random(ZR)
g2 = group.random(G2)
A = g2 ** a
u, v, d = group.random(G1), group.random(G1), group.random(G1)
U = pair(u, A)
V = pair(v, A)
D = pair(d, A)
w, z, h = group.random(ZR), group.random(ZR), group.random(ZR)
w1, w2 = g1 ** w, g2 ** w
z1, z2 = g1 ** z, g2 ** z
h1, h2 = g1 ** h, g2 ** h
pk = {'U':U, 'V':V, 'D':D, 'g1':g1, 'g2':g2, 'A':A,
'w1':w1, 'w2':w2, 'z1':z1, 'z2':z2,
'h1':h1, 'h2':h2, 'u':u, 'v':v, 'd':d, 's':s }
sk = {'a':a }
return (pk, sk)
def transform(ct, sk):
input = [ct, sk]
id, D, K, tag_k = sk
C, E1, E2, tag_c, T1 = ct
tag = (1 / (tag_c - tag_k))
A1 = (pair(C[1], D[1]) * (pair(C[2], D[2]) *
(pair(C[3], D[3]) *
(pair(C[4], D[4]) * pair(C[5], D[5])))))
A2 = (pair(C[6], D[6]) * pair(C[7], D[7]))
A3 = (A1 / A2)
A4 = (pair((E1**tag), D[7]) * pair((E2**-tag), K))
T2 = (A3 / A4)
T0 = C[0]
partCT = [T0, T1, T2]
output = partCT
return output
def run_Ind(verifyArgsDict, groupObjParam, verifyFuncArgs):
global group
global debug, H1, H2, lam_func
group = groupObjParam
N = len(verifyArgsDict)
z = 0
l = len(verifyArgsDict[z]['L'][bodyKey])
incorrectIndices = []
lam_func = lambda i, a, b, c: a[i] * (b[i]**c[i]
) # => u * (pk ** h) for all signers
H1 = lambda x: group.hash(('1', str(x)), G1)
H2 = lambda a, b, c: group.hash(('2', a, b, c), ZR)
__init__(group)
for z in range(0, N):
for arg in verifyFuncArgs:
if (group.ismember(verifyArgsDict[z][arg][bodyKey]) == False):
sys.exit("ALERT: Group membership check failed!!!!\n")
pass
u, S = verifyArgsDict[z]['sig'][bodyKey]['u'], verifyArgsDict[z][
'sig'][bodyKey]['S']
Lt = concat(verifyArgsDict[z]['L'][bodyKey])
l = len(verifyArgsDict[z]['L'][bodyKey])
h = [group.init(ZR, 1) for i in range(l)]
for i in range(l):
pass
h[i] = H2(verifyArgsDict[z]['M'][bodyKey], Lt, u[i])
pk = [H1(i) for i in verifyArgsDict[z]['L'][bodyKey]
] # get all signers pub keys
result = dotprod(group.init(G1), -1, l, lam_func, u, pk, h)
if pair(result, verifyArgsDict[z]['mpk'][bodyKey]['Pub']) == pair(
S, verifyArgsDict[z]['mpk'][bodyKey]['g']):
pass
else:
if z not in incorrectIndices:
incorrectIndices.append(z)
return incorrectIndices
def decrypt(self, S, ct, sk):
C, D, K = ct, sk['D'], sk['K']
_ID = sk['ID']
# hash IDs
S_id = [group.hash(i.upper()) for i in S]
if debug: print("hashed IDs: ", S_id)
if _ID in S_id: print("Your ID:", _ID, "is in revoked list!"); return
A1 = pair(C[1], D[1]) * pair(C[2], D[2]) * pair(C[3], D[3]) * pair(C[4], D[4]) * pair(C[5], D[5])
A2 = pair(C[6], D[6]) * pair(C[7], D[7])
A3 = A1 / A2
A4 = 1
for i in range(len(S_id)):
A4 *= (pair(C['i1'][i], K) / pair(C['i2'][i], D[7])) ** (1 / (_ID - S_id[i]))
return C[0] / (A3 / A4)
def transform(ct, sk): input = [ct, sk] id, D, K, tag_k = sk C, E1, E2, tag_c, T1 = ct tag = (1 / (tag_c - tag_k)) A1 = (pair(C[1], D[1]) * (pair(C[2], D[2]) * (pair(C[3], D[3]) * (pair(C[4], D[4]) * pair(C[5], D[5]))))) A2 = (pair(C[6], D[6]) * pair(C[7], D[7])) A3 = (A1 / A2) A4 = (pair((E1 ** tag), D[7]) * pair((E2 ** -tag), K)) T2 = (A3 / A4) T0 = C[0] partCT = [T0, T1, T2] output = partCT return output
def setup():
global tau1b
global tau1
global ga2
global ga1
global gb
global gba1
global gba2
global tau2
global msk
global mpk
global v1
global v2
global egga
global alpha
global g
global h
global galpha_a1
global u
global w
global v
global tau2b
input = None
g = groupObj.random(G1)
w = groupObj.random(G1)
u = groupObj.random(G1)
h = groupObj.random(G1)
v = groupObj.random(G1)
v1 = groupObj.random(G1)
v2 = groupObj.random(G1)
a1 = groupObj.random(ZR)
a2 = groupObj.random(ZR)
b = groupObj.random(ZR)
alpha = groupObj.random(ZR)
gb = (g**b)
ga1 = (g**a1)
ga2 = (g**a2)
gba1 = (gb**a1)
gba2 = (gb**a2)
tau1 = (v * (v1**a1))
tau2 = (v * (v2**a2))
tau1b = (tau1**b)
tau2b = (tau2**b)
egga = (pair(g, g)**(alpha * (a1 * b)))
galpha = (g**alpha)
galpha_a1 = (galpha**a1)
mpk = [
g, gb, ga1, ga2, gba1, gba2, tau1, tau2, tau1b, tau2b, w, u, h, egga
]
msk = [galpha, galpha_a1, v, v1, v2, alpha]
output = (mpk, msk)
def setup(self, n):
g, w, h, v, v1, v2 = group.random(G1, 6)
a1, a2, b, alpha = group.random(ZR, 4)
tau1 = v * (v1 ** a1)
tau2 = v * (v2 ** a2)
pk = {'n':n, 'g':g, 'g^b':g ** b, 'g^a1':g ** a1, 'g^a2':g ** a2,
'g^ba1':g ** (b * a1), 'g^ba2':g ** (b * a2), 'tau1':tau1, 'tau2':tau2,
'tau1^b':tau1 ** b, 'tau2^b':tau2 ** b, 'w':w, 'h':h,
'egg_alpha': pair(g, g) ** (alpha * a1 * b)}
sk = {'g^alph':g ** alpha, 'g^alph_a1':g ** (alpha * a1),
'g^b':g ** b,'v':v, 'v1':v1, 'v2':v2, 'alpha':alpha }
return (pk, sk)
def setup(): global tau1b global tau1 global ga2 global ga1 global gb global gba1 global gba2 global tau2 global msk global mpk global v1 global v2 global egga global alpha global g global h global galpha_a1 global u global w global v global tau2b input = None g = groupObj.random(G1) w = groupObj.random(G1) u = groupObj.random(G1) h = groupObj.random(G1) v = groupObj.random(G1) v1 = groupObj.random(G1) v2 = groupObj.random(G1) a1 = groupObj.random(ZR) a2 = groupObj.random(ZR) b = groupObj.random(ZR) alpha = groupObj.random(ZR) gb = (g ** b) ga1 = (g ** a1) ga2 = (g ** a2) gba1 = (gb ** a1) gba2 = (gb ** a2) tau1 = (v * (v1 ** a1)) tau2 = (v * (v2 ** a2)) tau1b = (tau1 ** b) tau2b = (tau2 ** b) egga = (pair(g, g) ** (alpha * (a1 * b))) galpha = (g ** alpha) galpha_a1 = (galpha ** a1) mpk = [g, gb, ga1, ga2, gba1, gba2, tau1, tau2, tau1b, tau2b, w, u, h, egga] msk = [galpha, galpha_a1, v, v1, v2, alpha] output = (mpk, msk)
def run_Ind(verifyArgsDict, groupObjParam, verifyFuncArgs):
global group
global debug, H1, H2, lam_func
group = groupObjParam
N = len(verifyArgsDict)
z = 0
l= len( verifyArgsDict[z]['L'][bodyKey] )
incorrectIndices = []
lam_func = lambda i,a,b,c: a[i] * (b[i] ** c[i]) # => u * (pk ** h) for all signers
H1 = lambda x: group.hash(('1', str(x)), G1)
H2 = lambda a, b, c: group.hash(('2', a, b, c), ZR)
__init__(group)
for z in range(0, N):
for arg in verifyFuncArgs:
if (group.ismember(verifyArgsDict[z][arg][bodyKey]) == False):
sys.exit("ALERT: Group membership check failed!!!!\n")
pass
u , S= verifyArgsDict[z]['sig'][bodyKey][ 'u' ] , verifyArgsDict[z]['sig'][bodyKey][ 'S' ]
Lt= concat( verifyArgsDict[z]['L'][bodyKey] )
l= len( verifyArgsDict[z]['L'][bodyKey] )
h= [ group.init( ZR , 1 ) for i in range( l ) ]
for i in range( l ) :
pass
h [ i ]= H2( verifyArgsDict[z]['M'][bodyKey] , Lt , u [ i ] )
pk= [ H1( i ) for i in verifyArgsDict[z]['L'][bodyKey] ] # get all signers pub keys
result= dotprod( group.init( G1 ) , -1 , l , lam_func , u , pk , h )
if pair( result , verifyArgsDict[z]['mpk'][bodyKey][ 'Pub' ] )== pair( S , verifyArgsDict[z]['mpk'][bodyKey][ 'g' ] ) :
pass
else:
if z not in incorrectIndices:
incorrectIndices.append(z)
return incorrectIndices
def setup(): global g global h input = None g = groupObj.random(G1) g2 = groupObj.random(G2) alpha = groupObj.random(ZR) beta = groupObj.random(ZR) h = (g ** beta) f = (g ** (1 / beta)) i = (g2 ** alpha) egg = (pair(g, g2) ** alpha) mk = [beta, i] pk = [g, g2, h, f, egg] output = (mk, pk) return output
def setup(self, n=5, l=32):
"""n integers with each size l"""
global lam_func
lam_func = lambda i,x,y: x[i] ** y[i]
alpha, t1, t2, t3, t4 = group.random(ZR, 5)
z = list(group.random(ZR, n))
g = group.random(G1)
h = group.random(G2)
omega = pair(g, h) ** (t1 * t2 * alpha)
g_l = [g ** i for i in z]
h_l = [h ** i for i in z]
v1, v2 = g ** t1, g ** t2
v3, v4 = g ** t3, g ** t4
msk = { 'alpha':alpha, 't1':t1, 't2':t2, 't3':t3, 't4':t4 }
mpk = { 'omega':omega, 'g':g, 'h':h, 'g_l':g_l, 'h_l':h_l,
'v1':v1, 'v2':v2, 'v3':v3, 'v4':v4, 'n':n, 'l':l }
return (mpk, msk)
def transform(ct):
input = [pk, skBlinded, ct]
policy_str, Ctl, C, Cr, Cpr, T1 = ct
S, D, Dj, Djp = skBlinded
policy = createPolicy(policy_str)
attrs = prune(policy, S)
coeff = getCoefficients(policy)
Y = len(attrs)
A = dotprod2(range(0,Y), transformLambdaFunc, attrs, Cr, coeff, Dj, Djp, Cpr)
print(" A := ", A)
result0 = (pair(C, D) * A)
T0 = Ctl
T2 = result0
print("T2 :=>", result0)
partCT = {'T0':T0, 'T1':T1, 'T2':T2}
output = partCT
return output
def setup():
global g
global h
input = None
g = groupObj.random(G1)
g2 = groupObj.random(G2)
alpha = groupObj.random(ZR)
beta = groupObj.random(ZR)
h = g ** beta
f = g ** (1 / beta)
i = g2 ** alpha
egg = pair(g, g2) ** alpha
mk = [beta, i]
pk = [g, g2, h, f, egg]
output = (mk, pk)
return output
def transform(ct):
input = [pk, skBlinded, ct]
policy_str, Ctl, C, Cr, Cpr, T1 = ct
S, D, Dj, Djp = skBlinded
policy = createPolicy(policy_str)
attrs = prune(policy, S)
coeff = getCoefficients(policy)
Y = len(attrs)
A = dotprod2(range(0, Y), transformLambdaFunc, attrs, Cr, coeff, Dj, Djp,
Cpr)
print(" A := ", A)
result0 = (pair(C, D) * A)
T0 = Ctl
T2 = result0
print("T2 :=>", result0)
partCT = {'T0': T0, 'T1': T1, 'T2': T2}
output = partCT
return output
def transformLambdaFunc(y, attrs, Cr, coeff, Dj, Djp, Cpr):
lambdaIndex = GetString(attrs[y])
firstTerm = (Cr[lambdaIndex]**(-coeff[lambdaIndex]))
secondTerm = (Djp[lambdaIndex]**coeff[lambdaIndex])
return pair(firstTerm, Dj[lambdaIndex]) * pair(secondTerm,
Cpr[lambdaIndex])
def lam_func1(y, attrs, Cr, coeff, Dj, Djp, Cpr):
getUserGlobals()
y = GetString(attrs[y])
return (pair((Cr[y]**-coeff[y]), Dj[y]) * pair((Djp[y]**coeff[y]), Cpr[y]))
def Test(self, s, tw):
a, b = s
print(self.h1.hashToZn(str(pair(tw, a))))
print(b)
return self.h1.hashToZn(str(pair(tw, a))) == self.h1.hashToZn(str(b))
