def RSA_key_generation(p,q, identity = 'Alice', filename = 'private_key.txt'): N = p * q phi_N = (p - 1) * (q - 1) e = random.randrange(0, phi_N) # public key while True: if check_relatively_prime(e, phi_N): break else: e = random.randrange(0, phi_N) # e = 65537 if check_relatively_prime(e, phi_N) == False: print "This e doesnot work" d = Ext_Euclidean(e, phi_N) # private key # use the private key to sign the public key try: with open('private_key.txt','r') as infile: # use the private key from file to sign public key private_key = file.readlines() private_key = int(private_key, 16) file.close() signature = pow(d, private_key, N) signature = hex(signature) signature = signature[2:-1] except IOError: # file do not exist, use the own private key to sign public key signature = pow(e, d, N) signature = hex(signature) signature = signature[2:-1] return N, phi_N, d, e, identity, signature
def encryptOracle(text): from Crypto.Random import random preCnt = random.randrange(5,10) postCnt = random.randrange(5,10) text = randNumBytes(preCnt) + text + randNumBytes(postCnt) blob = Blob() blob.fromStr(text) print len(blob.tostring()) blob.pkcs7(AES.block_size) print len(blob.tostring()) key = randNumBytes(AES.block_size) iv = randNumBytes(AES.block_size) choice = random.randrange(0,1) if choice == 0: ret = encryptCBC(key, iv, blob.tostring()) else: ret = encryptECB(key, blob.tostring()) return ret
def random_result(votes, num, g, h, p): vote_g = [] vote_p = [] hash_g = [] hash_p = [] for i in range(num): vote_g_i = [] vote_p_i = [] hash_g_i = [] hash_p_i = [] for j in range(len(votes)): len_j = len(votes[j]) ran = random_int.randint(0, len_j - 1) m_str = votes[j][ran] m = Utils.str_to_message(m_str) hm = CryptoHash.get_hash(m, p) r = random.randrange(2, p) s = random.randrange(2, p) vote_g_i.append(pow(g, r, p)) vote_p_i.append(pow(h, r, p) * m % p) hash_g_i.append(pow(g, s, p)) hash_p_i.append(pow(h, s, p) * hm % p) vote_g.append(vote_g_i) vote_p.append(vote_p_i) hash_g.append(hash_g_i) hash_p.append(hash_p_i) return [vote_g, vote_p, hash_g, hash_p]
def randomize_location(lat, lon): """randomize location""" rnd1 = float("0."+"".join(str(random.randrange(10)) for x in range(32))) rnd2 = float("0."+"".join(str(random.randrange(10)) for x in range(32))) d_min = 100 # meters d_max = 700 # meters gamma = 6.35e-6 # meters^-1 angle = -180 + 360 * rnd1 # degrees distance = d_min + (d_max - d_min) * rnd2 # meters # don't move when we are at the poles if -89 < lat < 89: lat = lat + distance * gamma * \ (1 + (sin(lat))** 2) * sin(angle) lon = lon + distance * gamma * \ (1 + (sin(lat)) ** 2) * cos(angle) / cos(lat) # take care at the edges - avoid invalid values if lat > 90: lat = 90 - ( lat - 90 ) elif lat < -90: lat = -90 - ( lat - (-90) ) if lon < -180: lon += 360 elif lon > 180: lon -= 360 return lat, lon
def encrypt(data, pk): n, y = pk u = randrange(n) a = randrange(n) c = randrange(n) for m in data.hex(): yield pow(y, int(m, 16), n) * pow(u, r, n) % n u = (a*u + c) % n
def genkey(k): p = getPrime(k) g = random.randrange(2, p) x = random.randrange(1, p - 1) h = pow(g, x, p) pk = (p, g, h) sk = (p, x) return (pk, sk)
def you_thought_it_was_rsa_encryption_but_it_was_me_dio(data, n, e): m = randrange(n) a = randrange(m) b = randrange(m) nonce = randrange(m) for d in data.hex(): yield pow(e, int(d, 16), n) * pow(nonce, -1, n) % n nonce = (a*nonce + b) % m
def RandText(): # Returns a random piece of text. words = random.randrange(1, 99) txt = [] for i in range(words): # Word length. L = random.randrange(1, 99) txt.append(Random.new().read(L)) return b' '.join(txt)
def RandPassword(): # Returns a random password between 1 and 196. L = random.randrange(3, 196) pwd = [] for i in range(L): # From 'space' to '~'. pwd.append( chr(random.randrange(32, 126)).encode() ) pwd = ''.join(pwd) L = len(pwd) return pwd
def RandPassword(): # Returns a random password between 1 and 128. L = random.randrange(1, 128) pwd = [] for i in range(L): # From 'space' to '~'. pwd.append(chr(random.randrange(32, 126)).encode()) pwd = b''.join(pwd) L = len(pwd) return pwd
def perhaps_rsa_keygen(): p, q = [getPrime(1024) for _ in range(2)] n = p*q phi = (p-1)*(q-1) e = randrange(n) while gcd(e, phi) != 1: e = randrange(n) return (n, e), (n, pow(e, -1, phi))
def millerRabin(p): i=0 while (p > (1<<i)): i+=1 for k in range(0,10): n=random.randrange(1<<i) while(euclid(n,p)[0]!=1): n=random.randrange(1<<i) if modifiedPower(n,(p-1),p) != 1: return False return True
def encryption_oracle(plaintext: bytes) -> bytes: plaintext = bytes(randrange(5, 11)) + plaintext + bytes(randrange(5, 11)) plaintext = pkcs7(plaintext) key = get_random_bytes(16) if randrange(2) == 0: iv = get_random_bytes(16) return encrypt_aes_cbc(key, iv, plaintext) cypher = AES.new(key, AES.MODE_ECB) return cypher.encrypt(plaintext)
def encryption_oracle(data): rndfile = Random.new() mode = random.choice([AES.MODE_ECB, AES.MODE_CBC]) if mode == AES.MODE_ECB: print("Using ECB!") crypt = AES.new(rndfile.read(16), mode) else: print("Using CBC!") crypt = AES.new(rndfile.read(16), mode, rndfile.read(16)) plaintext = rndfile.read(random.randrange(5, 10)) + data + rndfile.read( random.randrange(5, 10)) return crypt.encrypt(pad_pkcs7(plaintext, 16))
def __init__(self, prime: int, generator: int, username: str, password: str) -> None: self.n = prime self.g = generator self.I = username self.salt = randrange(64) self._x = self._integer_hash(self.salt, password) self.v = pow(self.g, self._x, self.n) self._a = randrange(self.n) self.A = pow(self.g, self._a, self.n)
def make_key_pair(p, q): N = p * q phi_N = (p - 1) * (q - 1) e = random.randrange(0, phi_N) while True: if check_relatively_prime(e, phi_N): break else: e = random.randrange(0, phi_N) # e = 65537 if check_relatively_prime(e, phi_N) == False: print "This e doesnot work" d = Ext_Euclidean(e, phi_N) return N, phi_N, d, e
def assigning_keys(p,q, identity = 'Alice'): N = p * q phi_N = (p - 1) * (q - 1) e = random.randrange(0, phi_N) # public key while True: if check_relatively_prime(e, phi_N): break else: e = random.randrange(0, phi_N) if check_relatively_prime(e, phi_N) == False: print "This e doesnot work" d = Ext_Euclidean(e, phi_N) # private key p = {"identity":identity, "public_key": e, "private_key": d, "order": N} people.append(p) return e , d, N
def encrypt(pk, path="message.txt",saveCT="ciphertext.enc"): # Generate random x in Zn x = random.randrange(2, (pk.n)-1) #random x in Zn # Calculate y = RSA(x) as x^e mod N y = pow(x, pk.e, pk.n) #y to send with ciphertext # Compute symmetric key with Hash function (SHA224) k = SHA224.new(repr(x).encode('utf-8')).hexdigest().encode('utf-8') #symmetric key for compute the ciphertext print("K: "+str(k)) # Open file plaintext to cipher plaintext = open(path,"rb").read() # Count block_size bs = Blowfish.block_size # Generate a random init vector iv = Random.new().read(bs) # Initialize Blowfish cipher cipher = Blowfish.new(k, Blowfish.MODE_CBC, iv) # Calculate Plaintext for padding plen = bs - divmod(len(plaintext),bs)[1] # Add padding padding = [plen]*plen padding = struct.pack('b'*plen,*padding) # Encrypt adding IV ciphertext = iv + cipher.encrypt(plaintext+padding) # Save ciphertext to file: print("CT-LEN:"+str(len(ciphertext))) with open(saveCT, 'wb') as output: dill.dump(y, output) dill.dump(ciphertext, output) return plaintext, ciphertext
def encrypt(pk, m, r=None): (p, g, h) = pk if r is None: r = random.randrange(1, p - 1) c1 = pow(g, r, p) c2 = (m * pow(h, r, p)) % p return (c1, c2)
def key_matrix_generator_Bob(public_key,array_of_images): """Key Matrix Generator""" key=ECC.import_key(public_key) #importing private key from Alice Q=key.pointQ P=ECC.EccPoint(x=key._curve.Gx,y=key._curve.Gy, curve='P-256') n=32 k_b = (random.randrange(2**(n-1)+1, 2**n - 1) ) k_c = (random.randrange(2**(n-1)+1, 2**n - 1)) ##note call the proper definition, R=k_b*P S=k_c*P K_0 = k_b*Q L = k_c*Q K_M=key_matrix_generator(K_0,L,array_of_images) # np.savetxt("Matrix.txt",(K_M)) return K_M,R,S
def encrypt(self, s, mac=16): """Encrypt a message for private viewing by the holder of the Private Key """ # nonce is essentially a secret on the encrypter's side # this is a secret exponent < 2^256 nonce = randrange(1, self.curve().p()) tmp = BasePoint * nonce nonce_point = PubKey(tmp.curve(), tmp.x(), tmp.y()) tmp = self * nonce shared_secret = PubKey(tmp.curve(), tmp.x(), tmp.y()) # derive a key for making a cipher and checksum using the # nonce point and shared secret key = nonce_point.kdf(shared_secret) # encode the nonce point into the message as the beginning header = nonce_point.sec() # encrypt the actual message using the AES cipher cipher = AES.new(key[:32]) # because we're using AES block mode, we need multiples of 16 s = s + '\x00' * (16 - len(s) % 16) message = cipher.encrypt(s) # add a checksum for validation checksum_maker = hmac.new(key[32:], digestmod=hashlib.sha256) checksum_maker.update(message) checksum = checksum_maker.digest()[:mac] return header + message + checksum
def encrypt(key, path="message.txt", saveCT="ciphertext.enc"): b = random.randrange(2, (key.p)-1) u = modexp(key.g, b, key.p) v = modexp(key.h, b, key.p) uv = str(u)+str(v) k = SHA224.new(uv.encode('utf-8')).hexdigest().encode('utf-8') #symmetric key for compute the ciphertext with AES print("K: "+str(k)) # Open file plaintext to cipher plaintext = open(path,"rb").read() #plaintext = encode(plaintext, key.iNumBits) bs = Blowfish.block_size iv = Random.new().read(bs) cipher = Blowfish.new(k, Blowfish.MODE_CBC, iv) plen = bs - divmod(len(plaintext),bs)[1] padding = [plen]*plen padding = struct.pack('b'*plen,*padding) ciphertext = iv + cipher.encrypt(plaintext+padding) # Save ciphertext to file: print("CT-LEN:"+str(len(ciphertext))) with open(saveCT, 'wb') as output: dill.dump(u, output) dill.dump(ciphertext, output) return plaintext, ciphertext
def encrypt(self,m): if type(m) == str: m = int(m) assert Aux.is_int(m) pub = Cipher.get_public_key(self) assert pub.has_key("n") assert pub.has_key("g") n = pub["n"] n2 = n*n if not pub.has_key("n2") else pub["n2"] if not pub.has_key("n2"): pub["n2"] = n2 g = pub["g"] r = pub["r"] if pub.has_key("r") else random.randrange(1,n) assert abs(m) < n if m < 0: g_m__n2 = self.__modinv(pow(g,-m,n2),n2) else: g_m__n2 = pow(g,m,n2) c = g_m__n2*pow(r,n,n2) % n2 return str(c)
def genkey(): while True: p = 2 while size(p) < 512: p *= getPrime(randrange(2, 12)) if isPrime(p + 1): return p + 1
def __init__(self, ip, port, client_nr, clientsocket): threading.Thread.__init__(self) self.ip = ip self.port = port self.client_nr = client_nr self.csocket = clientsocket key = Key() self.server_secret = randrange(0, key.q - 1) self.shared_prime = key.p self.shared_base = key.g self.server_DHside = pow(self.shared_base, self.server_secret, self.shared_prime) # Everything is set after establishing session key self.sessionKey = 0 self.enc_key = 0 self.auth_key = 0 self.enc = 0 self.dec = 0 self.ehmac = 0 self.dhmac = 0 self.nonce_iv = 0 self.nrseq = 0 print("[+] New thread started for " + ip + ":" + str(port))
def initializeGame(): all_players = [] for player in PLAYERS_COLLECTION.find(): all_players.append(player) needed_werewolves = len(all_players) / 3 count = 0 rand_number_list = [] while count != needed_werewolves: rand = randrange(0, len(all_players)) if rand in rand_number_list: continue else: rand_number_list.append(rand) count += 1 for i in rand_number_list: cur_player_id = (all_players[i])["userID"] playerDAO.updatePlayer(cur_player_id, "alignment", "Werewolf") if count > 0: GAMES_COLLECTION.update({}, {"$set": {"isActive": True}}) return True else: return False
def encryption_oracle(plaintext): plaintext = bytes(randrange(5, 11)) + plaintext + bytes(randrange(5, 11)) plaintext = pkcs7(plaintext, 16) key = bytes(getrandbits(8) for i in range(16)) if randrange(0,2) == 0: iv = bytes(getrandbits(8) for i in range(16)) cyphertext = encrypt_aes_cbc(plaintext, key, iv) #print("CBC") else: cypher = AES.new(key, AES.MODE_ECB) cyphertext = cypher.encrypt(plaintext) #print("ECB") return cyphertext
def is_prime(n, k=128): """ Test if a number is prime Args: n -- int -- the number to test k -- int -- the number of tests to do return True if n is prime """ # Test if n is not even. # But care, 2 is prime ! if n == 2 or n == 3: return True if n <= 1 or n % 2 == 0: return False # find r and s s = 0 r = n - 1 while r & 1 == 0: s += 1 r //= 2 # do k tests for _ in range(k): a = random.randrange(2, n - 1) x = pow(a, r, n) if x != 1 and x != n - 1: j = 1 while j < s and x != n - 1: x = pow(x, 2, n) if x == 1: return False j += 1 if x != n - 1: return False return True
def generate_prime(num_bits): k = num_bits i = 0 prime_less_than_1000 = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 ] while True: p = random.randrange(2**(k - 1), 2**(k)) check = 0 for i in prime_less_than_1000: if p % i == 0: check = 1 # i = i+1 if check == 0: prime_number_p = prime_test(p) if prime_number_p == True: #print i return p
def do_rerand(self, arg: CipherValue, public_key: List[int]) -> Tuple[List[int], List[int]]: # homomorphically add encryption of zero to re-randomize r = randrange(babyjubjub.CURVE_ORDER) enc_zero = CipherValue(self._enc_with_rand(0, r, public_key), params=arg.params) return self.do_op('+', public_key, arg, enc_zero), [r]
def create_dh_key(): # Creates a Diffie-Hellman key # Returns (public, private) g = 2 priv = random.randrange(1, prime-1) pub = pow(g, priv, prime) return (pub, priv)
def hashSign(self, m, vi, l1, delta, si): # Not used currently, but could be used to verify token parts are valid """ H'(m) :param: m - message (plaintext) :param: vi - verification key share :param: l1 - Secondary security parameter :param: delta - n factorial :param: si - secret share :returns: (z,c) - pair """ x = self.hash(m) r = randrange(0, pow(2, int.bit_length(self.N) + 2 * l1)) vprime = pow(self.v, r, self.N) xtilde = pow(x, 4 * delta, self.N) xprime = pow(xtilde, r, self.N) xi = pow(x, 4 * delta * si, self.N) b = SHAKE256.new() # Via Shoup p.215, b.update(bytes(self.v % self.N)) b.update(bytes(xtilde)) b.update(bytes(vi % self.N)) b.update(bytes(xi % self.N)) b.update(bytes(vprime)) b.update(bytes(xprime)) c = int(hexlify(b.read(l1)), 16) % self.N z = c * si + r return (z, c)
def generate_rand_poly(self, round): if self.is_member == False: raise ValueError('attribute is_member is false') coeffs = [randrange(CURVE_ORDER) for i in range(self.threshold)] coeffs = [ self.si, ] + coeffs self.poly_dict[round] = IntPoly(coeffs)
def __init__(self, mod): # Mod should be a prime number while not sympy.isprime(mod): mod -= 1 if mod == 1: print("You done messed up good") raise Exception a = v = 100 while math.gcd(a, v) != 1: a = random.randrange(mod) v = random.randrange(mod) self.a = a self.v = v self.mod = mod self.counter = 0
def testsys(obj): plain = random.randrange(0, obj.n) plain_enc = obj.encrypt(plain) plain_dec = obj.decrypt(plain_enc) if (plain_dec == plain): print("Encryption and Decryption work") else: print("Error in encryption or decryption") plain2 = random.randrange(0, obj.n) plain2_enc = obj.encrypt(plain2) plain2_dec = obj.decrypt(plain2_enc) sec_add = obj.secure_addition(plain_enc, plain2_enc) sec_add_dec = obj.decrypt(sec_add) if (sec_add_dec == (plain + plain2) % obj.n): print("Secure additon works") else: print("Error in secure addition") scalar = random.randrange(0, obj.n) sec_mul = obj.secure_scalar_multiplication(plain_enc, scalar) sec_mul_dec = obj.decrypt(sec_mul) if (sec_mul_dec == (plain * scalar) % obj.n): print("Secure Scalar Multiplication Works") else: print("Error in secure scalar multiplication") if (plain > plain2): sec_sub = obj.secure_subtraction(plain_enc, plain2_enc) dif = plain - plain2 else: sec_sub = obj.secure_subtraction(plain2_enc, plain_enc) dif = plain2 - plain sec_sub_dec = obj.decrypt(sec_sub) if (sec_sub_dec == dif): print("Secure subtraction works") else: print("Error in secure subtraction")
def generate_prime(): while 1: q=random.randrange(1<<512) if millerRabin(q): break while 1: k=random.randrange(1<<10) if millerRabin(k*q+1): p=q*k+1; break while 1: h=random.randrange(2,p) if modifiedPower(h,(p-1)/q,p)!=1: g=modifiedPower(h,(p-1)/q,p) break return g,p,q
def receive_pubkey(self, I: str, A: int) -> dict[str, int]: self.client[I]["A"] = A self.client[I]["u"] = randrange(16) return { "s": self.client[I]["s"], "B": pow(self.g, self._b, self.n), "u": self.client[I]["u"] }
def genkey(): g = 2 while True: p = 2 for _ in range(50): p *= getPrime(randrange(38, 42)) if isPrime(p + 1): if pow(g, p // 2, p + 1) == p: return g, p + 1
def random_string(length=-1, charset=string.ascii_letters): """ Returns a random string of "length" characters. If no length is specified, resulting string is in between 6 and 15 characters. A character set can be specified, defaulting to just alpha letters. """ if length == -1: length = random.randrange(6, 16) random_string = ''.join(random.choice(charset) for x in range(length)) return random_string
def __init__(self, username, password, **kwargs): super(UserModel, self).__init__(**kwargs) salt = get_random_bytes(randrange(96, 128)).hex() self.username = username self.password = SHA256.new(password.encode() + salt.encode()).hexdigest() self.salt = salt db.session.add(self) db.session.commit()
def RandPassword(): # Returns a random password between 1 and 196. L = random.randrange(1, 19) pwd = [] for i in range(L): pwd.append(random.choice('0123456456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')) pwd = b''.join(pwd) L = len(pwd) return pwd
def random_string(length=-1, charset=string.ascii_letters): """ Returns a random string of "length" characters. If no length is specified, resulting string is in between 6 and 15 characters. A character set can be specified, defaulting to just alpha letters. """ if length == -1: length = random.randrange(6,16) random_string = ''.join(random.choice(charset) for x in range(length)) return random_string
def __init__(self, stm=None, stp=None, S=None): if stm or stp: self._stm = stm self._stp = stp else: Krsa = _RSA.generate(self._size) S = S or _random.randrange(3, Krsa.n) assert 3 <= S <= Krsa.n self._stm = None self._stp = self._STP(Krsa.n, Krsa.e, Krsa.d, S)
def __remove_corrupt_machine_guid_xattr(self, fd, xattr_name): try: fremovexattr(fd, xattr_name) except OSError as e: if e.errno in ENOATTR_LIST: TRACE('!! Corrupt local guid xattr already gone! (probably racing)') sleeptime = random.randrange(100, 501) / 1000.0 TRACE('!! Sleeping %d ms before restarting to avoid colliding with other instances', sleeptime * 1000) raise RaceDetected elif e.errno == errno.EACCES: TRACE("!! Can't remove corrupt local guid xattr: access denied") raise else: unhandled_exc_handler() raise else: sleeptime = random.randrange(50, 201) / 1000.0 TRACE('!! Sleeping %d ms before continuing to avoid colliding with other instances', sleeptime * 1000) time.sleep(sleeptime)
def report_client_timing(self, timing_report): url = timing_report['url'].split('?')[0] percent = min(self.timing_report_percent_url.get(url, 100), REPORT_PERCENT_URL.get(url, 100), self.timing_report_percent) if percent == 0: return if percent < 100: if random.randrange(10000) >= percent * 100: return if url in ('retrieve_batch', 'retrieve_batch_parallel', 'store_batch', 'store_batch_parallel'): for limit in ('download_hash_batch_max', 'download_hash_batch_max_size', 'download_hash_batch_parallel_connections', 'upload_hash_batch_max', 'upload_hash_batch_max_size', 'upload_hash_batch_parallel_connections'): timing_report[limit] = self.dropbox_app.sync_engine.server_limits.get(limit) report('timing', **timing_report)
def randnum(x, y): """ Generate a random int between x (inclusive) and y (exclusive) Args: x (int): inclusive lower bound y (int): exclusive upper bound Returns: int: random number """ assert isinstance(x, int) assert isinstance(y, int) assert y - x < 2147483648, "Range too large" # 2 ** 31 return random.randrange(x, y)
def cryptString(secret, plain): '''只有CM在使用,以后不要再使用''' obj = Blowfish.new(secret, Blowfish.MODE_ECB) randstring = str.join( '', random.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890', 12)) split = random.randrange(10) + 1 s = randstring[:split] + ':valid:' + plain + ':valid:' + randstring[split:] length = len(s) l = length + 8 - (length % 8) padded = s + " " * (8 - length % 8) ciph = obj.encrypt(padded[:l]) try: return b32encode(ciph) except NameError: return encodestring(ciph)
def generate_keys(prime = None, generator = None): """ generates the private and public keys according to the Diffie-Hellman Protocol. Generates the public and private keys according to the Diffie-Hellman Protocol. The number q used to generate the private key is (prime - 1) / 2, i.e a n-1-bit number, this definition is taken from RFC 2412 """ if prime is None: prime = return_prime() if generator is None: generator = 2 q = (prime - 1) // 2 private_key = random.randrange(1, q) public_key = pow(generator, private_key, prime) return private_key, public_key
def gen_masterpwd(length=128, public=None): """ Generates a random masterkey password and optionaly encrypt it Keywords arguments: length -- The length of the masterkey password we want (default 128) public -- The public key file to use to encrypt the masterkey password (default None) """ items = string.printable.replace(' ', '') master = [] for i in range(length): master.append(items[rand.randrange(0, len(items))]) symbols = "".join(rand.sample(string.punctuation, 2)) master.append(symbols) master = "".join(master) if public is not None: try: pub_file = open(public, 'r') except Exception as err: log.error("[gen_masterpwd] {}".format(err)) else: pub_key = pub_file.read() rsa_key = rsa.importKey(pub_key) cipher = pkcs.new(rsa_key) try: ciph = cipher.encrypt(master.encode('utf-8')) except Exception as err: log.error("[gen_masterpwd] Error while encrypting the master password : {}".format(err)) else: return base64.b64encode(ciph) finally: pub_file.close() else: return master
for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop # Set the screen background screen.fill(BLACK) # Process each snow flake in the list for i in range(len(snow_list)): # Draw the snow flake pygame.draw.circle(screen, WHITE, snow_list[i], 2) # Move the snow flake down one pixel snow_list[i][1] += randrange(1,5) # If the snow flake has moved off the bottom of the screen if snow_list[i][1] > 400: # Reset it just above the top y = random.randrange(-50, -10) snow_list[i][1] = y # Give it a new x position x = random.randrange(0, 400) snow_list[i][0] = x # Go ahead and update the screen with what we've drawn. pygame.display.flip() clock.tick(20) # Be IDLE friendly. If you forget this line, the program will 'hang'
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, "1") 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)
def sign(self, data): # 2 <= K <= q K = random.randrange(2, self.priv.q) r, s = self.priv.sign(data, K) return long_to_bytes(r, 20) + long_to_bytes(s, 20)
#!/usr/bin/env python3 # Byte-at-a-time ECB decryption (harder) from base64 import b64decode from Crypto.Random.random import getrandbits, randrange from Crypto.Cipher import AES from m09 import pkcs7, de_pkcs7 from m11 import detect_ecb from m12 import blocksize RANDOM_KEY = bytes(getrandbits(8) for i in range(16)) RANDOM_PREFIX = bytes(getrandbits(8) for i in range(randrange(16))) def oracle(plaintext = b'', prefix = RANDOM_PREFIX): unknown_string = b64decode(open("data/12.txt", "r").read()) plaintext = pkcs7(prefix + plaintext + unknown_string, 16) cypher = AES.new(RANDOM_KEY, AES.MODE_ECB) return cypher.encrypt(plaintext) def decrypt(cyphertext): cypher = AES.new(RANDOM_KEY, AES.MODE_ECB) return de_pkcs7(cypher.decrypt(cyphertext)) def len_prefix(oracle): for i in range(32, 48): c = oracle(i * b'A') for b in range(len(c) // 16 - 1): if c[(b+1)*16:(b+2)*16] == c[(b+2)*16:(b+3)*16]: return 48 - i + 16 * b return 0
def generate_random_latitude(): """ creates a random coordinate """ return str(90 - float(random.randrange(10000000))/10000000 * 180)
def rndKey(self): intKey1 = random.randrange( 0xFFFFFFFFFFFFFFFF ) intKey2 = random.randrange( 0xFFFFFFFFFFFFFFFF ) self.__key = pack( '<QQ', intKey1, intKey2 ) self.__iv = Random.new().read( AES.block_size )
def test_encrypt_and_decrypt(self): s = long_to_bytes(randrange(2**1024)) secret = self.public_key.encrypt(s) length = len(s) self.assertEquals(s, self.private_key.decrypt(secret)[:length])
def test_invalid_decrypt(self): s = long_to_bytes(randrange(2**1024)) secret = self.public_key.encrypt(s) with self.assertRaises(Exception): self.private_key.decrypt(secret[:-1])
''' Created on Jan 25, 2016 @author: y2joshi ''' import sys, os import time from Crypto.Random.random import randrange if __name__ == '__main__': traceLength = int(sys.argv[1]) uniqueEvents = int(sys.argv[2]) noOfTraces = int(sys.argv[3]) traceDir = sys.argv[4] for i in range(0,noOfTraces): try: if not os.path.isdir(traceDir): os.makedirs(traceDir) outFile = open(traceDir + "/trace" + str(i),"w") outFile.write("traceTimes,traceEvents\n") for j in range(0,traceLength): evt = randrange(1,uniqueEvents+1,1) tm= time.time() outFile.write(str(tm)+","+str(evt)+"\n") #time.sleep(0.0005) finally: outFile.close()
def generate_random_longitude(): """ creates a random coordinate """ return str(180 - float(random.randrange(10000000))/10000000 * 360)