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