def __decryptData(self, data):
try:
data = hibrid.decrypt(data, self.__rsa.export_PrivateKey())
self.__init_uniqkey = str(data[-1])
if not (self.use_nodes == False):
secundaryData = hibrid.decrypt(data[1], self.__secundaryRSA.export_PrivateKey())
_use_nodes_bak = self.use_nodes
self.use_nodes = False
obj = wrap.getall(wrap.USE_NODE_INFO)['nodes']
self.updateNode(_use_nodes_bak, hibrid.encrypt(secundaryData[-1], obj[_use_nodes_bak][0]), -1, 3)
self.use_nodes = _use_nodes_bak
return(secundaryData)
except KeyError:
raise ValueError('No hay información alamacenada de forma local')
except ValueError:
raise requestError('Error descodificando los datos! ...')
else:
return(data)
def extract():
result = []
for _ in show_user_admins.show():
_data = wrap.getall(wrap.USE_ADMIN, username=_, separate=True)
for _ in _data:
result.append(_) if (_data[_]['root'] == True) else None
return (result)
wrap.db_personal = personal
if (show_ids == False):
try:
if not (username == None) and (separate == True) and not (isfile(
'{}/{}.db'.format(wrap.getDB(user), username))):
print(dumps((True, '¡El almacén seleccionado no existe!')))
sys.exit(1)
if (raw == False):
db = wrap.getall(user, username=username, separate=separate)
else:
db = __dict_json_decode(
dict(wrap.raw(user, username=username, separate=separate)))
except wrap.databaseIsNotDefined as Except:
print(str(Except))
sys.exit(1)
except wrap.agentNotExists:
print(dumps((True, 'El identificador no existe ...')))
sys.exit(1)
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)
else:
print('El almacén del rook no se puede borrar porque no existe ...')
sys.exit(1)
if (show == True):
if (len(bot_id_list) == 0):
print('No se han registrado credenciales para los bot\'s')
sys.exit(1)
bot_id_list = bot_id_list if (limit
== None) else bot_id_list[limit[0]:limit[1]]
credentials_list = [
wrap.getall(agent=wrap.USE_BOT, username=x, separate=True)
for x in bot_id_list
]
for credentials in credentials_list:
if not (rsa_password == None):
_evalue_credentials = rsa_password_check.check(
rsa_password, bot_id_list)
else:
_evalue_credentials = None
if not (option == None):
def connect(url,
token,
command,
data,
log,
return_exception=True,
headers=None):
if not (isinstance(url, str)):
log.logger('El tipo de dato de la URL no es correcto', debug.WAR)
return (False)
if not (isinstance(url, str)):
log.logger('El tipo de dato del token de acceso no es correcto',
debug.WAR)
return (False)
share = {}
share['token'] = token
log.logger('Usando el acceso público de "%s"' % (url), debug.INF)
try:
try:
pubKey = wrap.getall(wrap.USE_TMP)[sha1(
url.encode()).hexdigest()]['pub_key']
except KeyError:
log.logger(
'No se encontro la clave pública en el almacén ... Descargandola de: "%s"'
% (url), debug.PER)
share['command'] = ('getPubKey', None)
pubKey = simplycrypt.decrypt(
token,
requests.post(
url=url,
data=simplycrypt.encrypt(token, share),
headers=headers,
verify=False,
timeout=global_conf.connector['timeout']).content)
if (pubKey == False):
log.logger(
'Hubo un error extrayendo la clave pública de: "%s"' %
(url), debug.COM)
return (False)
log.logger('Almacenando la clave pública en el almacén ...',
debug.INF)
if (wrap.add(sha1(url.encode()).hexdigest(), {'pub_key': pubKey},
agent=wrap.USE_TMP) == True):
log.logger('La clave pública se guardó en el almacén',
debug.INF)
else:
log.logger(
'Error guardando la clave pública en el almacén ...',
debug.WAR)
return (False)
log.logger('Enviando "%s" a "%s" ...' % (command, url), debug.PER)
share['command'] = (command, data)
content = simplycrypt.decrypt(
token,
requests.post(url=url,
data=simplycrypt.encrypt(token, share),
headers=headers,
verify=False,
timeout=global_conf.connector['timeout']).content)
log.logger('Contenido enviado con éxito a: "%s"' % (url), debug.PER)
return (content)
except Exception as Except:
log.logger(
'Ocurrio un error conectando a un acceso público. Excepción: "%s"'
% (Except), debug.WAR)
if (return_exception == True):
return (str(Except))
else:
return (False)
parser.add(['-r', '--reset'], 'reset', 'Borrar todos los datos (Peligroso)', type=bool, action=True, group=danger_group)
args = parser.parse_args()
key = args.key
sub_key = args.sub_key
value = args.value
print_config = args.print_config
target = args.target
reset = args.reset
static = args.static
if not (key == None) or (print_config == True):
dat = wrap.getall(wrap.USE_CONFIG)
if (dat.get('config') == None):
dat['config'] = {}
dat = dat['config']
if (print_config == True):
if (static == True):
_print('Leyendo archivo de configuración estática ...')
_transformer = {}
static_config = global_conf.__dict__
def writeNodes(self, nodes, node_info):
if not (isinstance(nodes, list) == True) or not (isinstance(node_info, list) == True):
raise TypeError('El tipo de dato no es el correspondiente')
for _ in nodes:
if not (isinstance(_, list) == True):
raise TypeError('El tipo de dato de "%s" no es una lista' % (_))
if (len(_) != 3):
raise ValueError('La longitud de la lista (%s) no es correcta y tiene que seguir la siguiente sintaxis: (Node, Token, Secret Key)' % (_))
if not (len(node_info) == 11):
raise ValueError('La longitud del último nodo no tiene una longitud correcta y debe seguir la siguiente Síntaxis: (Node, Username, Passphrase, Uniqkey, Public Key Server, Your Private Key, Recover, Iteration\'s, Security Number, Decrement Number, Security Character\'s)')
_cipher = lambda data: hibrid.encrypt(data, node_info[4])
_username = _cipher(node_info[1])
_passphrase = _cipher(node_info[2])
_iteration = _cipher(str(node_info[7]))
_securityNumber = _cipher(str(node_info[8]))
_decrementNumber = _cipher(str(node_info[9]))
_securityCharacters = _cipher(str(node_info[10]))
_uniqkey = node_info[3] if (node_info[6] == False) else 'recover:%s' % (node_info[3])
_private_key_node = node_info[5]
node_info[1] = _username
node_info[2] = _passphrase
node_info[3] = _cipher(_uniqkey)
node_info[7] = _iteration
node_info[8] = _securityNumber
node_info[9] = _decrementNumber
node_info[10] = _securityCharacters
node_info.pop(5)
node_info.pop(5)
nodes.append(node_info)
_data = self.__simplySendData(('writeNodes', nodes))
try:
if (_data[1][1][0] == -1):
return(_data)
except (TypeError, IndexError, KeyError):
pass
if (_data == False):
return(_data)
elif (_data[1][0] == False):
return(_data)
else:
if (_data[1][1] == None):
return(_data)
obj = wrap.getall(wrap.USE_NODE_INFO)
if (obj.get('nodes') == None):
obj = {}
else:
obj = obj['nodes']
obj[_data[1][1]] = (node_info[4], _private_key_node)
if (wrap.add('nodes', obj, agent=wrap.USE_NODE_INFO) == True):
return(_data)
else:
return(False)
from utils.Wrappers import wrap
from utils.Ciphers import _decrypt_rsa_private_key
prog = basename(splitext(sys.argv[0])[0])
parser = argprogrammer.Parser()
parser.add(['-h', '--help'], 'help', 'Muestra la ayuda que estás viendo')
parser.add(['-P', '--rsa-passphrase'], 'rsa_passphrase',
'La frase de contraseña para desencriptar la clave privada RSA')
args = parser.parse_args()
rsa_passphrase = args.rsa_passphrase
_db = wrap.getall(wrap.USE_SERVER)
if (_db.get('keys') == None):
print('Error leyendo las claves del servidor ...')
sys.exit(1)
_keys = _db['keys']
(pub_key, priv_key) = (_keys['public_key'], _keys['private_key'])
if not (rsa_passphrase == None):
try:
priv_key = _decrypt_rsa_private_key._decrypt(priv_key, rsa_passphrase)
def loop_config(close=False):
# Globals vars
# Globals
global conf_hash, new_conf, use_keys, init
# Server
global realm, LHOST, LPORT, RPATH, public_key, private_key, resolve_dns, resolve_port
# Login
global false_username, false_passphrase, recover, max_retry, retry_seconds, denied_method
# honeypot
global blacklist, honeypot_list, tools, user_agent_list, regular_expression_for_address, regular_expression_for_userAgent, re_options
# style
global time, logger, logs
# templates
global TEMPLATE_FOLDER, TEMPLATE_ERROR404, TEMPLATE_ERROR511, TEMPLATE_ERROR400, TEMPLATE_ERROR403, TEMPLATE_CREDENTIALS, webmaster_email, TEMPLATE_ERROR500
# TOKEN SYSTEM:
###############
global token, new_token
# SECRET KEY SYSTEM:
####################
global secret_key, new_secret_key
while (True):
try:
# Configuration
conf_file = wrap.getall(wrap.USE_CONFIG)
if (conf_file == {}):
exit_force(
'Aún no se escriben datos en el archivos de configuración ...'
)
else:
# check config
key_detect(dict(conf_file), [group_name])
conf = dict(conf_file[group_name])
new_conf_hash = sha1(str(conf).encode()).hexdigest()
if (new_conf_hash != conf_hash):
conf_hash = new_conf_hash
# Check global config
key_detect(conf, [
'proxy', 'login', 'server', 'templates', 'honeypot',
'style'
])
# Style configuration
style = conf['style']
# Check Style
key_detect(style, ['time', 'log'])
time = str(style['time'])
style_log = 'logs/%s' % (
strftime('%H.%m.%S.%d-%m-%Y.log')) if (
convert.convert_bool(
style['log']) == True) else False
logger = logging.logger(output=style_log, time_format=time)
# Server configuration
server = conf['server']
# Check Server
key_detect(server, [
'sys_version', 'server_version', 'realm', 'lhost',
'lport', 'rpath', 'rdns', 'rport', 'public_service',
'user_agent', 'nodes_rule', 'cipher_file'
])
realm = str(server['realm'])
LHOST = str(server['lhost'])
LPORT = convert.convert_int(server['lport'])
BaseHTTPRequestHandler.sys_version = str(
server['sys_version'])
BaseHTTPRequestHandler.server_version = str(
server['server_version'])
RPATH = str(server['rpath'])
bit_size = convert.convert_int(server['bit_size'])
resolve_dns = convert.convert_int(server['rdns'])
resolve_port = convert.convert_int(server['rport'])
cipher_file = convert.convert_bool(server['cipher_file'])
# Comunicación
execute_command_to_admin.RULE = str(server['nodes_rule'])
execute_command_to_admin.cipher_file = cipher_file
execute_command.cipher_file = cipher_file
execute_command.parse_args = complements_info
if (re.match(r'(?!(RANDOM|STRICT))',
execute_command_to_admin.RULE)):
execute_command_to_admin.RULE = random.choice(
['STRICT', 'RANDOM'])
logger.log(
'Regla inválida; Usando "{}" como regla...'.format(
execute_command_to_admin.RULE), WAR)
execute_public_command.public_service = [
x.strip()
for x in str(server['public_service']).split(',')
] if not (convert.convert_bool(server['public_service'])
== True) else False
execute_public_command.user_agent = str(
server['user_agent'])
# Proxy configuration
proxy = conf['proxy']
# Check proxy
key_detect(proxy, ['proxy_list'])
proxy_list = proxy['proxy_list']
if (convert.convert_bool(proxy_list)):
try:
proxy_list = convert.convert_dict(proxy_list)
except Exception as Except:
logger.log(
'Error parseando los datos. Excepción: {}'.
format(Except), COM)
logger.log('No se usara un proxy :/ ...', WAR)
else:
if (proxy_list.get('proxy') == None):
logger.log(
'No configuró correctamente los valores de los proxy\'s...',
WAR)
else:
current_proxy = random.choice(
proxy_list['proxy'])
for _ in [
'proxy_type', 'proxy_addr',
'proxy_port', 'rds', 'username',
'password'
]:
if (key_check_in_dict.check(
current_proxy, _) == False):
current_proxy = False
logger.log('{} no está definido...',
WAR)
break
if not (current_proxy == False):
proxy_requirement_type = (
isinstance(current_proxy['proxy_type'],
str)
and current_proxy['proxy_type']
in ['SOCKS4', 'SOCKS5', 'HTTP'])
proxy_requirement_addr = isinstance(
current_proxy['proxy_addr'], str)
proxy_requirement_port = isinstance(
current_proxy['proxy_port'], int)
proxy_requirement_rds = isinstance(
current_proxy['rds'], bool)
proxy_requirement_username = (
isinstance(current_proxy['username'],
str)
or current_proxy['username'] == None)
proxy_requirement_password = isinstance(
current_proxy['password'], str
) or current_proxy['password'] == None
if (proxy_requirement_addr) and (
proxy_requirement_port
) and (proxy_requirement_rds) and (
proxy_requirement_username) and (
proxy_requirement_password):
try:
convex.transfor(
proxy_type=socks.PROXY_TYPES.
get(current_proxy['proxy_type']
),
proxy_addr='{}:{}'.format(
current_proxy[
'proxy_addr'],
current_proxy['proxy_port']
),
rdns=current_proxy['rds'],
username=current_proxy[
'username'],
password=current_proxy[
'password'])
except Exception as Except:
logger.log(
'No se pudo configurar el proxy. Excepcion: {}'
.format(Except))
else:
logger.log(
'Proxy: {}://{}:{}'.format(
current_proxy[
'proxy_type'],
current_proxy[
'proxy_addr'],
current_proxy['proxy_port']
), PER)
else:
logger.log(
'Algunos tipos de datos no son correctos, por lo tanto no se puede configurar el proxy'
)
else:
logger.log(
'No se puede usar un proxy, porque no está siguiendo la especificación acordada',
WAR)
else:
convex.restruct()
# Log in configuration
login = conf['login']
# Check Log in
key_detect(login, [
'false_username', 'false_passphrase', 'recover',
'max_retry', 'retry_seconds', 'denied_method'
])
max_retry = convert.convert_int(login['max_retry'])
retry_seconds = convert.convert_int(login['retry_seconds'])
denied_method = str(login['denied_method'])
false_username = str(login['false_username'])
false_passphrase = str(login['false_passphrase'])
recover = convert.convert_bool(login['recover'])
# Simple Honeypot configuration
simpleHoneypot = conf['honeypot']
# Check Simple Honeypot
key_detect(simpleHoneypot, [
'blacklist', 'honeypot_list', 'tools',
'user_agent_black_list',
'regular_expression_for_address',
'regular_expression_for_userAgent', 're_options'
])
re_options = convert.convert_int(
simpleHoneypot['re_options'])
regular_expression_for_address = str(
simpleHoneypot['regular_expression_for_address'])
regular_expression_for_userAgent = str(
simpleHoneypot['regular_expression_for_userAgent'])
blacklist = str(simpleHoneypot['blacklist'])
honeypot_list = str(simpleHoneypot['honeypot_list'])
tools = str(simpleHoneypot['tools'])
user_agent_list = str(
simpleHoneypot['user_agent_black_list'])
# Server keys
_server_keys = wrap.read('keys', agent=wrap.USE_SERVER)
if (_server_keys == False):
logger.log(
'El par de claves aún no son son generados ... generando ...',
WAR)
logger.log('Tamaño a generar: "%d"' % (bit_size), PER)
_keys = generate_keys(bit_size)
(public_key, private_key) = (_keys['public_key'],
_keys['private_key'])
if (wrap.add('keys', _keys,
agent=wrap.USE_SERVER) == True):
logger.log('El par de claves fueron generadas ...')
logger.log('Desencriptando ...')
try:
private_key = _decrypt_rsa_private_key._decrypt(
private_key, rsa_passphrase)
except ValueError:
logger.log(
'Error desencriptado la clave privada ...',
COM)
exit_force()
else:
logger.log('¡Clave desencriptada!')
else:
logger.log(
'Error escribiendo las claves en el almacén ...',
COM)
exit_force()
else:
if (use_keys == True):
use_keys = False
(public_key,
private_key) = (_server_keys['public_key'],
_server_keys['private_key'])
logger.log('Desencriptando clave privada ...')
try:
private_key = _decrypt_rsa_private_key._decrypt(
private_key, rsa_passphrase)
except ValueError:
logger.log(
'Error desencriptado la clave privada ...',
COM)
exit_force()
else:
logger.log('Clave desencriptada con éxito.')
# Local information
templates = conf['templates']
# Check Local information
key_detect(templates, [
'folder', 'error400', 'error404', 'error403',
'error511', 'credentials', 'webmaster_email',
'error500'
])
TEMPLATE_FOLDER = str(templates['folder'])
TEMPLATE_ERROR400 = '%s/%s' % (TEMPLATE_FOLDER,
templates['error400'])
TEMPLATE_ERROR404 = '%s/%s' % (TEMPLATE_FOLDER,
templates['error404'])
TEMPLATE_ERROR403 = '%s/%s' % (TEMPLATE_FOLDER,
templates['error403'])
TEMPLATE_ERROR511 = '%s/%s' % (TEMPLATE_FOLDER,
templates['error511'])
TEMPLATE_ERROR500 = '%s/%s' % (TEMPLATE_FOLDER,
templates['error500'])
TEMPLATE_CREDENTIALS = '%s/%s' % (TEMPLATE_FOLDER,
templates['credentials'])
webmaster_email = templates['webmaster_email']
# Server information
if (RPATH == 'RANDOM'):
RPATH = token_urlsafe(
convert.convert_int(
global_conf.token['path_max_length']))
if not (new_conf == True):
logger.log('Se actualizo la configuración!')
else:
new_conf = False
_secret_key = wrap.read('secret_key',
'secret_key',
agent=wrap.USE_SECRET_KEY)
if (_secret_key == False):
logger.log('Generando clave secreta ...')
secret_key = separate_space.separate(
generate_uniqkey.generate())
new_secret_key = True
if (wrap.add('secret_key', {'secret_key': secret_key},
agent=wrap.USE_SECRET_KEY)):
logger.log(f'Clave secreta generada -> {secret_key}',
PER)
else:
logger.log('Error generando la clave secreta ...', COM)
exit_force()
else:
if (_secret_key != secret_key):
if (new_secret_key == False):
logger.log(f'Clave secreta -> {_secret_key}', PER)
new_secret_key = True
else:
logger.log(
f'Clave secreta actualizado -> {_secret_key}',
PER)
secret_key = _secret_key
_token = wrap.read('token', 'token', agent=wrap.USE_TOKEN)
if (_token == False):
logger.log('Generando un nuevo token de acceso ...')
token = generate_uniqkey.generate()
new_token = True
if (wrap.add('token', {'token': token},
agent=wrap.USE_TOKEN)):
logger.log(f'Token de acceso generado -> {token}', PER)
else:
logger.log('Error generando el token de acceso ...',
COM)
exit_force()
else:
if (_token != token):
if (new_token == False):
logger.log(f'Token de acceso -> {_token}', PER)
new_token = True
else:
logger.log(f'Token actualizado -> {_token}', PER)
token = _token
if (close == True):
break
else:
init = True
sleep(1)
except Exception as Except:
exit_force('Error en la configuración: "{}"'.format(Except))
def check(username, passphrase, uniqkey, recover, log, address, max_retry,
retry_seconds, denied_method, iterations, chars, decrement_number,
security_number):
log.logger('Verificando credenciales del administrador...', debug.INF)
chars = str(chars)
try:
iterations = pos_convert.convert(int(iterations))
decrement_number = pos_convert.convert(int(decrement_number))
security_number = pos_convert.convert(int(security_number))
except ValueError:
log.logger(
'No se introdujo un tipo de dato correcto en un parámetro ...',
debug.COM)
return (False)
else:
if (len(chars) > hashing_length['chars']):
log.logger(
'El número de los caracteres (%d) sobrepasa el limite (%d)' %
(len(chars), hashing_length['chars']), debug.WAR)
return (False)
elif (iterations > hashing_length['iterations']):
log.logger(
'El número de iteraciones (%d) del cliente sobrepasa el limite (%d)'
% (iterations, hashing_length['iterations']), debug.WAR)
return (False)
elif (decrement_number > hashing_length['decrement_number']):
log.logger(
'El número de disminución (%d) del cliente sobrepasa el limite (%d)'
% (decrement_number, hashing_length['decrement_number']),
debug.WAR)
return (False)
elif (security_number > hashing_length['security_number']):
log.logger(
'El número de seguridad (%d) del cliente sobrepasa el limite (%d)'
% (security_number, hashing_length['security_number']),
debug.WAR)
return (False)
else:
log.logger(
'¡Los datos corresponden con las limitaciones asignadas!',
debug.INF)
denied_method = denied_method.lower()
agent = wrap.USE_ADMIN
address_string = address[0]
spam_agent = wrap.USE_SPAM_FOR_ADMINS
username = str(username)
passphrase = str(passphrase)
uniqkey = str(uniqkey)
db_passphrase = wrap.read(username,
'passphrase',
agent=agent,
separate=True)
new_uniqkey = False
if (uniqkey.lower().count(':') == 1):
log.logger('Parece que quiere acceder con la anterior clave única ...',
debug.WAR)
real_uniqkey = uniqkey.split(':')
try:
if not (real_uniqkey[0].lower() == 'recover'):
log.logger('¡Uso un formato invalído!', debug.COM)
return (False)
uniqkey = real_uniqkey[1]
except IndexError:
log.logger(
'No tiene datos suficientes para comprobar que desea usar la última clave única',
debug.COM)
return (False)
else:
real_uniqkey = False
if not (real_uniqkey == False):
log.logger(
'Quiere usar la última clave para acceder y tiene un formato correcto',
debug.INF)
if (recover == True):
log.logger('Va a tratar de acceder con la última clave única',
debug.WAR)
db_uniqkey = wrap.read(username,
'lastUniqkey',
agent=agent,
separate=True)
else:
log.logger('¡No está permitido usar la última clave única!',
debug.INF)
new_uniqkey = True
else:
new_uniqkey = True
if (new_uniqkey == True):
log.logger('Usando la clave única actual', debug.INF)
db_uniqkey = wrap.read(username, 'uniqkey', agent=agent, separate=True)
if (db_passphrase == False) or (db_uniqkey == False):
log.logger(
'No se pudo obtener la clave única o la frase de contraseña',
debug.WAR)
return (False)
log.logger(
'Verificando la existencia del administrador en el almacén de los intentos fallidos ...',
debug.INF)
if (username in wrap.getall(agent=spam_agent)):
log.logger('¡Correcto, el administrador existe!', debug.INF)
else:
log.logger(
'El administrador no existe, almacenando un espacio en el almacén ...',
debug.WAR)
if (wrap.add(username, {
'retry': 0,
'IP': [],
'max_time': None
},
agent=spam_agent) == True):
log.logger('Se agregó el administrador al almacén', debug.INF)
else:
log.logger(
'Hubo un error agregando los datos al almacén. No se puede seguir operando',
debug.COM)
return (False)
if (denied_method == 'forretry'):
_method = wrap.read(username, 'retry', agent=spam_agent)
elif (denied_method == 'forip'):
try:
_method = _extract(wrap.read(username, 'IP', agent=spam_agent),
address_string)[-1][2]
except (TypeError, IndexError):
_method = 0
else:
log.logger(_server_error_message, debug.INF)
return (False)
if (_method >= max_retry):
if (denied_method == 'forip'):
try:
_result = _extract(wrap.read(username, 'IP', agent=spam_agent),
address_string)[-1][1]
except (TypeError, IndexError):
_trans = 0
else:
_trans = float(_result)
elif (denied_method == 'forretry'):
_trans = float(wrap.read(username, 'max_time', agent=spam_agent))
if not (time() >= _trans):
log.logger('¡Aún no ha transcurrido el tiempo maximo registrado!',
debug.WAR)
else:
log.logger(
'Tiempo transcurrido con exito. Reiniciando valores ...',
debug.INF)
if (wrap.delete(username, agent=spam_agent) == True):
log.logger('Correcto, se reiniciaron los valores con exito',
debug.INF)
else:
log.logger('Hubo un error reiniciando los valores ...',
debug.COM)
return (False)
if (denied_method == 'forretry'):
if (wrap.read(username, 'retry', agent=spam_agent) >= max_retry):
log.logger(
'Los intentos fallidos de inicio de sesión han llegado al maximo configurado ...',
debug.WAR)
return (False)
elif (denied_method == 'forip'):
try:
_result = _extract(wrap.read(username, 'IP', agent=spam_agent),
address_string)[-1][2]
except (TypeError, IndexError):
_result = 0
if (_result >= max_retry):
log.logger(
'Los intentos de inicios de sesión por parte de la dirección IP "%s" han llegado al maximo configurado ...'
% (address_string), debug.WAR)
return (False)
else:
log.logger(_server_error_message, debug.WAR)
return (False)
if (db_uniqkey == uniqkey) and (db_hash.compare(
passphrase, db_passphrase, iterations, chars, security_number,
decrement_number) == True):
log.logger('¡La frase de contraseña o la clave única es correcta!',
debug.PER)
wrap.write(username,
'lastLogin',
strftime("%H:%M:%S&%d/%m/%Y"),
agent=agent,
separate=True)
wrap.write(username,
'lastUniqkey',
db_uniqkey,
agent=agent,
separate=True)
return (True)
else:
log.logger(
'La frase de contraseña o la clave única no es correcta ...',
debug.COM)
result = []
result1 = []
result2 = []
_max_time = time() + retry_seconds
if (denied_method == 'forretry'):
_retry = int(wrap.read(username, 'retry', agent=spam_agent)) + 1
try:
_retry_for_ip = int(
_extract(wrap.read(username, 'IP', agent=spam_agent),
address_string)[-1][2])
except (TypeError, IndexError):
_retry_for_ip = 0
result2.append(
wrap.write(username, 'max_time', _max_time, agent=spam_agent))
result2.append(
wrap.write(username, 'retry', _retry, agent=spam_agent))
if (False in result2):
log.logger(
'Ocurrio un error interno. no se puede remplazar el valor de intentos fallidos',
debug.COM)
return (False)
else:
_retry = int(wrap.read(username, 'retry', agent=spam_agent))
try:
_retry_for_ip = int(
_extract(wrap.read(username, 'IP', agent=spam_agent),
address_string)[-1][2]) + 1
except (TypeError, IndexError):
_retry_for_ip = 1
try:
wrap.read(username, 'IP', agent=spam_agent)[-1][0]
except (TypeError, IndexError):
result1.append(False)
result1.append(
wrap.write(username,
'IP',
_max_time,
agent=spam_agent,
target=wrap.TARGET_SUBINDEX_UPDATE,
array_subindex=(-1, 1)))
result1.append(
wrap.write(username,
'IP',
_retry_for_ip,
agent=spam_agent,
target=wrap.TARGET_SUBINDEX_UPDATE,
array_subindex=(-1, 2)))
if (False in result1):
result.append(
wrap.write(username,
'IP', [address_string, _max_time, _retry_for_ip],
agent=spam_agent))
if (False in result):
log.logger('¡No se pudo agregar otro ingreso al almacén! ...',
debug.COM)
return (False)
_bak_retry = _retry if (denied_method == 'forretry') else _retry_for_ip
log.logger(
'Total de intentos fallidos registrados: "%d"' % (_bak_retry),
debug.WAR)
return (False)
def check(passphrase, bot_id, log, address, max_retry, retry_seconds, denied_method, rdns, iterations, chars, decrement_number, security_number):
passphrase = str(passphrase)
bot_id = str(bot_id)
chars = str(chars)
log1 = debug.log(address=address, username='******' % (bot_id), log=log, rdns=rdns) if not (bot_id == '') else debug.log(address=address, username='******', log=log, rdns=rdns)
log1.logger('Verificando las credenciales del rook...', debug.INF)
try:
iterations = pos_convert.convert(int(iterations))
decrement_number = pos_convert.convert(int(decrement_number))
security_number = pos_convert.convert(int(security_number))
except (TypeError, ValueError):
log1.logger('No se introdujo un tipo de dato correcto en un parámetro ...', debug.COM)
return(False)
else:
if (len(chars) > hashing_length['chars']):
log1.logger('El número de los caracteres (%d) sobrepasa el limite (%d)' % (len(chars), hashing_length['chars']), debug.WAR)
return(False)
elif (iterations > hashing_length['iterations']):
log1.logger('El número de iteraciones (%d) del cliente sobrepasa el limite (%d)' % (iterations, hashing_length['iterations']), debug.WAR)
return(False)
elif (decrement_number > hashing_length['decrement_number']):
log1.logger('El número de disminución (%d) del cliente sobrepasa el limite (%d)' % (decrement_number, hashing_length['decrement_number']), debug.WAR)
return(False)
elif (security_number > hashing_length['security_number']):
log1.logger('El número de seguridad (%d) del cliente sobrepasa el limite (%d)' % (security_number, hashing_length['security_number']), debug.WAR)
return(False)
else:
log1.logger('¡Los datos corresponden con las limitaciones asignadas!', debug.INF)
denied_method = denied_method.lower()
address_string = address[0]
spam_agent = wrap.USE_SPAM
db_username = wrap.read(bot_id, 'username', separate=True)
db_passphrase = wrap.read(bot_id, 'passphrase', separate=True)
if (db_username == False) or (db_passphrase == False):
log1.logger('No se pudo obtener el Nombre de usuario o frase de contraseña', debug.WAR)
return(False)
log1.logger('Verificando la existencia del bot en el almacén de los intentos fallidos ...', debug.INF)
if (bot_id in wrap.getall(agent=wrap.USE_SPAM)):
log1.logger('¡Correcto, el bot existe!', debug.INF)
else:
log1.logger('El bot no existe, almacenando un espacio en el almacén ...', debug.WAR)
if (wrap.add(bot_id, {'retry':0, 'IP':[], 'max_time':None}, agent=wrap.USE_SPAM) == True):
log1.logger('Se agrego el bot al almacén', debug.INF)
else:
log1.logger('Hubo un error agregando los datos al almacén. No se puede seguir operando', debug.COM)
return(False)
if (denied_method == 'forretry'):
_method = wrap.read(bot_id, 'retry', agent=spam_agent)
elif (denied_method == 'forip'):
try:
_method = _extract(wrap.read(bot_id, 'IP', agent=spam_agent), address_string)[-1][2]
except (TypeError, IndexError):
_method = 0
else:
log1.logger(_server_error_message, debug.INF)
return(False)
if (_method >= max_retry):
if (denied_method == 'forip'):
try:
_result = _extract(wrap.read(bot_id, 'IP', agent=spam_agent), address_string)[-1][1]
except (TypeError, IndexError):
_trans = 0
else:
_trans = float(_result)
elif (denied_method == 'forretry'):
_trans = float(wrap.read(bot_id, 'max_time', agent=spam_agent))
if not (time() >= _trans):
log1.logger('¡Aún no ha transcurrido el tiempo maximo registrado!', debug.WAR)
else:
log1.logger('Tiempo transcurrido con exito. Reiniciando valores ...', debug.INF)
if (wrap.delete(bot_id, agent=spam_agent) == True):
log1.logger('Correcto, se reiniciaron los valores con exito', debug.INF)
else:
log1.logger('Hubo un error reiniciando los valores ...', debug.COM)
return(False)
if (denied_method == 'forretry'):
if (wrap.read(bot_id, 'retry', agent=spam_agent) >= max_retry):
log1.logger('Los intentos fallidos de inicio de sesión han llegado al maximo configurado ...', debug.WAR)
return(False)
elif (denied_method == 'forip'):
try:
_result = _extract(wrap.read(bot_id, 'IP', agent=spam_agent), address_string)[-1][2]
except (TypeError, IndexError):
_result = 0
if (_result >= max_retry):
log1.logger('Los intentos de inicios de sesión por parte de la dirección IP "%s" han llegado al maximo configurado ...' % (address_string), debug.WAR)
return(False)
else:
log1.logger(_server_error_message, debug.WAR)
return(False)
log = debug.log(address=address, username='******' % (db_username, bot_id), log=log, rdns=rdns)
if (db_hash.compare(passphrase, db_passphrase, iterations, chars, security_number, decrement_number) == True):
log.logger('Credenciales correctas', debug.INF)
return(True)
else:
log.logger('¡Credenciales incorrectas!', debug.COM)
result = []
result1 = []
result2 = []
_max_time = time()+retry_seconds
if (denied_method == 'forretry'):
_retry = int(wrap.read(bot_id, 'retry', agent=spam_agent))+1
try:
_retry_for_ip = int(_extract(wrap.read(bot_id, 'IP', agent=spam_agent), address_string)[-1][2])
except (TypeError, IndexError):
_retry_for_ip = 0
result2.append(wrap.write(bot_id, 'max_time', _max_time, agent=spam_agent))
result2.append(wrap.write(bot_id, 'retry', _retry, agent=spam_agent))
if (False in result2):
log.logger('Ocurrio un error interno. No se puede remplazar el valor de intentos fallidos', debug.COM)
return(False)
else:
_retry = int(wrap.read(bot_id, 'retry', agent=spam_agent))
try:
_retry_for_ip = int(_extract(wrap.read(bot_id, 'IP', agent=spam_agent), address_string)[-1][2])+1
except (TypeError, IndexError):
_retry_for_ip = 1
try:
wrap.read(bot_id, 'IP', agent=wrap.USE_SPAM)[-1][0]
except (TypeError, IndexError):
result1.append(False)
result1.append(wrap.write(bot_id, 'IP', _max_time, agent=spam_agent, target=wrap.TARGET_SUBINDEX_UPDATE, array_subindex=(-1, 1)))
result1.append(wrap.write(bot_id, 'IP', _retry_for_ip, agent=spam_agent, target=wrap.TARGET_SUBINDEX_UPDATE, array_subindex=(-1, 2)))
if (False in result1):
result.append(wrap.write(bot_id, 'IP', [address_string, _max_time, _retry_for_ip], agent=spam_agent))
if (False in result):
log.logger('¡No se pudo agregar otro ingreso al almacén! ...', debug.COM)
return(False)
_bak_retry = _retry if (denied_method == 'forretry') else _retry_for_ip
log.logger('Total de intentos fallidos registrados: "%d"' % (_bak_retry), debug.WAR)
return(False)
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)
else:
if (microseconds > max_microsecond):
print(
'Los micro-segundos se excedieron del limite permitido.'
)
sys.exit(1)
time_ = '%d:%d:%d.%d' % (hours, minutes, seconds, microseconds)
print('Leyendo mensajes ...')
sleep(1)
messages_lst = wrap.getall(wrap.USE_MESSAGE)
if (len(messages_lst) == 0):
print('Aún no hay mensajes...')
sys.exit(0)
messages = [x for x in messages_lst]
messages = messages[:limit] if not (limit == 0) else messages
if not (date == None) or not (time_ == None):
result = []
for _ in messages:
print('{}, Fue eliminado con éxito'.format(del_admin))
sys.exit(0)
else:
print('El administrador no se puede borrar, porque no existe ...')
sys.exit(1)
if (show == True):
admins = show_user_admins.show()
admins = admins if (limit == None) else admins[limit[0]:limit[1]]
credentials_list = [
x for x in [
wrap.getall(wrap.USE_ADMIN, username=x, separate=True)
for x in admins
] if not (x == False)
]
if (credentials_list == []):
print('¡No hay información acerca de los administradores!')
else:
for credentials in credentials_list:
if not (rsa_password == None):
_evalue_credentials = rsa_password_check.check(