Esempio n. 1
0
def prng_bits(group, bits=80):
    bID4 = InitBenchmark()
    StartBenchmark(bID4, [RealTime])
    for i in range(trials):
        a = randomBits(bits)
    EndBenchmark(bID4)
    result = (GetBenchmark(bID4, RealTime) / trials) * time_in_ms
    return result
Esempio n. 2
0
 def random(self, type=ZR, seed=None):
     if type == GT: return self.__randomGT()
     elif type == ZR or type == G1 or type == G2:
         if seed != None:
             return self.Pairing.random(type, seed)
         return self.Pairing.random(type)
     else:
         return integer(randomBits(self.secparam))
Esempio n. 3
0
    def S(self, pub):
        x = randomBits(448)
        x = str(x).zfill(135) 

        r = hashlib.md5(x.encode('utf-8')).digest()

        com = hashlib.sha1(x.encode('utf-8')).digest()[:128]

        dec = x

        return (r, com, dec)
Esempio n. 4
0
 def random(self, type=ZR, count=1, seed=None):
     if type == GT:
         return self.__randomGT()
     elif type == ZR or type == G1 or type == G2:
         if seed != None and count == 1:
             return random(self.Pairing, type, seed)
         elif count > 1:
             return tuple([random(self.Pairing, type) for i in range(count)])
         return random(self.Pairing, type)
     else:
         return integer(randomBits(self.secparam))
Esempio n. 5
0
 def getRandomBits(self, length):
     i = randomBits(length)
     len = math.ceil(length / 8)
     return Conversion.IP2OS(i, len)
Esempio n. 6
0
 def getRandomBytes(self, length):
     bits = length * 8
     val = randomBits(bits)
     return Conversion.IP2OS(val, length)
Esempio n. 7
0
def runCDH_batch(dict, group):
	N = len(dict)

	delta = {}

	for sigIndex in range(0, N):
		delta[sigIndex] = group.init(ZR, randomBits(80))

	sumB = group.init(ZR, 0)
	sumD = group.init(ZR, 0)
	sumC = group.init(ZR, 0)
	dotA = group.init(G1, 1)
	dotG = group.init(G1, 1)
	dotE = group.init(G1, 1)
	dotF = group.init(G1, 1)

	for i in range(0, N):
		for arg in verifyFuncArgs:
			if (group.ismember(dict[i][arg]) == False):
				sys.exit("group membership failed")

	for i in range(0, N):
		M = dict[i][M_index]
		M = group.hash(M, ZR)

		r = dict[i][sig_index]['r']
		sig1 = dict[i][sig_index][1]
		sig2 = dict[i][sig_index][2]
		sig_i = dict[i][sig_index]['i']

		sumD = sumD + delta[i]
		sumB = sumB + (M * delta[i])
		sumC = sumC + (r * delta[i])
		dotA = dotA * (sig1 ** delta[i])
		dotG = dotG * (sig2 ** delta[i])
		n = group.init(ZR, ceil(log(sig_i, 2)))

		dotE = dotE * (sig2 ** (n * delta[i] ) )
		dotF = dotF * (sig2 ** (sig_i * delta[i] ) )

	U = dict[0][pk_index]['U']
	V = dict[0][pk_index]['V']
	D = dict[0][pk_index]['D']
	g2 = dict[0][pk_index]['g2']
	z2 = dict[0][pk_index]['z2']
	w2 = dict[0][pk_index]['w2']
	h2 = dict[0][pk_index]['h2']

	leftSide = pair(dotA, g2)
	rightSidePair1 = pair(dotE, w2)
	rightSidePair2 = pair(dotF, z2)
	rightSidePair3 = pair(dotG, h2)
	rightSidePairings = rightSidePair1 * rightSidePair2 * rightSidePair3

	U_right = U ** sumB
	V_right = V ** sumC
	D_right = D ** sumD

	rightSide = (U_right * (V_right * (D_right * (rightSidePairings))))

	if (leftSide == rightSide):
		return
	sys.exit("WTF IS HAPPENING????????")
Esempio n. 8
0
 def getRandomBits(self, length):
     i = randomBits(length)
     len = math.ceil(length / 8)
     return Conversion.IP2OS(i, len)
Esempio n. 9
0
 def getRandomBytes(self, length):
     bits = length * 8;
     val = randomBits(bits)
     return Conversion.IP2OS(val, length)