def start(): """ Start the application """ config_type = "DevelopmentConfig" if len(sys.argv) == 2: if sys.argv[1] == "dev": config_type = "DevelopmentConfig" elif sys.argv[1] == "test": config_type = "TestConfig" elif sys.argv[1] == "prod": config_type = "ProductionConfig" app = Flask(__name__) app.config.from_object("conf.config.%s" % config_type) app.secret_key = getRandomInteger(128) app.permanent_session_lifetime = timedelta(seconds=10) FORMAT = "%(asctime)s %(levelname)s: " "%(message)s [in %(pathname)s:%(lineno)d]" logging.basicConfig(filename=app.config["LOGFILE"], level=logging.DEBUG, format=FORMAT) PYSTHClient.init_controllers(app) @app.errorhandler(400) def bad_request(exception): """Bad Request""" data = dict(status=exception.code, error=str(exception), description=bad_request.__doc__) return jsonify(data), 400 @app.errorhandler(404) def page_not_found(exception): """Page Not Found""" data = dict(status=exception.code, error=str(exception), description=page_not_found.__doc__) return jsonify(data), 404 if app.config["DEBUG"] is True: @app.errorhandler(500) def error(exception): """Internal Server Error""" data = dict(status=exception.code, error=str(exception), description=error.__doc__) return jsonify(data), 500 @app.errorhandler(403) def forbidden(exception): """Forbidden""" data = dict(status=exception.code, error=str(exception), description=forbidden.__doc__) return jsonify(data), 403 # noinspection PyUnusedLocal @app.before_first_request def bootstrap(): """ Call the bootstrap function """ Bootstrap() with app.app_context(): Base.do_first_request() app.run(app.config["HOST"], app.config["PORT"])
def gen_proof(pk, u, esum, real, v): a = [] z = [] e = [] n = pk.n r = None for i in range(len(u)): if i != real: newz = pycrypto.getRandomInteger(PRIME_SIZE*2) newe = pycrypto.getRandomInteger(PRIME_SIZE) newa = (pow(newz, n, n * n) * pycrypto.inverse(pow(u[i], newe, n * n), n * n)) % (n * n) z.append(newz) e.append(newe) a.append(newa) else: r = pycrypto.getRandomInteger(PRIME_SIZE*2) newa = pow(r, n, n * n) a.append(newa) z.append(None) e.append(0) e[real] = (esum - sum(e)) % (pow(2, PRIME_SIZE)) z[real] = (r * pow(v, e[real], n * n)) % (n * n) return (u, a, e, z, esum)
def setup(fileName): # Create Strong prime and RSA modulus pPrime = number.getStrongPrime(1024) qPrime = number.getStrongPrime(1024) p = (pPrime-1)/ 2 q = (qPrime-1)/ 2 RSAn = p*q RSAN = pPrime * qPrime # Choose a generator of QR gPerp = generatorOfQR(RSAN) # Create Public Key xG = number.getRandomInteger(1023) xH = number.getRandomInteger(1023) xS = number.getRandomInteger(1023) xZ = number.getRandomInteger(1023) xR = number.getRandomInteger(1023) G = safePow(gPerp, xG, RSAN) H = safePow(gPerp, xH, RSAN) S = safePow(H, xS, RSAN) Z = safePow(H, xZ, RSAN) R = safePow(H, xR, RSAN) # Create Prime Order Group ( pGroup, qGroup, u) = createPrimeOrderGroup( pPrime, qPrime, RSAN) pubKey = publicKey() pubKey.set( RSAN, gPerp, G, H, S, Z, R, pGroup, qGroup, u) prvKey = privateKey() prvKey.set( pPrime, qPrime, RSAN, gPerp, G, H, S, Z, R, pGroup, qGroup, u) pubKey.write(fileName+".pubkey") prvKey.write(fileName+".prvkey")
def __init__(self, secret): self.z = hex(number.getRandomInteger(128)) self.q = hex(number.getPrime(128)) self.__K = secret self.coefficients = [] # Make sure key value is smaller than prime used for modulo while int(self.__K, 16) >= int(self.q, 16): self.q = hex(number.getRandomInteger(128))
def define_keys(): from Crypto.Util.number import getRandomInteger return ( getRandomInteger(32), getRandomInteger(32), getRandomInteger(32), os.urandom(100), )
def benchmark_with_input(): sizeP = int(input("select prime number size in bit: ")) p = number.getPrime(sizeP) q = number.getPrime(sizeP) print(f"using prime numbers \n p = {p} \n q = {q}") while 1: x = number.getRandomInteger(int(input("[x] base size in bit: "))) y = number.getRandomInteger(int(input("[y] exponent size in bit: "))) print(f"using base x = {x} \n exponent y = {y}") benchmark(x, y, p, q) cont = input("(q)uit or (c)ontinue?: ") if cont == "q": return
def getRandomInZ_N(N): """ Returns an integer in the group Z^*_n """ n_length = N.bit_length() if PYCRYPTO: rand = number.getRandomInteger(n_length, os.urandom) while (rand > N): rand = number.getRandomInteger(n_length, os.urandom) return rand else: raise NotImplementedError( "Couldn't find PyCrypto. No futher method implemented. Please install PyCrypto." )
def encrypt(pk, msg): while True: r = pycrypto.getRandomInteger(PRIME_SIZE * 2) if pycrypto.GCD(r, pk.n) == 1: break return ((pow(pk.g, msg, pk.n * pk.n) * pow(r, pk.n, pk.n * pk.n)) % (pk.n * pk.n), r)
def __init__(self): self.p = 99233 self.g = 99132 self.host = '127.0.0.1' self.port = 65432 self.private_key = number.getRandomInteger(self.p - 1) self.common_secret = ""
def get_root(index, p, k, c): # Find m such that m^index=c mod p^k # assert index < 1000 print("p = " + hex(p)) assert gmpy2.is_prime(p) assert p.bit_length() * k <= (2 << 16) n = p**k phi = (p**(k - 1)) * (p - 1) c %= n # First, split index into 2 parts, invert-able and un-invert-able. un_invert_able = gmpy2.gcd(index, phi) invert_able = index // un_invert_able while True: gcd = gmpy2.gcd(invert_able, phi) if gcd == 1: break invert_able //= gcd un_invert_able *= gcd assert invert_able * un_invert_able == index assert gmpy2.gcd(invert_able, phi) == 1 print(invert_able, un_invert_able) # Get rid of the invert-able part. d = gmpy2.invert(invert_able, phi) c2 = pow(c, d, n) assert pow(c2, invert_able, n) == c print("c2 = " + hex(c2)) # Next, find m such that m^un_invert_able=c2 mod p^k. Y = gmpy2.gcd(index, phi) X = phi // Y while True: gcd = gmpy2.gcd(X, un_invert_able) if gcd == 1: break X //= gcd Y *= gcd assert X * Y == phi assert gmpy2.gcd(un_invert_able + X, phi) == 1 print("X = 0x%x,\nY = %d" % (X, Y)) # Got a suitable Y. ans = set() counter = 0 while True: g = gmpy2.next_prime(getRandomInteger(p.bit_length()) % p) for i in range(Y): m_uninv_and_X = c2 * pow(g, i * phi // Y, n) % n assert pow(m_uninv_and_X, Y, n) == pow(c2, Y, n) m = pow(m_uninv_and_X, gmpy2.invert(un_invert_able + X, phi), n) if pow(m, un_invert_able, n) == c2: ans.add(m) counter += 1 if len(ans) >= un_invert_able or counter >= 10: break for m in ans: assert pow(m, index, n) == c return ans
def gen_key_pair(self, bit_length): if (bit_length % 2 != 0): raise ValueError("Bit length must be a multiple of 2") if (bit_length < 8): raise ValueError("Bit length must be at least 8 bits") bits_pq = bit_length / 2 self.n = 0 while (self.n.bit_length() != bit_length): self._gen_primes(bits_pq) self.n = self.p * self.q self.phi_n = (self.p - 1) * (self.q - 1) self.e = 0 while ((self.e <= 3) | (self.e >= self.phi_n) | (number.GCD(self.e, self.phi_n) != 1)): self.e = number.getRandomInteger(self.phi_n.bit_length()) self.d = number.inverse(self.e, self.phi_n) self.block_size = len(str(self.n)) #Initializing the CRT values self._init_crt()
def loop(self): self.socket_r, self.socket_w = yield from asyncio.open_connection( servidor, puerto, loop=self.main_loop) secreto = getRandomInteger(10) generado = pow(Cifrado.generador, secreto) % Cifrado.modulo self.socket_w.write( json.dumps({ 'gen-key': True, 'key': generado }).encode()) respuesta_servidor = yield from self.socket_r.read(100) respuesta_servidor = json.loads(respuesta_servidor.decode()) generado_servidor = respuesta_servidor['gen'] key = str(pow(generado_servidor, secreto) % Cifrado.modulo) key = Cifrado.normalizar_key(key) self.enigma = Cifrado.Enigma(key) while True: data = yield from self.socket_r.read(100) mensaje = self.enigma.decifrar(data) self.recibir_mensaje(mensaje)
def testing_full(i): print('running full test %d times' % i) bits = 128 for i in range(100): p = gmpy2.next_prime(2**(bits / 2)) q = gmpy2.next_prime(p) n = p * q n2 = n * n mbits = size(n) b = mbits // 2 k = getRandomRange(0, n) g = (1 + k * n) % n2 sk1 = LCM(p - 1, q - 1) sk2 = inverse(L(pow(g, sk1, n2), n), n) pt = getRandomInteger(bits - 1) ct = encrypt(pt, g, n, n2) assert decrypt(encrypt(pt, g, n, n2), sk1, sk2, n, n2) == pt print(pt) print(bin(pt)[2:]) low = recover_low_bits(LocalOracle(sk1, sk2, n, n2, b), n, n2, g, ct) print(low) high = recover_high_bits(int(low, 2), LocalOracle(sk1, sk2, n, n2, b), n, n2, g, ct) print(high) result = int(high + low, 2) print(result) assert result == pt
def sanity(): bits = 1024 p = getStrongPrime(bits / 2) q = getStrongPrime(bits / 2) n = p * q n2 = n * n k = getRandomRange(0, n) g = (1 + k * n) % n2 sk1 = LCM(p - 1, q - 1) sk2 = inverse(L(pow(g, sk1, n2), n), n) pt = getRandomInteger(bits - 1) ct = encrypt(pt, g, n, n2) mult = 123 ct20 = pow(ct, mult, n2) print(decrypt(ct20, sk1, sk2, n, n2) == (mult * pt) % n) divisor = 123 ct_2 = pow(ct, inverse(divisor, n), n2) print(divisor * decrypt(ct_2, sk1, sk2, n, n2) % n == pt) add = 123 ct_add = ct * encrypt(add, g, n, n2) print(decrypt(ct_add, sk1, sk2, n, n2) == (pt + add) % n) sub = 123 ct_sub = ct * encrypt(n - sub, g, n, n2) print(decrypt(ct_sub, sk1, sk2, n, n2) == (pt - sub) % n) ct_comb = pow(ct * encrypt(sub, g, n, n2), mult, n2) print(decrypt(ct_comb, sk1, sk2, n, n2) == (mult * (pt + sub)) % n) ct_comb2 = pow(ct, mult, n2) * encrypt(sub, g, n, n2) print(decrypt(ct_comb2, sk1, sk2, n, n2) == (mult * pt + sub) % n)
def generateKeys(security_level = 1): prime_size, random_size = 0, 0 if security_level == 1: prime_size, random_size = 160, 864 elif security_level == 2: prime_size, random_size = 224, 1824 elif security_level == 3: prime_size, random_size = 256, 2816 else: return q = number.getPrime(prime_size) k = number.getRandomInteger(random_size) p = k * q + 1 while utils.rm_primality(p) != True: k = utils.gen_random(random_size) p = k * q + 1 a = number.getRandomRange(0, p) g = utils.mod_exp(a, (p - 1) / q, p) while g == 1: a = number.getRandomRange(0, p) g = utils.mod_exp(a, (p - 1) / q, p) x = number.getRandomRange(1, q - 2) y = utils.mod_exp(g, x, p) return p, q, g, x, y
def p39() -> str: m = getRandomInteger(31) rsa = RSA(bitsize=32) print(f'Initialized 32 bit RSA: e = {rsa.e}, N = {rsa.N}') c = rsa.enc(m) print(f'Enc({m}) = {c}') return f'Dec({c}) = {rsa.dec(c)}'
def DSAGenParameter(): print "Génération des paramètres" # On génère Q print "Génération de Q" q = number.getPrime(160) print "Q généré" # On génère P print "Génération de P" while True: r = number.getRandomInteger(480) p = (q*r)+1 if number.isPrime(p): break print "P généré" # On génère G print "Génération de G" while True: y = number.getRandomRange(0, p) g = pow(y, (p-1)/q, p) if g != 1: break print "G généré" print "Paramètres générés" return p, q, y, g
def commonModAttack(e, d, n): ''' Algorithm (explained in class) to recover the primes p and q given the key pair ''' from math import log2 r = e * d - 1 t = 0 while not r & 1: t += 1 r = r >> 1 numberOfAttempts = 1 while True: g = number.getRandomInteger(int(log2(n))) p = number.GCD(g, n) if p > 1: print("Hurry up to Vegas? It's your lucky day!") return p, div(n, p)[0] x = modexp(g, r, n) x2 = modprod(x, x, n) while x2 != 1: x = x2 x2 = modprod(x, x, n) p = number.GCD(x - 1, n) if p > 1: print("Success after {} attempts".format(numberOfAttempts)) return p, div(n, p)[0] numberOfAttempts += 1
def __cipher_AES(): key = b'Very long and co' nonce = number.getRandomInteger(128) ctr = Counter.new(128, initial_value=nonce) cipher = AES.new(key, AES.MODE_CTR, counter=ctr) return cipher, bytes(str(nonce), 'utf-8')
def verify_good_num(e, n, d): for i in range(10): m = getRandomInteger(int(math.log2(n))) check_m = mod_exp_itr(mod_exp_itr(m, e, n), d, n) if check_m != m: return False return True
def send_challenges(): code = marshal.loads( "63000000000d000000070000004300000073df010000740000721d0064010064020015000000000100640200157d00006e00007401007d01007c0100640300157d02006402007d0300786f007c03006a02008300007c01006b030072a400784c007403007296007404006a05007c02008301007d04007404006a05007c02008301007d05007406007c04007c0500188301006a02008300007c0100640400146b0400724b0050714b00714b00577c04007c0500147d0300713600577c0400640500187c050064050018147d06006406007d07006407007d080078090174030072ce017404006a07007408006403007409007c01007c0700148301008302007408006403007409007c01007c070014830100640500178302008302007d09007871007c09006a02008300007c01007c0800146b0000727b016402007d0a007844007404006a0a007c0a00830100736d017404006a0700740800640300640800830200740800640300640800830200740800640300640900830200178302007d0a00712a01577c09007c0a00397d0900710b01577404006a0b007c09007c06008302006405006b0300729a0171c6006e00007404006a0c007c09007c06008302007d0b007404006a0b007c0b007c06008302006405006b030072ca0171c6006e00005071c60057640a007d0c007c03007c0b0066020053280b0000004e690700000069000000006902000000675839b4c876bedf3f6901000000674e62105839b4d03f678d976e1283c0d23f692d000000690c0000006903000000280d000000740500000046616c736574050000004e53495a45740a0000006269745f6c656e67746874040000005472756574060000006e756d626572740e0000006765745374726f6e675072696d657403000000616273740e00000067657452616e646f6d52616e67657403000000706f777403000000696e74740700000069735072696d6574030000004743447407000000696e7665727365280d00000074010000007874050000004e73697a657406000000707173697a6574010000004e740100000070740100000071740300000070686974060000006c696d69743174060000006c696d697432740100000064740300000070707074010000006574030000007a7a7a2800000000280000000073150000002f6f726967696e616c6368616c6c656e67652e7079740a0000006372656174655f6b657917000000733e000000000106010a010d0206010a010601150109010f010f04200108010e0112020601060109013c0119010601120135020e011801060112011801060105020604" .decode("hex")) create_key = types.FunctionType(code, globals(), "create_key") ck = create_key challenges = [] for _ in xrange(NCHALLENGES): n, e = ck() v = number.getRandomInteger(NSIZE - 1) challenges.append((n, e, v)) ctime = int(time.time()) for c in challenges: n, e, v = c print n print e print v print ctime sys.stdout.flush() tohmac = repr((challenges, ctime)) hm = hmac.new(secret.hmackey, msg=tohmac, digestmod=hashlib.sha256) print hm.hexdigest() sys.stdout.flush()
def encrypt(pk, msg): n, g = pk assert 0 <= msg < n, 'invalid message' while True: r = getRandomInteger(n.bit_length() * 2) if GCD(r, n) == 1: break n2 = pow(n, 2) return (pow(g, msg, n2) * pow(r, n, n2)) % n2
def encrypt(self, data): key = long_to_bytes(getRandomInteger(128)) encryptor = AES.new(key, AES.MODE_CBC) length = len(data) if length % 16 != 0: data += ' ' * (16 - length % 16) ciphertext = encryptor.encrypt(data) (cryptkey, ) = self.rsa.encrypt(key, None) encrypted = pickle.dumps((cryptkey, length, ciphertext)) return b64encode(encrypted)
def generate(self, p, q): self.p = p self.q = q self.N = p * q phi = (p-1) * (q-1) while True: e = getRandomInteger(40) if GCD(e, phi) == 1: self.e = e self.d = inverse(e, phi) return
def run(self): g = 5 p = number.getStrongPrime(512) s = number.getRandomInteger(512) public = modExp(g, s, p) print "p= " + str(p) print "s= " + str(s) print "public= " + str(public) gtp = int(raw_input("g^t mod p: ")) key = modExp(gtp, s, p) print "key= " + str(key)
def getShares(target, n, k): coefs = [] shares = [] for i in range(k - 1): coefs.append(number.getRandomInteger(8)) coefs.append(target) # secret is f(0) npoly = np.poly1d(coefs) print npoly print "Secret is", npoly(0) for i in range(1, n): shares.append((i, npoly(i))) return shares
def send_messages(self, m_list): self.msgs = cPickle.loads(m_list) n = 0 req_msg = [] rnd = number.getRandomInteger(5, self.rng) rnd = rnd%9 self.msg_no = rnd while n<10: if (n != rnd): req_msg.append(n) n = n+1 return req_msg
def make_key(k): while True: r = getRandomInteger(k) << 2 p, q = r ** 2 + r + 1, r ** 2 + 3 * r + 1 if gmpy2.is_prime(p) * gmpy2.is_prime(q): break print(r) pubkey = r ** 6 + 5 * r ** 5 + 10 * r ** 4 + 13 * r ** 3 + 10 * r ** 2 + 5 * r + 1 # (r^2 + r + 1)^2 * (r^2 + 3*r + 1) # pubkey = p^2*q print(int(gmpy2.iroot(pubkey, 6)[0])) return pubkey
def decrypt_proof(pk, sk, cipher, chall): n = pk.n msg = paillier.decrypt(pk, sk, cipher) rn = (cipher * pycrypto.inverse(pow(pk.g, msg, n * n), n * n)) % (n * n) r = pow(rn, pycrypto.inverse(n, sk.l), n * n) # generates bogus if r^n not nth power a = pycrypto.getRandomInteger(PRIME_SIZE * 2) an = pow(a, n, n * n) z = a * pow(r, chall, n * n) return (an, z)
def verify(): print "Proof of Work" prefix = long_to_bytes(getRandomInteger(32)) print "Prefix: %s" % prefix.encode('base64') try: suffix = raw_input() s = suffix.decode('base64') except: MyExit(-1) r = sha512(prefix + s).hexdigest() if "ffffff" not in r: MyExit(-1)
def create_prime(p_bit_len, add_bit_len, a): #1024 9 23 p = getPrime(p_bit_len) #1024 p_bit_len2 = 2 * p_bit_len // 3 + add_bit_len #691 while True: b = getRandomInteger(p_bit_len2) #691 _p = a * p #23 * p q = _p**2 + 3 * _p * b + 3 * b**2 if isPrime(q): print('b =', b) print('q = ', q) print('_p = ', _p) print('p =', p) return p, q
def createPrimeOrderGroup(pPrime, qPrime, MOD): while(1): q = number.getPrime(qGroupBit) r = 0 for i in range(10000000): r = number.getRandomNBitInteger(pGroupBit-qGroupBit) p = (r*q+1) % MOD if(number.isPrime(p)): u = number.getRandomInteger(nBit) u1 = safePow(u,p-1,MOD) qInv = number.inverse( q, (pPrime-1)*(qPrime-1)) u2 = safePow(u1,qInv,MOD) if(u2 != 0): return ( q, p, u)
def gen_keys(): p = pycrypto.getPrime(PRIME_SIZE) q = pycrypto.getPrime(PRIME_SIZE) n = p * q l = ((p-1) * (q-1))//pycrypto.GCD(p-1,q-1) while True: g = pycrypto.getRandomInteger(PRIME_SIZE * 4) % (n * n) if pycrypto.GCD(g,n) == 1: c = (pow(g, l, n * n) - 1)//n if pycrypto.GCD(c, n) == 1: mu = pycrypto.inverse(c, n) break return PublicKey(n,g), PrivateKey(l, mu)
def gen_keys(): p = pycrypto.getPrime(PRIME_SIZE) q = pycrypto.getPrime(PRIME_SIZE) n = p * q l = ((p - 1) * (q - 1)) // pycrypto.GCD(p - 1, q - 1) while True: g = pycrypto.getRandomInteger(PRIME_SIZE * 4) % (n * n) if pycrypto.GCD(g, n) == 1: c = (pow(g, l, n * n) - 1) // n if pycrypto.GCD(c, n) == 1: mu = pycrypto.inverse(c, n) break return PublicKey(n, g), PrivateKey(l, mu)
def gen_key(bits=2048): x = RSA.generate(bits) n = x.n n2 = pow(n, 2) while True: g = getRandomInteger((n.bit_length() * 2) - 1) lm = ((x.p - 1) * (x.q - 1)) // GCD(x.p - 1, x.q - 1) glm = pow(g, lm, n2) a = (glm - 1) // n if GCD(a, n) == 1: mu = inverse(a, n) public_key = (n, g) secret_key = (lm, mu) return public_key, secret_key
def encrypt(self, data): from Crypto.Cipher import AES from Crypto.Hash import HMAC, SHA512 from Crypto.Util import Counter, number initial_value = number.getRandomInteger(128) counter = Counter.new(128, initial_value=initial_value) cipher = AES.new(self.enc_key, AES.MODE_CTR, counter=counter) encrypted = cipher.encrypt(data) protected_data = ('%032x' % initial_value) + encrypted mac = HMAC.new(self.mac_key, msg=protected_data, digestmod=SHA512) digest = mac.digest() return digest + protected_data
def data_received(self, data): if self.estado == 'no-key': mensaje = json.loads(data.decode()) if mensaje['gen-key']: generado_cliente = mensaje['key'] if generado_cliente: secreto = getRandomInteger(10) key = str(pow(generado_cliente, secreto) % Cifrado.modulo) generado = pow(Cifrado.generador, secreto) % Cifrado.modulo key = Cifrado.normalizar_key(key) self.estado = 'key-ready' self.enigma = Cifrado.Enigma(key) self.transport.write(json.dumps({'gen': generado}).encode()) elif self.estado == 'key-ready': # Aqui enviamos el mensaje a todos los clientes conectados self.propagar('{}: {}'.format(self.nombre_cliente, self.enigma.decifrar(data)))
def loop(self): self.socket_r, self.socket_w = yield from asyncio.open_connection(servidor, puerto, loop=self.main_loop) secreto = getRandomInteger(10) generado = pow(Cifrado.generador, secreto) % Cifrado.modulo self.socket_w.write(json.dumps({'gen-key': True, 'key': generado}).encode()) respuesta_servidor = yield from self.socket_r.read(100) respuesta_servidor = json.loads(respuesta_servidor.decode()) generado_servidor = respuesta_servidor['gen'] key = str(pow(generado_servidor, secreto) % Cifrado.modulo) key = Cifrado.normalizar_key(key) self.enigma = Cifrado.Enigma(key) while True: data = yield from self.socket_r.read(100) mensaje = self.enigma.decifrar(data) self.recibir_mensaje(mensaje)
#!/usr/bin/python3.2 # -*-coding:Utf-8 -* from Crypto.Util import number """ Test de la librairie Crypto Un premier aléatoire de 512 bits sera-t-il toujours plus petit qu'un premier aléatoire de 511 bits ? EDIT : Retourne faux """ if __name__ == '__main__': #On teste un grand nombre de fois pour être sûr for i in range(20000): a = number.getRandomInteger(512) b = number.getRandomInteger(511) if a<b: print "FAUX !", i break;
from Crypto.Util import number if __name__ == '__main__': print('hello world with', number.getRandomInteger(4))
' numbers will be, [default=2048]') parser.add_option('-e', '--secret', dest='secret', default=512, help='Set how many bits long the secret number will' ' be [default=512]') options, args = parser.parse_args() alpha_tog = options.alpha beta_tog = options.beta verbose = options.verbose size = int(options.size) secret = int(options.secret) if alpha_tog is True and beta_tog is True: print("[!] Error: can't set both alpha and beta use one per instance") exit(1) try: if alpha_tog is True: a = getRandomInteger(secret) # This needs to be large, at least 512bit p = getStrongPrime(size) g = getStrongPrime(size) alpha = Alpha(p, g, a, verbose) alpha.exchange() alpha.output() exit() elif beta_tog is True: # b = get_random(size) b = getRandomInteger(secret) # This needs to be large, at least 512bit beta = Beta(b, verbose) beta.exchange() beta.output() exit() except PermissionError:
def encrypt(pk, msg): while True: r = pycrypto.getRandomInteger(PRIME_SIZE * 2) if pycrypto.GCD(r,pk.n) == 1: break return ((pow(pk.g, msg, pk.n * pk.n) * pow(r, pk.n, pk.n * pk.n)) % (pk.n * pk.n), r)
from Crypto.Util.number import getRandomInteger from datetime import timedelta from apscheduler.scheduler import Scheduler from werkzeug.contrib.fixers import ProxyFix from flask import Flask from flask import jsonify from conf.base import Base from conf.boostrap import Bootstrap from services.user_data_service import UserDataService CONFIG_TYPE = 'ProductionConfig' APP = Flask(__name__) APP.config.from_object('conf.config.%s' % CONFIG_TYPE) APP.secret_key = getRandomInteger(128) APP.permanent_session_lifetime = timedelta(seconds=10) #Imports all controllers and register pages CONTROLLERS = [] for controller in os.listdir(os.getcwd() + "/controllers"): module_name, ext = os.path.splitext(controller) if module_name.endswith('_controller') and ext == '.py': module = __import__("controllers.%s" % module_name) CONTROLLERS.append(module.__getattribute__(module_name)) for controller in CONTROLLERS: APP.register_blueprint(controller.PAGE) logging.basicConfig( filename=APP.config["LOGFILE"], level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s '
def generateSecret(self,Nbits): tmpRand = number.getRandomInteger(Nbits) h = HMAC.new(str(self.N)) h.update(str(tmpRand)) return h.hexdigest()