def encrypt(self,m,r1=None,r2=None, r3=None):
''' Outputs a PPATCCiphertext on m using r1,r2 as the randomness for the
commitment and r1,r2,r3 as the randomness for the encryption
'''
# notations
q = self.PPATCpp.order
g = self.PPATCpp.g
ECG = g.ECG # EFp2
Jcoord = self.PPATCpp.Jcoord
if r1 == None:
r1 = randint(1,int(q))
if r2 == None:
r2 = randint(1,int(q))
if r3 == None:
r3 = randint(1,int(q))
# commitment
d = self.commit(m,r1,r2)
# encryption
c1t = oEC.mul_comb2_EFp2(ECG,r2,self.precomp_g,Jcoord)
c1 = oEC.toEFp2(ECG,c1t,Jcoord)
#c1 = r2*g
c2t = oEC.mul_comb2_EFp2(ECG,r3,self.precomp_g,Jcoord)
c2 = oEC.toEFp2(ECG,c2t,Jcoord)
#c2 = r3*g
c31t = oEC.mul_comb2_EFp2(ECG,r1,self.precomp_g1,Jcoord)
c32t = oEC.mul_comb2_EFp2(ECG,r3,self.precomp_g2,Jcoord)
c3t = oEC.addEFp2(ECG,c31t,c32t,Jcoord)
c3 = oEC.toEFp2(ECG,c3t,Jcoord)
#c3 = (r1*g1)+(r3*g2)
return PPATCCiphertext(d,c1,c2,c3,self)
def test_SPEKE():
password = "******"
p = getStrongPrime(768)
h = hashlib.sha1()
#https://build.opensuse.org/package/view_file?file=pycrypto-2.6-elgamal.patch&package=python-crypto.openSUSE_11.4_Update&project=openSUSE%3AMaintenance%3A564&rev=1fe551f41425aa7d6cb7bca6de778168
h.update(password)
print("hash(%s)=%s=%s" % (password, h.hexdigest(), bytes_to_long(h.digest())))
sq = bytes_to_long(h.digest())**2
print("hash^2=%s" % sq)
g = sq % p
print("g=%s" % g)
ga = 0
#choose values sufficiently large, but not too large
#as this would slow down calculations too much!
MIN_I = 2**12
MAX_I = 2**13
while ga<=2 or ga>=p-2:
a = random.randint(MIN_I, MAX_I)
print("a=%s" % a)
ga = (g**a) % p
print("(g**a)%%p=%s" % ga)
gb = 0
while gb<=2 or gb>=p-2:
b = random.randint(MIN_I, MAX_I)
print("b=%s" % b)
gb = (g**b) % p
print("(g**b)%%p=%s" % gb)
ak = (gb**a) % p
print("aK=%s" % ak)
bk = (ga**b) % p
print("bK=%s" % bk)
assert ak==bk
def commit(self,m,r1=None,r2=None):
q = self.PPATCpp.order
if r1 == None:
r1 = randint(1,int(q))
if r2 == None:
r2 = randint(1,int(q))
# notations
Jcoord = self.PPATCpp.Jcoord
ECG1 = self.h1.ECG
ECG2 = self.g1.ECG
# commitment
d11t = oEC.mul_comb2_EFp(ECG1,r1,self.precomp_h,Jcoord)
d12t = oEC.mul_comb2_EFp(ECG1,r2,self.precomp_h1,Jcoord)
d1t = oEC.addEFp(ECG1,d11t,d12t,Jcoord)
d1 = oEC.toEFp(ECG1,d1t,Jcoord)
#d1 = (r1*h)+(r2*h1)
mp = self.encode(m)
d21t = oEC.mul_comb2_EFp2(ECG2,r2,self.precomp_g1,Jcoord)
d2t = oEC.addEFp2(ECG2,mp,d21t,Jcoord)
d2 = oEC.toEFp2(ECG2,d2t,Jcoord)
#d2 = mp + r2*g1
return PPATCCommitment(d1,d2,self)
def generate_request(**request_parameters):
'''Generate a token provisioning request.'''
default_model = 'MacBookPro%d,%d' % (random.randint(1, 12), random.randint(1, 4))
default_request_parameters = {
'timestamp':int(time.time()),
'token_model':'VSST',
'otp_algorithm':'HMAC-SHA1-TRUNC-6DIGITS',
'shared_secret_delivery_method':'HTTPS',
'manufacturer':'Apple Inc.',
'serial':''.join(random.choice(string.digits + string.ascii_uppercase) for x in range(12)),
'model':default_model,
'app_handle':'iMac010200',
'client_id_type':'BOARDID',
'client_id':'Mac-' + ''.join(random.choice('0123456789ABCDEF') for x in range(16)),
'dist_channel':'Symantec',
'platform':'iMac',
'os':default_model,
}
default_request_parameters.update(request_parameters)
request_parameters = default_request_parameters
data_before_hmac = u'%(timestamp)d%(timestamp)d%(client_id_type)s%(client_id)s%(dist_channel)s' % request_parameters
request_parameters['data'] = base64.b64encode(
hmac.new(
HMAC_KEY,
data_before_hmac.encode('utf-8'),
hashlib.sha256
).digest()
).decode('utf-8')
return REQUEST_TEMPLATE % request_parameters
def encrypt(self,m,r=None,s=None):
''' Outputs a PPATSCiphertext on m using r as the randomness for the
commitment and s as the randomness for the encryption
'''
#limit = 2**self.maxexp
#assert m < limit
#assert m >= 0
order = self.PPATSpp.order
if r == None:
r = randint(1,int(order))
if s == None:
s = randint(1,int(order))
# notations
g1 = self.g1
ECG = g1.ECG
Jcoord = self.PPATSpp.Jcoord
# commitment part
d,r = self.commit(m,r)
#d = (r*h)+(m*h1)
# encryption part
c1t = oEC.mul_comb2_EFp2(ECG,s,self.precomp_g,Jcoord)
c1 = oEC.toEFp2(ECG,c1t,Jcoord)
#c1 = s*g
rgt = oEC.mul_comb2_EFp2(ECG,r,self.precomp_g,Jcoord)
sg1t = oEC.mul_comb2_EFp2(ECG,s,self.precomp_g1,Jcoord)
c2t = oEC.addEFp2(ECG,rgt,sg1t,Jcoord)
c2 = oEC.toEFp2(ECG,c2t,Jcoord)
#c2 = (r*g)+(s*g1)
return PPATSCiphertext(d,c1,c2,self)
def generate_key_info():
"""
This method generates the key-information for RSA encryption and decryption
:return: RSA-key info
"""
p = int(random.randint(1000, 5000))
q = int(random.randint(1000, 5000))
d = -1
while not primetest(p):
p = int(random.randint(1000, 5000))
while not primetest(q):
q = int(random.randint(1000, 5000))
n = p * q
Yn = (p - 1) * (q - 1)
e = 0
while d < 0:
e = int(random.randint(2, Yn - 1)) # Create a random integer that is between 1<e<Y(n) #test 73
d = eea(Yn, e)[0] # eea only returns a negative integer if GCD (Y(n),e) is not 1
return n, e, d, p, q, Yn
def init():
# place the victim's cache lines
victim_counter = phy_assoc*num_sets/2
tag_range = int(math.pow(2,tag_width) - 1)
while victim_counter > 0:
victim_addr = random.randint(0, tag_range)
victim_way = random.randint(0, phy_assoc-1)
victim_set = pick_set(victim_way, victim_addr)
if cache_tag[victim_set][victim_way][0] != -1:
continue
else:
cache_tag[victim_set][victim_way] = [victim_addr, 0]
victim_counter = victim_counter - 1
# place the victim's cache lines
attacker_counter = phy_assoc*num_sets/2
tag_range = int(math.pow(2,tag_width) - 1)
while attacker_counter > 0:
attacker_addr = random.randint(0, tag_range)
attacker_way = random.randint(0, phy_assoc-1)
attacker_set = pick_set(attacker_way, attacker_addr)
if cache_tag[attacker_set][attacker_way][0] != -1:
continue
else:
cache_tag[attacker_set][attacker_way] = [attacker_addr, 1]
attacker_counter = attacker_counter - 1
print "finish initialization"
def verifiabilityProof2(ppatspk, d, m, r, b=None, u=None, t=None):
""" This ZK proof ensures that d = r*h+m*h1 is a commitment on m = 0 or 1
b,u,t are the randomness used in the proof (optional)
"""
# notations
order = ppatspk.PPATSpp.order
h = ppatspk.PPATSpp.h
h1 = ppatspk.h1
ECG = h.ECG
Jcoord = ppatspk.PPATSpp.Jcoord
# ht = oEC.toTupleEFp(ECG,h,Jcoord)
nh1t = oEC.toTupleEFp(ECG, -h1, Jcoord)
ddt = oEC.toTupleEFp(ECG, d.d, Jcoord)
# assert h*r+h1*m == d.d # commitment is well formed
assert m == 0 or m == 1 # the proof works only if m = 0 or 1
if b == None:
b = randint(1, int(order))
if u == None:
u = randint(1, int(order))
if t == None:
t = randint(1, int(order))
hbt = oEC.mul_comb2_EFp(ECG, b, ppatspk.precomp_h, Jcoord)
hb = oEC.toEFp(ECG, hbt, Jcoord)
if m == 0:
u1 = u
t1 = t
# commitment
# w0 = PPATSCommitment(h*b,self)
w0 = ppat.ppats.PPATSCommitment(hb, ppatspk)
hu1t = oEC.mul_comb2_EFp(ECG, u1, ppatspk.precomp_h, Jcoord)
s1 = oEC.addEFp(ECG, ddt, nh1t, Jcoord)
s1t1 = oEC.mulECP(ECG, s1, -t1, False, Jcoord)
w1t = oEC.addEFp(ECG, hu1t, s1t1, Jcoord)
w1v = oEC.toEFp(ECG, w1t, Jcoord)
w1 = ppat.ppats.PPATSCommitment(w1v, ppatspk)
# challenge
t0 = ppatspk.hashf([ppatspk.PPATSpp, ppatspk, d, w0, w1]) - t1
# response
u0 = b + r * t0
if m == 1:
u0 = u
t0 = t
# commitment
hu0t = oEC.mul_comb2_EFp(ECG, u0, ppatspk.precomp_h, Jcoord)
ddt0 = oEC.mulECP(ECG, ddt, -t0, False, Jcoord)
w0t = oEC.addEFp(ECG, hu0t, ddt0, Jcoord)
w0v = oEC.toEFp(ECG, w0t, Jcoord)
w0 = ppat.ppats.PPATSCommitment(w0v, ppatspk)
w1 = ppat.ppats.PPATSCommitment(hb, ppatspk)
# challenge
t1 = ppatspk.hashf([ppatspk.PPATSpp, ppatspk, d, w0, w1]) - t0
# response
u1 = b + r * t1
return [u0, u1, t0, t1]
"""
def test_geq_proof_on_commitment(self):
m1 = randint(1,self.maxmessage)
m2 = randint(1,m1)
com1, r1 = self.ppatspk.commit(m1)
com2, r2 = self.ppatspk.commit(m2)
gproof = nizk.geqProof(self.ppatspk,com1,m1,r1,com2,m2,r2,self.maxexp)
res = nizk.geqProofCheck(self.ppatspk,com1,com2,gproof,self.maxexp)
self.assertTrue(res)
def test_multiplication_of_cipher_by_scalar(self):
m1 = randint(1,2**(self.maxexp-10)) # So the multiplication of the cipher can be decrytpted
cipher1 = self.ppatspk.encrypt(m1)
a = randint(1,1000)
cipher2 = self.ppatspk.encrypt(a*m1)
d1 = self.ppatssk.decrypt(cipher1)
d2 = self.ppatssk.decrypt(cipher2)
self.assertTrue(a*d1==d2)
def rand_padding(s):
pre_padlen = random.randint(5, 10)
post_padlen = random.randint(5, 10)
prefix = random.getrandbits(8 * pre_padlen).to_bytes(pre_padlen, 'big')
postfix = random.getrandbits(8 * post_padlen).to_bytes(post_padlen, 'big')
return prefix + s + postfix
def test_multiplication_of_commitment_by_a_scalar(self):
m1 = randint(1,self.maxmessage)
r1 = randint(1,self.n-1)
d1,r1 = self.ppatspk.commit(m1,r1)
a = randint(1,1000)
d2 = a*d1
d2p,r2 = self.ppatspk.commit(a*m1,a*r1)
self.assertTrue(d2==d2p)
def generate_and_encode_password(self, size=10):
N = [random.randint(0,4294967295) for i in range(size)]
P = [s[N[i]%len(s)] for i, s in enumerate(self.must_set)]
P.extend(self.All[n%len(self.All)] for n in N[len(self.must_set):])
n = random.randint(0, fact_map[size-1])
password = decode2string(n, P)
N.append(n)
return password, N
def test_addition_of_commitments(self):
m1 = randint(1,self.maxmessage)
r1 = randint(1,self.n-1)
d1,r1 = self.ppatspk.commit(m1,r1)
m2 = randint(1,self.maxmessage)
r2 = randint(1,self.n-1)
d2,r2 = self.ppatspk.commit(m2,r2)
d3 = d1+d2
d3p,r3 = self.ppatspk.commit(m1+m2,r1+r2)
self.assertTrue(d3==d3p)
def challenge22():
cur_time = int(time.time()) + random.randint(40, 1000)
m = Mersenne(cur_time)
cur_time += random.randint(40, 1000)
num = m.extract_number()
for i in range(int(time.time()) - 4000, int(time.time()) + 4000):
m = Mersenne(i)
if m.extract_number() == num:
print("Seed: {0}".format(i))
return
def test_addition_of_ciphers(self):
m1 = randint(1,2**(self.maxexp-1)) # So the addition of the two can be decrytpted
cipher1 = self.ppatspk.encrypt(m1)
m2 = randint(1,2**(self.maxexp-1))
cipher2 = self.ppatspk.encrypt(m2)
cipher3 = self.ppatspk.encrypt(m1+m2)
d1 = self.ppatssk.decrypt(cipher1)
d2 = self.ppatssk.decrypt(cipher2)
d3 = self.ppatssk.decrypt(cipher3)
self.assertTrue(d1+d2==d3)
def test_multiplication_of_commtiments_by_triplet(self):
#q = self.ppatspp.q
m1 = randint(1,self.maxmessage)
r1 = randint(1,self.n-1)
a1,r1 = self.ppatspk.commit(m1,r1)
m2 = randint(1,self.maxmessage)
r2 = randint(1,self.n-1)
a2,r2 = self.ppatspk.commit(m2,r2)
r3 = randint(1,self.n-1)
a3,r3 = self.ppatspk.commit(m1*m2,r3)
proof = nizk.multiplicationProof(self.ppatspk,a1,a2,a3,m1,m2,r1,r2,r3)
m1p = randint(1,self.maxmessage)
r1p = randint(1,self.n-1)
d1,r1p = self.ppatspk.commit(m1p,r1p)
m2p = randint(1,self.maxmessage)
r2p = randint(1,self.n-1)
d2,r2p = self.ppatspk.commit(m2p,r2p)
g = self.ppatspp.g
o1 = (r1p-r1)*g
o2 = (r2p-r2)*g
openings = (m1p-m1,o1),(m2p-m2,o2)
d3 = nizk.multiplicationWithTripletAndCheck(self.ppatspk,d1,d2,a1,a2,a3,proof,openings)
o3 = (r3+m2p*r1-m2*r1+m1p*r2-m1*r2)*g
self.assertTrue(self.ppatspk.verifyOpening(d3,m1p*m2p,o3))
def test_multiplication_of_commitment_proof_and_check(self):
m1 = randint(1,self.maxmessage)
r1 = randint(1,self.n-1)
d1,r1 = self.ppatspk.commit(m1,r1)
m2 = randint(1,self.maxmessage)
r2 = randint(1,self.n-1)
d2,r2 = self.ppatspk.commit(m2,r2)
r3 = randint(1,100)
d3,r3 = self.ppatspk.commit(m1*m2,r3)
proof = nizk.multiplicationProof(self.ppatspk,d1,d2,d3,m1,m2,r1,r2,r3)
self.assertTrue(nizk.multiplicationProofCheck(self.ppatspk,d1,d2,d3,proof))
def test_split_into_chunks():
for _ in xrange(1000):
whole_size = rand.randint(100, 10000)
chunk_size = rand.randint(1, 100)
random_string = random.read(whole_size)
chunks = split_into_chunks(random_string, chunk_size)
for c in chunks:
if c == chunks[-1]:
assert(len(c) <= chunk_size)
else:
assert(len(c) == chunk_size)
def generate_and_encode_password(self, size=10):
N = [random.randint(0, MAX_INT) for i in range(size+1)]
N[0] += (size - N[0] % self.MAX_ALLOWED)
P = [s[N[i+1]%len(s)] for i,s in enumerate(self.must_set)]
P.extend(self.All[n%len(self.All)] for n in N[len(self.must_set)+1:])
n = random.randint(0, MAX_INT)
password = self.decode2string(n, P)
N.append(n)
extra = hny_config.PASSWORD_LENGTH - len(N);
N.extend([convert2group(0,1) for x in range(extra)])
return password, N
def keygen(k,x=-1,p=-1,q=-1):
if (p,q)==(-1,-1):
(p,q)=getSafePrimes(k)
g=randint(2,p-2)
g=powmod(g,2,p)
if (x==-1):
x=randint(2,q-1)
y=powmod(g,x,p)
common=(g,p,q)
pk=(common,y)
sk=(common,x)
return (pk,sk)
def encryptwithCproof(self,m,r1=None,r2=None,r3=None,s=None,s1=None,s2=None,s3=None):
q = self.PPATCpp.order
if r1 == None:
r1 = randint(1,int(q))
if r2 == None:
r2 = randint(1,int(q))
if r3 == None:
r3 = randint(1,int(q))
c = self.encrypt(m,r1,r2,r3)
cproof = nizkproofs.nizkpok.consistencyProof_ppatc(self,c,m,r1,r2,r3,s,s1,s2,s3)
return c,cproof
def encryption_oracle(s):
key = util.randbytes(16)
cipher = AES.new(key, AES.MODE_ECB)
if random.randint(0, 1) == 0:
print('Encrypting with ECB')
else:
print('Encrypting with CBC')
IV = util.randbytes(16)
cipher = challenge10.CBC(cipher, IV)
s = util.randbytes(random.randint(5, 10)) + s + util.randbytes(random.randint(5, 10))
s = util.padPKCS7(s, 16)
return cipher.encrypt(s)
def encryption_oracle(s):
cipher = AES.new(get_rnd_bytes(AES.block_size), AES.MODE_ECB)
s = get_rnd_bytes(random.randint(5, 10)) + s + get_rnd_bytes(random.randint(5, 10))
if random.randint(0, 1) == 1:
print("Encryption Oracle: ECB.")
else:
print("Encryption Oracle: CBC.")
iv = get_rnd_bytes(AES.block_size)
cipher = c10.CBC(cipher, iv, AES.block_size)
return cipher.encrypt(s)
def encryption_oracle(input): padded_input = Random.new().read(randint(5,10)) + input + Random.new().read(randint(5,10)) size = len(padded_input) padded_input = pad16(padded_input) #print len(padded_input) #print padded_input if randint(0,1): print "ECB used" return encrypt_ECB(padded_input, generate_AESKey(), "") else: print "ECB-CBC used" return encrypt_CBC(encrypt_ECB, padded_input, generate_AESKey(), Random.new().read(AES.block_size), 16)
def consistencyProof_ppatc(ppatcpk,c,m,r1,r2,r3,s=None,s1=None,s2=None,s3=None):
''' This proof ensures that the commitment part of the ciphertext is
commiting on the same message that is encrypted in the encryption part
The proof is a proof of equality between discrete logarithms
'''
# notations
'''
h = ppatcpk.PPATCpp.h
ECG1 = h.ECG
h1 = ppatcpk.h1
g = ppatcpk.PPATCpp.g
ECG2 = g.ECG
Jcoord = ppatcpk.PPATCpp.Jcoord
g1 = ppatcpk.g1
g2 = ppatcpk.g2
'''
q = ppatcpk.PPATCpp.order
if s1 == None:
s1 = randint(1,int(q))
if s2 == None:
s2 = randint(1,int(q))
if s3 == None:
s3 = randint(1,int(q))
if s == None:
s = randint(1,int(q))
'''
ms = ppatcpk.encode(s) # ms is a random element of G1
c1pt = oEC.mul_comb2_EFp2(ECG2,s2,ppatcpk.precomp_g,Jcoord)
c1p = oEC.toEFp2(ECG2,c1pt,Jcoord)
c1p = s2*g
c2p = s3*g
c3p = s1*g1 + s3*g2
d1p = s1*h + s2*h1
d2p = ms + s2*g1
dp = ppat.ppatc.PPATCCommitment(d1p,d2p,ppatcpk)
cp = ppat.ppatc.PPATCCiphertext(dp,c1p,c2p,c3p,ppatcpk)
'''
cp = ppatcpk.encrypt(s,s1,s2,s3)
nu = ppatcpk.hashf([ppatcpk.PPATCpp,ppatcpk,c,cp])
f1 = (s1 + nu*r1)%q
f2 = (s2 + nu*r2)%q
f3 = (s3 + nu*r3)%q
#fm = (mp + nu*m) %q
fm = (s + nu*m) %q
return [nu,f1,f2,f3,fm]
def gen_password_old(length = 10, num_punc = 1, sequence = None): """ Generate a random password, where: :var length length of password, default 10 :var num_punc minimum number of punctuation characters in pass :var sequence the sequence to generate from. vary to increase or decrease frequency of each """ sequence = ['LOWERCASE', 'LOWERCASE', 'LOWERCASE', 'LOWERCASE', 'LOWERCASE', 'LOWERCASE', 'UPPERCASE', 'VOWELS', 'NUMBERS', 'PUNC'] seq = [sequence[randint(0, len(sequence) - 1)] for i in range(0, 100)] # print sequence[random.randint(0, len(sequence) - 1)].upper() # seq = [LOWERCASE for i in range(0, 10)] # print locals() return "".join([globals()[i][randint(0, len(globals()[i]) - 1)] for i in seq])[0:length]
def set(self, message, extra, views, compress = True):
extra = extra or ''
views = views or self._views
if (views < 1):
views = 1
msglen = len(message)
if self._debug:
print('message: ' + message)
print('messagelen: ' + str(msglen))
print('extra: ' + str(extra))
print('views: ' + str(views))
if compress and (msglen > self._mincompsize):
message = '\x01' + self._deflate(message)
if self._debug:
print('compressed: ' + str(len(message)))
else:
message = '\x00' + message
while True:
uid = uuid.uuid4().bytes
if not self._cache.has(uid):
break
if self._debug:
print('uid: ' + uid.encode('hex'))
msgidx = random.randint(0, self._keycount - 1)
msgiv = Random.new().read(AES.block_size)
if self._debug:
print('msgidx: ' + str(msgidx))
print('msgiv: ' + msgiv.encode('hex'))
msgcipher = AES.new(self._msgkey[msgidx]['key'], AES.MODE_CFB, msgiv)
self._msgkey[msgidx]['count'] += 1
salt = Random.new().read(SHA256.digest_size)
cryptmsg = self._intpack(msgidx, self._kcsize) + msgiv + msgcipher.encrypt(salt) + msgcipher.encrypt(HMAC.new(salt, message, SHA256).digest()) + msgcipher.encrypt(message)
if self._cache.set(uid, (HMAC.new(extra, cryptmsg, SHA256).digest() + cryptmsg, views)):
cryptiv = Random.new().read(AES.block_size)
cryptidx = random.randint(0, self._keycount - 1)
if self._debug:
print('cryptidx: ' + str(cryptidx))
print('cryptiv: ' + cryptiv.encode('hex'))
cryptcipher = AES.new(self._cryptkey[cryptidx]['key'], AES.MODE_CFB, cryptiv)
self._cryptkey[cryptidx]['count'] += 1
return (base64.urlsafe_b64encode(self._instanceid + self._intpack(cryptidx, self._kcsize) + cryptiv + cryptcipher.encrypt(uid)).rstrip('='), None)
else:
return (None, self.ERROR_CACHE_NOTSET)
def is_case_insensitive_path(root_path, return_file = False):
if _IS_WIN:
tmp_file = '~%dHI.tmp' % (random.randint(0, sys.maxint),)
else:
tmp_file = '.~%dHI' % (random.randint(0, sys.maxint),)
orig_path = os.path.join(root_path, tmp_file)
open(orig_path, 'w').close()
try:
does_exist = os.path.exists(os.path.join(root_path, tmp_file.lower()))
if return_file:
return (does_exist, orig_path)
return does_exist
finally:
os.unlink(orig_path)
def encryptwithCproof(self,m,r=None,s=None,mp=None,rp=None,sp=None):
''' Outputs a PPATSCiphertext and a consistency on m using r as the randomness for the
commitment and s as the randomness for the encryption
If provided, mp,rp,sp are used for the proof of consistency
'''
order = self.PPATSpp.order
if r == None:
r = randint(1,int(order))
if s == None:
s = randint(1,int(order))
c = self.encrypt(m,r,s)
cproof = nizkproofs.nizkpok.consitencyProof(self,c,m,r,s,mp,rp,sp)
return c,cproof
def test_encrypt_with_consistency_check_proof(self):
m1 = randint(1, self.n - 1)
#m1 = m1i*P
c, cproof = self.ppatcpk.encryptwithCproof(m1)
self.assertTrue(
nizk.consistencyProofCheck_ppatc(self.ppatcpk, c, cproof))
def profile_for(email):
email = email.replace("&", "")
email = email.replace("=", "")
return encrypt_encoded_user_cookie(
User(email, random.randint(10, 99), "user"))
from Crypto.Random import random
print('random.randint: ', random.randint(10, 20))
print('random.randrange: ', random.randrange(10, 20, 2))
print('random.randint: ', random.getrandbits(3))
print('random.choice: ', random.choice([1, 2, 3, 4, 5]))
print('random.sample: ', random.sample([1, 2, 3, 4, 5], 3))
list = [1, 2, 3, 4, 5]
random.shuffle(list)
print('random.shuffle: ', list)
def fillupTree(self, blockList):
'''
This method randomly assign blocks to the tree nodes and pad with dummy
blocks
We assume here that the tree is empty
'''
#Z = self.POTree.Z
blockL = []
k = len(blockList)
t = self.POTree.tLoad
r1 = t - k # the number of dummyblocks to create
t1 = time.time()
for blockID, block in blockList:
blockL.append((blockID, block))
t2 = time.time()
for i in range(r1):
blockL.append(('DB' + str(i), None))
t3 = time.time()
#print k,t,r1, len(blockDic)
assert len(
blockL
) == t # we now have exactly enough blocks to fill up the tree
new_blockList = []
tm1, tm2 = 0, 0
#kBD = blockDic.keys()
for i in range(t):
t31 = time.time()
lBD = len(blockL)
r2 = randint(0, lBD - 1)
randomBlockID, randomBlock = blockL.pop(r2)
#randomBlock = blockDic.pop(randomBlockID)
new_blockList.append((i, randomBlock))
t32 = time.time()
subpath = positionToSubPath(i, self.POTree.nbChildren,
self.POTree.Z, self.POTree.depth,
self.sPD)
"""
possiblePathsList = possiblePaths(subpath,self.POTree.nbChildren,self.POTree.depth+1)
l = len(possiblePathsList)
r2 = randint(0,l-1)
path = possiblePathsList[r2]
"""
path = randomPath(subpath, self.POTree.nbChildren,
self.POTree.depth + 1)
self.positionList[i] = (randomBlockID, path)
self.positionMap[randomBlockID] = (i, path)
t33 = time.time()
tm1 += t32 - t31
tm2 += t33 - t32
if i % (t // 64) == 0:
print round((float(i) / t) * 100, 2), '% done'
t4 = time.time()
self.POTree.writeBlocks(new_blockList)
t5 = time.time()
print 'blockDic insertion:', t2 - t1, '\n dummy block creation:', t3 - t2, '\n tree filling:', t4 - t3, '\n random block extraction:', tm1 / t, '\n path attribution:', tm2 / t, '\n block rerwriting in tree:', t5 - t4
def get_random_prime(bits=1024):
return int(gmpy.next_prime(randint(2**(bits - 1), 2**bits)))
import s34_aux
import socket
from Crypto.Random import get_random_bytes
from Crypto.Random.random import randint
for i in range(3):
p = 0xffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff
if i == 0:
g = 1
elif i == 1:
g = p
else:
g = p - 1
a = randint(2, p - 2)
A = pow(g, a, p)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 9001))
conn = s34_aux.Conn(sock)
conn.sendnum(p)
conn.sendnum(g)
conn.sendnum(A)
B = conn.readnum()
s = pow(B, a, p)
def generateQPKeys(self):
N2 = self.N * self.N
self.__a = random.randint(1, N2 // 4)
# self.__a = random.randint(1, 15)
self.h1 = util.calculate_expo_mod(self.g, self.__a, N2)
def convert2group(t, totalC):
return t + random.randint(0, (MAX_INT-t)/totalC) * totalC
def roll(self, limit):
return randint(1, 10)
lon = float(line[6])
p = str(proj(lat, lon))
xy = p.split(',')
strOut = ",".join(line[0:5]) + "," + xy[0][1:] + "," + xy[1][1:-1] + "," + ",".join(line[7:])
except:
pass
yield strOut
sc = pyspark.SparkContext()
busCSVFile = sys.argv[1]
runLocal = sys.argv[2] == 'T'
outputDir = sys.argv[3]
if(runLocal):
outputDir += str(randint(0, 999))
subprocess.call('rm -rf ' + outputDir, shell=True)
rddBikeUniqueStations = sc.textFile(busCSVFile) \
.mapPartitions(csvParse) \
.mapPartitions(lambda itr: toNAD83(itr)) \
.filter(lambda x: x != "") \
.saveAsTextFile(outputDir, "org.apache.hadoop.io.compress.GzipCodec")
if(runLocal):
print "Output Dir: " + outputDir
def __subloop(self, wsock: socket.socket):
'This method handles the state transitions for the Start/Stop procedures'
connid = randint(0, 65535)
while connid in self.__startdt.keys():
connid = randint(0, 65535)
msr = None
self.__startdt[connid] = False
wsock.settimeout(RTU_TIMEOUT)
self.log(f'Initiating state handler with ID {connid:d}')
while not self.terminate:
try:
data = wsock.recv(BUFFER_SIZE)
data = APDU(data)
atype = data['APCI'].Type
if msr is None: # STOPPED connection as shown in figure 17 from 60870-5-104 IEC:2006
if atype in [0x00,
0x01]: # I-frame (0x00) or S-frame (0x01)
self.log(
f'Received an unexpected frame ({TYPE_APCI[atype]:s}) in "STOPPED connection" state. Terminating thread ...'
)
self.__terminate = True
elif atype == 0x03: # U-frame (0x03)
ut = data['APCI'].UType
if ut == 0x01: # STARTDT act
self.log('Received a "STARTDT act" U-frame')
data = startdt(True) # STARTDT actcon
elif ut == 0x04: # STOPDT act
self.log('Received a "STOPDT act" U-frame')
data = stopdt(True) # STOPDT actcon
else: # TESTFR act
self.log('Received a "TESTFR act" U-frame')
data = testfr(True) # TESTFR actcon
# NOTE: If more than one bit is activated, it will be registered as a 'TESTFR act'
wsock.send(data)
if ut == 0x01: # Start the connection
self._RTU__startdt[
connid] = True # Track the state of the current connection
msr = Thread(target=self._RTU__measure,
kwargs={
'wsock': wsock,
'connid': connid
})
self.log('Start measuring data ...')
msr.start() # Start measuring
else: # STARTED connection as shown in figure 17 from 60870-5-104 IEC:2006
if atype == 0x03: # U-frame (0x03)
ut = data['APCI'].UType
if ut == 0x01: # STARTDT act
self.log('Received a "STARTDT act" U-frame')
data = startdt(True) # STARTDT actcon
elif ut == 0x04: # STOPDT act
self.log('Received a "STOPDT act" U-frame')
data = stopdt(True) # STOPDT actcon
self._RTU__startdt[
connid] = False # Change measurement state
self.log('Stop measusing data ...')
msr.join() # Stop measuring
msr = None
else: # TESTFR act
self.log('Received a "TESTFR act" U-frame')
data = testfr(True) # TESTFR actcon
wsock.send(data)
elif atype == 0x01: # S-frame (0x01)
self.log('Received an S-frame')
self.__tx = data['APCI'].Rx
else: # I-frame (0x00)
self.log('Received an I-frame. Initiating handler ...')
self.__handle_iframe(wsock, data)
# NOTE: In this particular simulation, we are not considering the 'Pending UNCONFIRMED STOPPED connection' state, as our responses are faster
except socket.timeout:
self.log('ERROR: T1 timeout')
self.__terminate = True # RTU T1 timeout => terminate connection
except BrokenPipeError:
self.log('ERROR: Connection ended unexpectedly')
self.__terminate = True # Connection ended unexpectedly.
except socket.error as e:
if e.errno != errno.ECONNRESET:
self.log(f'ERROR: Unknown socket error: {e.errno:d}')
raise # Other unknown error
self.__terminate = True
except IndexError:
self.log('ERROR: Index error')
if msr is not None: # The connection was still measuring
self.__startdt[connid] = False # Change measurement state
msr.join() # Stop measuring
msr = None
self.__startdt.pop(connid) # Remove the connection tracking
wsock.close()
def encrypt(self) -> bytes:
iv = Random.get_random_bytes(len(self.key))
s = self.choices[random.randint(0, len(self.choices) - 1)]
return block.aes_cbc_encrypt(s, self.key, iv), iv
def generate(length):
password = ""
for i in range(length):
index = random.randint(0, 63)
password = password + characters[index]
return password
def generate_keypair(p=P, q=Q, g=G):
x = randint(1, q-1)
y = pow(g, x, p)
return PublicKey(y), PrivateKey(x)
def runTest(self):
"""Crypto.Random.new()"""
# Import the Random module and try to use it
from Crypto import Random
randobj = Random.new()
x = randobj.read(16)
y = randobj.read(16)
self.assertNotEqual(x, y)
z = Random.get_random_bytes(16)
self.assertNotEqual(x, z)
self.assertNotEqual(y, z)
# Test the Random.random module, which
# implements a subset of Python's random API
# Not implemented:
# seed(), getstate(), setstate(), jumpahead()
# random(), uniform(), triangular(), betavariate()
# expovariate(), gammavariate(), gauss(),
# longnormvariate(), normalvariate(),
# vonmisesvariate(), paretovariate()
# weibullvariate()
# WichmannHill(), whseed(), SystemRandom()
from Crypto.Random import random
x = random.getrandbits(16 * 8)
y = random.getrandbits(16 * 8)
self.assertNotEqual(x, y)
# Test randrange
if x > y:
start = y
stop = x
else:
start = x
stop = y
for step in range(1, 10):
x = random.randrange(start, stop, step)
y = random.randrange(start, stop, step)
self.assertNotEqual(x, y)
self.assertEqual(start <= x < stop, True)
self.assertEqual(start <= y < stop, True)
self.assertEqual((x - start) % step, 0)
self.assertEqual((y - start) % step, 0)
for i in range(10):
self.assertEqual(random.randrange(1, 2), 1)
self.assertRaises(ValueError, random.randrange, start, start)
self.assertRaises(ValueError, random.randrange, stop, start, step)
self.assertRaises(TypeError, random.randrange, start, stop, step, step)
self.assertRaises(TypeError, random.randrange, start, stop, "1")
self.assertRaises(TypeError, random.randrange, "1", stop, step)
self.assertRaises(TypeError, random.randrange, 1, "2", step)
self.assertRaises(ValueError, random.randrange, start, stop, 0)
# Test randint
x = random.randint(start, stop)
y = random.randint(start, stop)
self.assertNotEqual(x, y)
self.assertEqual(start <= x <= stop, True)
self.assertEqual(start <= y <= stop, True)
for i in range(10):
self.assertEqual(random.randint(1, 1), 1)
self.assertRaises(ValueError, random.randint, stop, start)
self.assertRaises(TypeError, random.randint, start, stop, step)
self.assertRaises(TypeError, random.randint, "1", stop)
self.assertRaises(TypeError, random.randint, 1, "2")
# Test choice
seq = list(range(10000))
x = random.choice(seq)
y = random.choice(seq)
self.assertNotEqual(x, y)
self.assertEqual(x in seq, True)
self.assertEqual(y in seq, True)
for i in range(10):
self.assertEqual(random.choice((1, 2, 3)) in (1, 2, 3), True)
self.assertEqual(random.choice([1, 2, 3]) in [1, 2, 3], True)
if sys.version_info[0] is 3:
self.assertEqual(
random.choice(bytearray(b('123'))) in bytearray(b('123')),
True)
self.assertEqual(1, random.choice([1]))
self.assertRaises(IndexError, random.choice, [])
self.assertRaises(TypeError, random.choice, 1)
# Test shuffle. Lacks random parameter to specify function.
# Make copies of seq
seq = list(range(500))
x = list(seq)
y = list(seq)
random.shuffle(x)
random.shuffle(y)
self.assertNotEqual(x, y)
self.assertEqual(len(seq), len(x))
self.assertEqual(len(seq), len(y))
for i in range(len(seq)):
self.assertEqual(x[i] in seq, True)
self.assertEqual(y[i] in seq, True)
self.assertEqual(seq[i] in x, True)
self.assertEqual(seq[i] in y, True)
z = [1]
random.shuffle(z)
self.assertEqual(z, [1])
if sys.version_info[0] == 3:
z = bytearray(b('12'))
random.shuffle(z)
self.assertEqual(b('1') in z, True)
self.assertRaises(TypeError, random.shuffle, b('12'))
self.assertRaises(TypeError, random.shuffle, 1)
self.assertRaises(TypeError, random.shuffle, "11")
self.assertRaises(TypeError, random.shuffle, (1, 2))
# 2to3 wraps a list() around it, alas - but I want to shoot
# myself in the foot here! :D
# if sys.version_info[0] == 3:
# self.assertRaises(TypeError, random.shuffle, range(3))
# Test sample
x = random.sample(seq, 20)
y = random.sample(seq, 20)
self.assertNotEqual(x, y)
for i in range(20):
self.assertEqual(x[i] in seq, True)
self.assertEqual(y[i] in seq, True)
z = random.sample([1], 1)
self.assertEqual(z, [1])
z = random.sample((1, 2, 3), 1)
self.assertEqual(z[0] in (1, 2, 3), True)
z = random.sample("123", 1)
self.assertEqual(z[0] in "123", True)
z = random.sample(list(range(3)), 1)
self.assertEqual(z[0] in range(3), True)
if sys.version_info[0] == 3:
z = random.sample(b("123"), 1)
self.assertEqual(z[0] in b("123"), True)
z = random.sample(bytearray(b("123")), 1)
self.assertEqual(z[0] in bytearray(b("123")), True)
self.assertRaises(TypeError, random.sample, 1)
import json
from binascii import hexlify, unhexlify
from ecpy.curves import curve_secp256k1
from ecpy.point import Point, Generator
from ecpy.ecdsa import ECDSA
from Crypto.Random import random
from Crypto.Cipher import AES
from Crypto.Util import Counter
_curve = curve_secp256k1
Point.set_curve(_curve)
_G = Generator.init(_curve['G'][0], _curve['G'][1])
ECDSA.set_generator(_G)
server_p = random.randint(1, curve_secp256k1['n'] - 1)
server_P = _G * server_p
config = {}
config['receive_dir'] = "recv/"
config['message_dir'] = "messages/"
config['capacity'] = (128 * 1024 * 1024 * 1024)
config['max_file_size'] = (256 * 1024 * 1024)
config['ncache_sleep_interval'] = 30
config['version'] = '0.0.2'
clopts = []
clopts.append({'name': 'rpcuser', 'default': None})
clopts.append({'name': 'rpcpass', 'default': None})
clopts.append({'name': 'rpchost', 'default': '127.0.0.1'})
clopts.append({'name': 'rpcport', 'default': 7765})
fp2_i = field.ExtensionFieldElem(Fp2, fp2_ip)
xi = (c**2) * fp2_1 + (d**3) * fp2_i # c**2+(d**3)*A (4+i)
cxi = (c**2) * fp2_1 - (d**3) * fp2_i # c**2-(d**3)*A
#ixi = 8*fp2bi-8*fp2b1 # 8*A-8
#xi = ixi.invert()
#C2b = EllipticCurve.Curve(fp2b0, 3*ixi,Fp2b) # Y**2 = X**3+3*(8*A-8)
C2 = ellipticCurve.Curve(fp2_0, cxi,
Fp2) # Y**2 = X**3+c**2-(d**3)*A The twisted curve
PInf2 = ellipticCurve.ECPoint(infty=True)
EFp2 = ellipticCurve.ECGroup(Fp2, C2, PInf2)
u0 = EFp2.elem((-d) * fp2_i, c * fp2_1) #EC point (-d*A,c)
h = 2 * p - n
Q = u0 * h # Q is a generator of G2 of order n
r = randint(1, int(n))
s = randint(1, int(n))
rP = r * P
sQ = s * Q
##### Fp6 #####
poly3 = field.polynom(Fp2, [fp2_1, fp2_0, fp2_0, -xi]) #X**3-xi
Fp6 = field.ExtensionField(Fp2, poly3)
fp6_0 = Fp6.zero()
fp6_1 = Fp6.one()
fp6_xi = Fp6.elem(xi) # xi in Fp6
##### Fp12 #####
poly6 = field.polynom(Fp6, [fp6_1, fp6_0, -fp6_xi]) # X**2-xi
Fp12 = field.ExtensionField(Fp6, poly6)
print Fp12, " ...done"
from nibss.utils.crypt import Crypt
from Crypto.Random import random
iv = ''.join(chr(random.randint(0, 23)) for i in range(16))
aes = ''.join(chr(random.randint(0, 23)) for i in range(16))
responses = {
"single_bvn": {
'message': 'OK',
'data': {
'ResponseCode': '00',
'BVN': '12345678901',
'FirstName': 'Uchenna',
'MiddleName': 'Chijioke',
'LastName': 'Nwanyanwu',
'DateOfBirth': '22-Oct-1970',
'PhoneNumber': '07033333333',
'RegistrationDate': '16-Nov-2014',
'EnrollmentBank': '900',
'EnrollmentBranch': 'Victoria Island',
'WatchListed': 'NO'
}
},
"multiple_bvn": {
"message": "OK",
"data": {
"ResponseCode":
"00",
"ValidationResponses": [{
"ResponseCode": "00",
"BVN": "12345678901",
def test_encrypt_open_verify(self):
m1 = randint(1, self.n - 1)
#m1 = m1i*P
cipher1 = self.ppatcpk.encrypt(m1)
a1 = self.ppatcsk.opens(cipher1)
self.assertTrue(self.ppatcpk.verify(cipher1, m1, a1))
def test_commit_and_verify(self):
m1 = randint(1, self.n - 1)
r1 = randint(1, self.n - 1)
r2 = randint(1, self.n - 1)
d = self.ppatcpk.commit(m1, r1, r2)
self.assertTrue(self.ppatcpk.verifyCommitment(d, m1, r1, r2))
def queryBlock(self, blockID):
'''
This method returns the block stored in the self.POTree which corresponds
to the blockID
Doing so, the method modifies all the blocks along the path corresponding
to the block. The blocks are either :
- rerandomized
- moved in the stash
- reassigned in the path
- replaced by dummy blocks
'''
assert not self.isADummyBlock(blockID)
n = self.POTree.nbChildren
Z = self.POTree.Z
position, path = self.positionMap[blockID]
assert path in self.pathList
#print 'path', path
indexesList = pathToIndexList(path, n, Z)
#print 'indexesList', indexesList
assert ((position != 'stash') and
(position in indexesList)) or (position == 'stash')
l = len(self.pathList)
r = randint(0, l - 1)
new_path = self.pathList[r]
#print 'new_path', new_path
blockList = self.POTree.getBlocks(indexesList)
if position == 'stash':
querriedBlock = self.clientStash[blockID]
self.clientStash[blockID] = querriedBlock
else:
querriedBlock = blockList[indexesList.index(position)]
self.positionList[position] = blockID, new_path
self.positionMap[blockID] = position, new_path
for i in range(len(blockList)):
block_i = blockList[i]
pos_i = indexesList[i]
block_i_ID, path_i = self.positionList[pos_i]
# Update block position and add it to the stash or to the dummystash
if self.isADummyBlock(block_i_ID):
self.dummyStash[block_i_ID] = block_i
self.positionMap[block_i_ID] = ('dummy stash', path_i)
else:
self.clientStash[block_i_ID] = block_i
self.positionMap[block_i_ID] = ('stash', path_i)
self.positionList[pos_i] = (None, None)
new_block_list = self.getCandidates(
indexesList,
path) # seek candidates to greedily refill the path of the tree
#print len(new_block_list)
L = []
#print 'new_block_list',new_block_list
#print 'dummystash',self.dummyStash
for position_j, blockID_j in new_block_list:
if self.isADummyBlock(blockID_j):
block_j = self.dummyStash.pop(blockID_j)
L.append((position_j, block_j))
self.positionMap[blockID_j] = (None, None)
else:
block_j = self.clientStash.pop(blockID_j)
new_block_j = self.rerandomizeBlock(block_j)
L.append((position_j, new_block_j))
old_pos, path_j = self.positionMap[blockID_j]
self.positionList[position_j] = (blockID_j, path_j)
self.positionMap[blockID_j] = (position_j, path_j)
self.POTree.writeBlocks(L)
return querriedBlock
def oldtrain(solver, test_net, data_arrays, train_data_arrays, options):
caffe.select_device(options.train_device, False)
print('====> in training....')
net = solver.net
net.debug_info = True
#pdb.set_trace()
clwt = None
test_eval = None
if options.scale_error == 2:
clwt = ClassWeight(data_arrays, solver.iter)
test_eval = TestNetEvaluator(test_net, net, data_arrays, options)
test_eval2 = None
if (options.test_net != None):
test_eval2 = TestNetEvaluator(test_net, net, train_data_arrays,
options)
input_dims, output_dims, input_padding = get_spatial_io_dims(net)
fmaps_in, fmaps_out = get_fmap_io_dims(net)
print('input_dims:', input_dims)
print('output_dims:', output_dims)
print('input_padding:', input_padding)
print('fmaps_out:', fmaps_out)
dims = len(output_dims)
losses = []
shapes = []
# Raw data slice input (n = 1, f = 1, spatial dims)
shapes += [[1, fmaps_in] + input_dims]
# Label data slice input (n = 1, f = #edges, spatial dims)
shapes += [[1, fmaps_out] + output_dims]
if (options.loss_function == 'malis'):
# Connected components input (n = 1, f = 1, spatial dims)
shapes += [[1, 1] + output_dims]
if (options.loss_function == 'euclid'):
# Error scale input (n = 1, f = #edges, spatial dims)
shapes += [[1, fmaps_out] + output_dims]
# Nhood specifications (n = #edges, f = 3)
if (('nhood' in data_arrays[0]) and (options.loss_function == 'malis')):
shapes += [[1, 1] + list(np.shape(data_arrays[0]['nhood']))]
net_io = NetInputWrapper(net, shapes)
weight_vec = []
if (options.loss_function == 'softmax'
or options.loss_function == 'euclid') and options.scale_error == 1:
#pdb.set_trace()
weight_vec = class_balance_distribution(data_arrays[0]['label'])
#weight_vec[2] = weight_vec[1]*4.0 #for 3 class, inversed during weighting
#pdb.set_trace()
# Loop from current iteration to last iteration
for i in range(solver.iter, solver.max_iter):
if (options.test_net != None and i % options.test_interval == 0
and i > 1):
#pdb.set_trace()
test_eval2.evaluate(i)
if options.scale_error == 2:
test_eval.evaluate(i)
clwt.recompute_weight(test_eval.pred_arrays_samesize, i)
# First pick the dataset to train with
dataset = randint(0, len(data_arrays) - 1)
if dims == 3:
offsets = []
for j in range(0, dims):
offsets.append(
randint(
0, data_arrays[dataset]['data'].shape[1 + j] -
(output_dims[j] + input_padding[j])))
# These are the raw data elements
#pdb.set_trace()
data_slice = slice_data(
data_arrays[dataset]['data'], [0] + offsets, [fmaps_in] +
[output_dims[di] + input_padding[di] for di in range(0, dims)])
label_slice = slice_data(data_arrays[dataset]['label'], [0] + [
offsets[di] + int(math.ceil(input_padding[di] / float(2)))
for di in range(0, dims)
], [fmaps_out] + output_dims)
if options.scale_error == 2 and clwt != None:
weight_slice = slice_data(clwt.class_weights[dataset], [0] + [
offsets[di] + int(math.ceil(input_padding[di] / float(2)))
for di in range(0, dims)
], [fmaps_out] + output_dims)
elif dims == 2:
offsets = []
offsets.append(
randint(0, data_arrays[dataset]['data'].shape[1] - 1))
for j in range(0, dims):
offsets.append(
randint(
0, data_arrays[dataset]['data'].shape[1 + j] -
(output_dims[j] + input_padding[j])))
# These are the raw data elements
#pdb.set_trace()
data_slice = slice_data(
data_arrays[dataset]['data'], [0] + offsets, [fmaps_in, 1] +
[output_dims[di] + input_padding[di] for di in range(0, dims)])
label_slice = slice_data(
data_arrays[dataset]['label'], [0, offsets[0]] + [
offsets[di + 1] +
int(math.ceil(input_padding[di] / float(2)))
for di in range(0, dims)
], [fmaps_out, 1] + output_dims)
data_slice = np.squeeze(data_slice)
label_slice = np.squeeze(label_slice)
#offsets=np.zeros(dims);
if (data_slice.shape[0] < 1) or (label_slice.shape[0] < 2):
pp = 1
#print('pid:', os.getpid(), 'offsets:', offsets, 'dims:', dims, 'shape:', data_arrays[dataset]['data'].shape)
#exit(1)
#pdb.set_trace()
#if(np.unique(label_slice).shape[0]<2):
# continue;
# transform the input
# this code assumes that the original input pixel values are scaled between (0,1)
if 'transform' in data_arrays[dataset]:
# print('Pre:',(data_slice.min(),data_slice.mean(),data_slice.max()))
data_slice_mean = data_slice.mean()
lo, hi = data_arrays[dataset]['transform']['scale']
data_slice = data_slice_mean + (
data_slice - data_slice_mean) * np.random.uniform(low=lo,
high=hi)
lo, hi = data_arrays[dataset]['transform']['shift']
data_slice = data_slice + np.random.uniform(low=lo, high=hi)
# print('Post:',(data_slice.min(),data_slice.mean(),data_slice.max()))
data_slice = np.clip(data_slice, 0.0, 0.95)
if options.loss_function == 'malis':
components_slice, ccSizes = malis.connected_components_affgraph(
label_slice.astype(int32), data_arrays[dataset]['nhood'])
# Also recomputing the corresponding labels (connected components)
net_io.setInputs([
data_slice, label_slice, components_slice,
data_arrays[0]['nhood']
])
if options.loss_function == 'euclid':
###if(options.scale_error == True):
###frac_pos = np.clip(label_slice.mean(),0.05,0.95) #for binary labels
###w_pos = 1.0/(2.0*frac_pos)
###w_neg = 1.0/(2.0*(1.0-frac_pos))
###else:
###w_pos = 1
###w_neg = 1
###net_io.setInputs([data_slice, label_slice, error_scale(label_slice,w_neg,w_pos)])
if (options.scale_error == 3):
frac_pos = np.clip(label_slice.mean(), 0.01,
0.99) #for binary labels
w_pos = 1.0 / (2.0 * frac_pos)
w_neg = 1.0 / (2.0 * (1.0 - frac_pos))
net_io.setInputs([
data_slice, label_slice,
error_scale(label_slice, w_neg, w_pos)
])
elif (options.scale_error == 1):
frac_pos = weight_vec[0]
w_pos = 1. / frac_pos
label_weights = error_scale_overall(label_slice, weight_vec)
net_io.setInputs([data_slice, label_slice, label_weights])
elif options.scale_error == 2:
net_io.setInputs([data_slice, label_slice, weight_slice])
elif options.scale_error == 0:
net_io.setInputs([data_slice, label_slice])
if options.loss_function == 'softmax':
net_io.setInputs([data_slice, label_slice])
#pdb.set_trace()
print('data_slice dims:', data_slice.shape)
# Single step
n_slices = output_dims[-1]
loss = solver.step(1) #n_slices)
#for i in range(n_slices):
# loss = solver.stepForward(1)
#solver.stepBackward()
# sanity_check_net_blobs(net)
while gc.collect():
pass
if (options.loss_function == 'euclid' or options.loss_function
== 'euclid_aniso') and options.scale_error == 1:
print("[Iter %i] Loss: %f, frac_pos=%f, w_pos=%f" %
(i, loss, frac_pos, w_pos))
else:
print("[Iter %i] Loss: %f" % (i, loss))
# TODO: Store losses to file
losses += [loss]
if hasattr(options, 'loss_snapshot') and ((i % options.loss_snapshot)
== 0):
io.savemat('loss.mat', {'loss': losses})
def fb():
return 'DB' + (str(randint(0, 2**20))), 'dummy block'
def generate_wallet(wallet_password):
# __________________________________________________________________________________________________________________
# SECP256K1 PARAMETERS FOR EC CRYPTOGRAPHY
p = int("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F",
16)
n = int("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141",
16)
h = 1
# __________________________________________________________________________________________________________________
# ELLIPTIC CURVE DEFINITION
x = int("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798",
16) # See "Recommended Eliptic Curve Domain Parameters" Paper
y = int("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8",
16)
g = (x, y)
field = SubGroup(p, g, n, h)
curve = Curve(a=0, b=7, field=field,
name='secp2561k') # Object creation for the elliptic curve
# __________________________________________________________________________________________________________________
# PRIVATE/PUBLIC KEY GENERATION THROUGH 'ELLIPTIC CURVE POINT MULTIPLICATION'
private_key = randint(1, n)
#private_key = int("f8f8a2f43c8376ccb0871305060d7b27b0554d2cc72bccf41b2705608452f315", 16) #example
public_key = private_key * curve.g
# The public key is generated as an added point to the elliptic curve g. To obtain this new point, the eliptic curve
# is multiplied by an initial point, known as the private key. Even given the elliptic curve and new point,
# it is not (easily) possible to find the initial point (i.e. the private key).
# __________________________________________________________________________________________________________________
# DERIVING THE ETHEREUM ADDRESS FROM PUBLIC KEY
public_key_hex = Web3.toHex(public_key.x)[2:] + Web3.toHex(
public_key.y)[2:] # Removing the 0x start using [2:]
address = Web3.keccak(hexstr=public_key_hex).hex()
address = Web3.toChecksumAddress('0x' + address[-40:])
# 0x is added to the last 40 characters of the sha-256 encrypted public key to generate the Ethereum address. A
# Checksum is applied to the result by capitalizing certain characters (purely for readability).
# __________________________________________________________________________________________________________________
# PASSWORD PROTECTION
password = str(wallet_password).encode('utf-8')
password = bytes(password) # Choose a password
salt = get_random_bytes(16) # Generate a random salt
key = scrypt(password, salt, 32, N=2**20, r=8,
p=1) # Generate a 32-byte encryption key from the password
# and salt, with CPU cost parameter 2**20
private_key = Web3.toHex(private_key)[
2:] # Convert existing private key to Hex format
data = str(private_key).encode(
'utf-8') # Convert Hex key to string and encode into bytes
cipher = AES.new(key, AES.MODE_CBC) # Call required AES encryption method
ct_bytes = cipher.encrypt(pad(
data, AES.block_size)) # Encrypt private key 'data' using AES-256
salt = salt.hex() # Convert salt to hex
iv = cipher.iv.hex() # Convert initialization vector to hex
ct = ct_bytes.hex() # Convert encrypted private key to hex
output = {
'salt': salt,
"initialization vector": iv,
"encrypted private key": ct
}
with open(address + '.txt', 'w') as json_file:
json.dump(output, json_file)
print('Generated wallet:')
print(' address: ', address)
print()
#print('Private key: ', private_key) Only print for testing
return 0
def double8_enc(key1, key2, message, iv):
actual_key1 = bytes.fromhex(key1) * 16
actual_key2 = bytes.fromhex(key2) * 16
cipher1 = AES.new(actual_key1, AES.MODE_CBC, iv)
cipher2 = AES.new(actual_key2, AES.MODE_CBC, iv)
return cipher2.encrypt(cipher1.encrypt(pad(message, AES.block_size)))
if __name__ == '__main__':
# generate two random 1-byte keys in an OpenSSL-like format
# (string of hexadecimal digits without leading 0x)
# e.g., "aa" "07" "f4"
key1 = format(randint(0, 256), '02x')
key2 = format(randint(0, 256), '02x')
print(key1)
print(key2)
#generate a random IV
iv = get_random_bytes(16)
print(iv)
# generate a plaintext and double-encrypt it with a short-key cipher
plaintext = b'This is just a string that has not a meaning'
ciphertext = double8_enc(key1, key2, plaintext, iv)
# number of keys to explore with the used cipher
# 8 bit key -> 256 keys
# in double encryption -> 65535 keys
def ia_pd():
world.cfg["ia_pd"] = randint(1, 99999)
if "values" in world.cfg:
world.cfg["values"]["ia_pd"] = world.cfg["ia_pd"]
def encode_vault_size(self, lhs, n):
v = self.G.get(lhs, {})
n = str(n)
try:
i = v.keys().index(n)
x = sum(v.values()[:i])
y = x + v.values()[i]
except ValueError:
return convert2group(0, v['__total__'])
return convert2group(random.randint(x, y - 1), v['__total__'])
def decode_vault_size(self, lhs, cf):
assert not lhs.startswith('L')
cf %= self.G[lhs]['__total__']
if cf == 0 and lhs == 'G':
print_err("Grammar of size 0!!!!", lhs, cf)
#return cf
i = getIndex(cf, self.G[lhs].values())
return i + 1
if __name__ == '__main__':
vd = VaultDistribution()
assert vd.decode_vault_size('D', vd.encode_vault_size('D', 0)) == 0
for i in range(25):
k = random.randint(0, MAX_ALLOWED)
lhs = random.choice(vd.G.keys())
e = vd.encode_vault_size(lhs, k)
assert vd.decode_vault_size(lhs, e) == k
send_encrypted(KEY, output)
print """Welcome to the
______ _ _ _____ _ _ _
| _ \ | | | / ___| | | | |
| | | | |_| | \ `--.| |__ ___| | |
| | | | _ | `--. \ '_ \ / _ \ | |
| |/ /| | | | /\__/ / | | | __/ | |
|___/ \_| |_/ \____/|_| |_|\___|_|_|
"""
print "Parameters:"
print "p = {}".format(p)
print "g = {}".format(g)
a = random.randint(1, 2**46)
A = pow(g, a, p)
print "A = {}".format(A)
B = int(raw_input("Please supply B: "))
K = pow(B, a, p)
KEY = sha256(str(K)).digest()
pw = read_encrypted(KEY)
if pw == password:
serve_commands(KEY)
else:
send_encrypted("Invalid password!\n")
def create_dh_key():
my_private_key = random.randint(1, int(2**8))
my_public_key = (Generator**my_private_key) % prime
return (my_public_key, my_private_key)
def create_dh_key():
# Creates a Diffie-Hellman key
# Returns (public, private)
private = random.randint(2, int(2**8))
public = (2**private) % prime
return (public, private)
