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