def calc_k():
"""
Calcula la k, que es k = H(N, g) donde H es cualquier funcion de Hash
en este caso hash. Para obtenerla con los valores estandard de N, x y g se tendria
que usar una funcion sha1 modificada que no esta disponible para python.
Se usa para el calculo el algoritmo de http://srp.stanford.edu/demo/demo.html
Retorna un entero grande.
"""
nhex = dec2hex(N)
hashin = ""
if ((len(nhex) & 1) == 0):
hashin += nhex
else:
hashin += "0" + nhex
ghex = dec2hex(g)
hashin += "0" * (len(nhex) - len(ghex))
hashin += ghex
ktmp = hex2dec(hash.hexdigest(hashin.upper()))
if (ktmp < N):
return ktmp
else:
return ktmp % N
def calc_x(s, p):
"""
Calcula la x, en este caso x = H(salt,pass), siendo H hash.
Se usa el algoritmo de http://srp.stanford.edu/demo/demo.html, pero se
aplica una combinacion interna diferente del hash.
s y p son los strings correspondientes a salt y password. Siempre se usaran en
mayusculas.
Retorna un entero grande.
"""
hashin = dec2hex(s).upper() + p
xtmp = hex2dec(hash(hashin))
if (xtmp < N):
return xtmp
else:
return xtmp % (N - 1)
def calc_u(A, B, N):
"""
Calcula u = H(A, B) [SRP-6a].
Usamos el algoritmo de http://srp.stanford.edu/demo/demo.html
"""
hashin = ""
ahex = dec2hex(A)
bhex = dec2hex(B)
## Size in bits of N
Ns = len(dec2bin(N))
nlen = 2 * ((Ns + 7) << 3)
hashin += "0" * (nlen - len(ahex)) + ahex
hashin += "0" * (nlen - len(bhex)) + bhex
utmp = hex2dec(hash(hashin.upper()))
if (utmp < N):
return utmp
else:
return utmp % N
def SRP_Auth_2(req, data):
"""
Acaba de hacer los calculos de la clave de sesion y hace la comprobacion de la
clave de sesion que envia el usuario (segun el protocolo el usuario ha de ser el
primero en enviar, si no corresponden abortar).
"""
#~ try:
## Recuperar K
data = JSONDecoder("UTF-8").decode(data)
Mc = data["M"]
## Recuperar las variables de la sesion
cryptovars = retrieve_crypto_vars(req)
B = cryptovars["B"]
v = cryptovars["v"]
b = cryptovars["b"]
A = cryptovars["A"]
user = cryptovars["user"].upper()
salt = cryptovars["salt"].upper()
## u = H(A, B)
u = calc_u(A, B, N)
u = hex2dec(hash(dec2hex(A) + dec2hex(B)))
## S = (Av^u) ^ b
S = powMod(A * powMod(v, u, N), b, N)
## Clave de sesion K = H(S)
K = hash(dec2hex(S).upper()).upper()
## Comprobar que la prueba del cliente es igual a lo que tenemos nosotros
## M = H(H(N) xor H(g), H(I), s, A, B, K)
HN = hex2dec(hash(dec2hex(N)))
Hg = hex2dec(hash(dec2hex(g)))
HI = hash(user).upper()
innerhash = dec2hex(
(HN ^ Hg)).upper() + HI + salt + dec2hex(A) + dec2hex(B) + K
Mc_s = hash(innerhash).upper()
## si no coincide lo que calculamos nosotros con lo que nos envian... nanay
if (Mc != Mc_s):
rdata = {
"status": "FAILED"
}
req.write(JSONEncoder("UTF-8").encode(rdata))
else:
## Si son iguales enviamos nuestra prueba al cliente
## Generar la prueba del servidor
Ms = hash(dec2hex(A) + Mc + K)
## Hacer efectivo el login en el servidor y emitir cookie si es necesario
session_login(req)
if (data["remember"] == "yes"):
message = createLoginCookie(req, req.session['SRP_crypto']['user'])
if message != "OK":
rdata = {
"status": message
}
## Guardar la clave de sesion y proceder a la comprobacion por parte del cliente
rdata = {
"M": Ms.upper(),
"status": "OK"
}
req.write(JSONEncoder("UTF-8").encode(rdata))
#~ except:
#~ rdata = {"status": "Second auth step failed."};
#~ req.write(JSONEncoder("UTF-8").encode(rdata))
## Todo completado, eliminar la info de la variable de sesion
delete_crypto_vars(req)
def SRP_Auth_1(req, data):
"""
Primer paso del protocolo para el servidor
Recibe diccionario con :
username: String con el username
A: Bigint string -> A = g ^a donde a es un bigint al azar
"""
try:
session = req.session
session.lock()
if session.has_key("logged"):
if session["logged"]:
rdata = {
"status": "Already logged in."
}
req.write(JSONEncoder("UTF-8").encode(rdata))
return
session.unlock()
data = JSONDecoder("UTF-8").decode(data)
## recogemos A
A = hex2dec(data["A"])
## Abortar si A%N == 0
if (A % N == 0):
rdata = {
"status": "Server step 1 failed."
}
req.write(JSONEncoder("UTF-8").encode(rdata))
## Conectar
db = MySQLdb.connect(host="localhost",
user="******",
passwd="1234",
db="prueba")
## Preparar transaccion
sql = """
SELECT *
FROM usuarios
WHERE userName = "******"
""" % (data['username'])
cursor = db.cursor()
cursor.execute(sql)
resultado = cursor.fetchall()
## Desconectar
db.close()
user_id = None
## Asegurarse que no hay mas de un resultado
if len(resultado) > 1:
rdata = {
"status": "Server step 1 failed: Duplicated username!."
}
req.write(JSONEncoder("UTF-8").encode(rdata))
return
else:
if len(resultado) == 0:
rdata = {
"status": "No existe el usuario."
}
req.write(JSONEncoder("UTF-8").encode(rdata))
return
else:
user_id = resultado[0][0]
## Devuelve el salt (2a columna) y B
## k = H(N, g)
## Si se ha de calcular k, lo podemos hacer aqui
dbsalt = resultado[0][3]
dbv = resultado[0][2]
v = hex2dec(dbv)
salt = hex2dec(dbsalt)
## b es un numero al azar de como maximo 32 bytes
random.seed()
b = random.getrandbits(256)
## B= kv + g^b (mod N)
kv = k * v
gb = powMod(g, b, N)
B = (kv + gb) % N
rdata = {
"salt": dbsalt.upper(),
"B": dec2hex(B).upper(),
"status": "OK"
}
req.write(JSONEncoder("UTF-8").encode(rdata))
## Create crypto data structure
cryptovars = {
"A": A,
"B": B,
"v": v,
"b": b,
"user": data['username'],
"salt": dbsalt.upper(),
"user_id": user_id
}
save_crypto_vars(req, cryptovars)
except:
rdata = {
"status": "Server step 1 failed."
}
req.write(JSONEncoder("UTF-8").encode(rdata))
def session_login(req):
"""
Poner el flag de log in en la sesion.
"""
session = req.session
session.lock()
session['logged'] = True
session['user_id'] = session['SRP_crypto']['user_id']
session.save()
session.unlock()
if __name__ == '__main__':
print "TESTING with http://srp.stanford.edu/demo/demo.html params"
salt = hex2dec("b91241183b637f4ece1a")
x = hex2dec("9c1c8f38b23abb059bbe31bdaf7f3564d8e47203")
v = powMod(g, x, N)
print "v: " + dec2hex(v)
## Client
a = hex2dec(
"412eebb52ed5addf78c28bc0c4311cbe32d7759975ae97caaad360fc2a095cd")
A = powMod(g, a, N)
print "A: " + dec2hex(A)
## Server
b = hex2dec(
"581d1c0c7b7539ad85be1ba8231d132deeb3fa2776fb870002bb59fea33247d9")
kv = k * v
gb = powMod(g, b, N)