def read_secure_cookie(self, cookie_name):
"""read_secure_cookie(str) -> return(str)
Verifies whether the user cookie has not
been tampered with. Returns the cookie
else returns False
"""
cookie_val = self.request.cookies.get(cookie_name)
return cookie_val and Secure.check_secure_val(cookie_val)
def __init__(self, host, port, passwd, limit=0, buffer=1000*1000*100, repeat=1): """# Explicacion rapida: # host: La direccion a la cual conectarse o usar (En el caso del servidor) # port: El puerto donde se enviaran o recibir los datos de la conexion # passwd: La contrasena que se usara para encriptar y desencriptar los datos # limit: El limite de conexiones permitidas en el caso de que se use el servidor # buffer: El limite de flujo de datos. # repeat: Las repeticiones de encriptacion de un dato. Mientras mas repeticiones mas lento sera el proceso.""" self.host = str(host) self.port = int(port) self.limit = int(limit) self.buffer = int(buffer) self.event = socket.socket() self.serverSettingsConf = False self.crypter = Secure(passwd, repeat) self.list = [] self.start = False self.server_data_decrypted = [] self.client_data_decrypted = []
def login(self, user, password):
# Takes a user and a password checks if it is correct.
# If so stores it in google appengine db and uses the
# obj id returned from the database as cookie val
usr_obj = Secure.check_passwd(user.lower(), password, Users) # takes str, str, obj (google appengine)
if usr_obj:
cookie_val = self.make_cookie(str(usr_obj.key().id())) # get the int val for the val
self.set_cookie("user_id", cookie_val)
self.redirect("/blog/newpost")
else:
self.error("Invalid login")
def post(self):
"""retreive the responses from the user"""
self.user_name = Secure.valid_username(self.request.get("username"))
self.passwd = Secure.valid_passwd(self.request.get("password"))
self.email = self.request.get("email")
if not (self.user_name and self.passwd):
msg = "username cannot be empty"
msg2 = "password cannot be empty"
self.errors(name_error=msg, passwd_error=msg2)
else:
if self.passwd.group() != self.request.get("verify"):
msg = "Password do not match"
self.errors(name=self.user_name.group(), passwd_error=msg, passwd2_error=msg)
else:
if self.email and not Secure.valid_email(self.request.get("email")):
self.errors(name=self.user_name.group(), email_error="email incorrect format")
elif self.email:
self.done()
else:
self.done()
def done(self):
username = self.user_name.group().lower()
# Check if user already exists.
if Users.by_name(username):
self.errors(name_error="User already exists")
else:
password = self.passwd.group()
email = None
if self.email:
email = self.email
# hash the password before storing in database
passwd_hash = Secure.make_salt_password(username, password)
# Add the user, hashed password or email to the database
usr_obj = Users.add(username, passwd_hash, email)
cookie_val = self.make_cookie(str(usr_obj.key().id()))
self.set_cookie("user_id", cookie_val)
self.redirect("/blog/newpost")
def make_cookie(self, val):
"""makes a secure hash cookie"""
return Secure.make_secure_val(val)
class Connection:
def __init__(self, host, port, passwd, limit=0, buffer=1000*1000*100, repeat=1):
"""# Explicacion rapida:
# host: La direccion a la cual conectarse o usar (En el caso del servidor)
# port: El puerto donde se enviaran o recibir los datos de la conexion
# passwd: La contrasena que se usara para encriptar y desencriptar los datos
# limit: El limite de conexiones permitidas en el caso de que se use el servidor
# buffer: El limite de flujo de datos.
# repeat: Las repeticiones de encriptacion de un dato. Mientras mas repeticiones mas lento sera el proceso."""
self.host = str(host)
self.port = int(port)
self.limit = int(limit)
self.buffer = int(buffer)
self.event = socket.socket()
self.serverSettingsConf = False
self.crypter = Secure(passwd, repeat)
self.list = []
self.start = False
self.server_data_decrypted = []
self.client_data_decrypted = []
def client(self):
"""
Se conecta al socket de la direccion y el puerto que usted especifique.
"""
self.event = socket.socket()
try:
self.event.connect((self.host, self.port))
except socket.error:
raise connectError("Error conectando al socket en la direccion especificada.")
def client_interact(self, data, client):
"""
Envia datos hacia un socket que este conectado en el servidor a traves de una direccion especifica.
"""
encryptedata = self.crypter.encrypt(data)
length_encrypedata = str(len(encryptedata))
try:
self.client_connection.sendto(length_encrypedata+" "+encryptedata, client)
except socket.gaierror:
raise unknownAddr(unknownaddr_message)
def server_interact(self, data):
"""
Envia datos hacia el servidor de el socket este conectado.
"""
encryptedata = self.crypter.encrypt(data)
length_encrypedata = str(len(encryptedata))
self.event.send(length_encrypedata+" "+encryptedata)
def client_sendfile(self, file, client):
"""
Envia el contenido de un archivo especificado a traves de un socket en una direccion especifica.
"""
readfile = open(file, "rb")
self.client_interact(readfile.read(), client)
readfile.close()
def server_sendfile(self, file):
"""
Envia el contenido de un archivo especificado a traves de un socket hacia el servidor.
"""
readfile = open(file, "rb")
self.server_interact(readfile.read())
readfile.close()
def client_buffer_interact(self, data, client):
"""
Este metodo se comunica con el metodo 'client_buffer_recv'.
Envia datos a un socket con una direccion especifica y los almacena en un buffer con datos relevantes.
"""
host, port = self.client_connection.getsockname()
origin = host+":"+str(port)
encryptedata = self.crypter.encrypt(dumps({"origin":origin, "content":data.encode("hex"), "length":len(data)}))
length_encrypedata = str(len(encryptedata))
try:
self.client_connection.sendto(length_encrypedata+" "+encryptedata, client)
except socket.gaierror:
raise unknownAddr(unknownaddr_message)
def server_buffer_interact(self, data):
"""
Este metodo se comunica con el metodo 'server_buffer_recv'.
Envia datos a un socket conectado al servidor y los almacena en un buffer con datos relevantes. Este metodo se conecta al socket del servidor cada vez que envia datos.
"""
self.client()
host, port = self.event.getsockname()
origin = host+":"+str(port)
encryptedata = self.crypter.encrypt(dumps({"origin":origin, "content":data.encode("hex"), "length":len(data)}))
length_encrypedata = str(len(encryptedata))
self.event.send(length_encrypedata+" "+encryptedata)
def server_recv(self):
"""
Espera el contenido enviado a traves de un socket que este conectado hacia el servidor, para posteriormente retornarlo.
Este metodo se comunica con el metodo 'server_interact'.
"""
server_data = ''
repetir = True
while True:
try:
data = self.event.recv(self.buffer)
if (repetir):
repetir = False
longitud = int(data.split()[0])
server_data += data.replace(data.split()[0]+" ", "")
else:
server_data += data
longitud_a_sumar = int(len(server_data))
if (longitud == longitud_a_sumar):
return self.crypter.decrypt(server_data)
except:
raise corruptData(corruptdata_message)
def client_recv(self):
"""
Espera el contenido enviado a traves de un socket que este conectado hacia un cliente, para posteriormente retornarlo.
Este metodo se comunica con el metodo 'server_interact'.
"""
show_error(int(len(self.client_list())), 3)
show_error(self.serverSettingsConf, 1)
client_data = ''
repetir = True
while True:
try:
data = self.client_connection.recv(self.buffer)
if (repetir):
repetir = False
longitud = int(data.split()[0])
client_data += data.replace(data.split()[0]+" ", "")
else:
client_data += data
longitud_a_sumar = int(len(client_data))
if (longitud == longitud_a_sumar):
return self.crypter.decrypt(client_data)
except:
raise corruptData(corruptdata_message)
def server_buffer_recv(self, stop=False):
"""
Recibe los datos que un servidor le envia a un cliente a traves de un socket para almacenarlo en un buffer con datos relevantes y especificos.
El parametro stop: Si el argumento es 'False', no parara de recibir y almacenar datos. Si esta el 'True' cuando reciba un datos de un cliente terminara el bucle.
"""
self.client()
def server_receive():
server_data = ''
repetir = True
while True:
try:
data = self.event.recv(self.buffer)
if (repetir):
repetir = False
longitud = int(data.split()[0])
server_data += data.replace(data.split()[0]+" ", "")
else:
server_data += data
longitud_a_sumar = int(len(server_data))
if (longitud == longitud_a_sumar):
self.server_data_decrypted.append(server_data)
if (stop):
break
else:
server_data = ''
repetir = True
except:
raise corruptData(corruptdata_message)
output = thread.start_new_thread(server_receive, ())
def server(self, buffer=True):
"""
Inicia el servidor esperando conexiones.
El parametro buffer: Si el argumento es 'True', recibira datos y los almacenara en un buffer con datos relevantes y especificos. Util a la hora de comunicarse con otros metodos: ej: 'server_buffer_interact'. Si esta en 'False' entonces solo esperara las conexiones.
"""
show_error(self.start, 2)
def start_with_thread():
self.start = True
level = 0
repetir = True
client_data = ''
self.serverSettingsConf = True
self.event = socket.socket()
self.event.bind((self.host, self.port))
self.event.listen(self.limit)
while True:
if (self.limit > 0):
level += 1
self.client_connection, client = self.event.accept()
self.list.append(client)
if (buffer):
try:
data = self.client_connection.recv(self.buffer)
if (repetir):
repetir = False
longitud = int(data.split()[0])
client_data += data.replace(data.split()[0]+" ", "")
else:
client_data += data
longitud_a_sumar = int(len(client_data))
if (longitud == longitud_a_sumar):
self.client_data_decrypted.append(client_data)
client_data = ''
repetir = True
#if (not self.limit == 0 and level == self.limit):
# break
except:
raise corruptData(corruptdata_message)
output = thread.start_new_thread(start_with_thread, ())
def client_list(self):
"""
retorna la lista de clientes que se han conectado. Nota: No se puede determinar si el cliente ya no esta conectado!.
"""
return self.list
def server_buffer_print(self):
"""
Desencripta y descodifica los datos que se almacenan en el buffer que se han enviado a traves del socket del servidor hacia el cliente.
"""
output = []
for i in self.server_data_decrypted:
output.append(loads(self.crypter.decrypt(i)))
output_decode = []
for i in output:
origin = str(i['origin'])
content = str(i['content'].decode("hex"))
length = int(i['length'])
output_decode.append({"origin":origin, "length":length, "content":content})
return output_decode
def client_buffer_print(self):
"""
Desencripta y descodifica los datos que se almacenan en el buffer que se han enviado a traves del socket del cliente hacia el servidor.
"""
show_error(self.serverSettingsConf, 1)
output = []
for i in self.client_data_decrypted:
output.append(loads(self.crypter.decrypt(i)))
output_decode = []
for i in output:
origin = str(i['origin'])
content = str(i['content'].decode("hex"))
length = int(i['length'])
output_decode.append({"origin":origin, "length":length, "content":content})
return output_decode