print('No está permitido la eliminación de "%s"' % (_)) sys.exit(1) try: if (isinstance(wrapper_instance, list)) and (delete == True): limit = 0 count_value = 0 while not (limit >= limits): result = wrap.write( identifier, key, value, target=wrap.TARGET_DELETE, separate=True) if (agent == 'bot') else wrap.write( identifier, key, value, agent=wrap.USE_ADMIN, target=wrap.TARGET_DELETE, separate=True) if not (result == False): count_value += 1 else:
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 defend(command, address, bhost, bport, log): try: bhost = str(bhost) bport = str(bport) commands = [x.strip() for x in command.split(';') if (convert.convert_bool(x))] (host, port) = address # Bind (hostname, address) = my_addr.addr() for b_ in commands: cmd = b_ try: limit = int(cmd.split(None, 1)[0]) except: log('¡El limite debe ser un número!', debug.WAR) return cmd = ''.join(cmd.split(None, 1)[1:]).strip() for _key, _value in {'{ip}':host, '{port}':port, '{bhost}':bhost, '{bport}':bport, '{phost}':my_public_addr.addr}.items(): if (cmd.find(_key) != -1): if (isfunction(_value)): _value = str(_value()) cmd = cmd.replace(_key, _value) uniqid = sha1(cmd.encode()).hexdigest() db_result = int(wrap.read(uniqid, 'limit', agent=wrap.USE_DEFEND)) if not (limit == 0): if (db_result == 0): if (wrap.add(uniqid, {'limit':1}, agent=wrap.USE_DEFEND) == False): log('Lo siento no se pudo agregar un limite al almacén para la siguiente defensa: "{}"'.format(cmd), debug.COM) return elif (db_result >= limit): return else: if (wrap.write(uniqid, 'limit', db_result+1, agent=wrap.USE_DEFEND) == False): log('No se pudo actualizar el limite en el almacén para la siguiente defensa: "{}"'.format(cmd), debug.COM) return parsed = shlex.split(cmd) try: result = Popen(parsed, stdout=PIPE, stderr=STDOUT, universal_newlines=True) except FileNotFoundError: log('El ejecutable: "{}" no se puede ejecutar porque no existe ...'.format(parsed[0]), debug.WAR) return except Exception as Except: log('Ocurrio un error desconocido al ejecutar el siguiente comando: "{}". Excepción: "{}"'.format(cmd, Except), debug.WAR) return pid = result.pid name = "%s.%s.%s.log" % (host, uniqid, strftime('%d-%m-%Y')) output_func('\033[1;37m***\033[0m \033[1;32mIniciando\033[0m: \033[1;33mID\033[0m:\033[1;37m%s\033[0m: \033[1;33mpid\033[0m:\033[1;37m%d\033[0m \033[1;34m~\033[0m \033[1;33mfile\033[0m:\033[1;37m%s ***\033[0m\n' % (uniqid, pid, name), name) with result as _process: for c_ in _process.stdout: output_func("\033[1;34m%s\033[0m: \033[1m%s\033[0m\n" % (parsed[0], c_.rstrip()), name) output_func('\033[1;37m***\033[0m \033[1;32mFinalizado\033[0m: \033[1;33mID\033[0m:\033[1;37m%s\033[0m: \033[1;33mpid\033[0m:\033[1;37m%d\033[0m \033[1;34m~\033[0m \033[1;33mfile\033[0m:\033[1;37m%s ***\033[0m\n' % (uniqid, pid, name), name) except Exception as Except: log('Excepción ejecutando la defensa: {}'.format(Except), debug.COM)
def do_POST(self): global request_count_safe share = False request_count_safe['POST'] += 1 if (self.eject() == True): return content_length = self.headers['Content-Length'] if (content_length == None): self.do_AUTHHEAD() return content_length = int(content_length) if (content_length <= 0): self.do_AUTHHEAD() return post_data = self.rfile.read(content_length) if (len(post_data) <= 0): self.do_AUTHHEAD() return try: _extract_post_data = extract_http_post_data.extract(post_data) except Exception as Except: _extract_post_data = False else: rusername = _extract_post_data.get('username') rpassword = _extract_post_data.get('passphrase') data_ = _extract_post_data.get('data') runiqkey = _extract_post_data.get('uniqkey') security_chars = _extract_post_data.get('chars') security_number = _extract_post_data.get('security_number') security_decrement_number = _extract_post_data.get( 'decrement_number') security_iterations = _extract_post_data.get('iterations') reply = _extract_post_data.get('reply') if (None in [ rusername, rpassword, data_, runiqkey, security_chars, security_number, security_decrement_number, security_iterations ]): _extract_post_data = False evalue_exp = None else: _decipher = lambda dat: hibrid.decrypt(dat, private_key) try: rusername = _decipher(rusername) rpassword = _decipher(rpassword) data_ = _decipher(data_) runiqkey = _decipher(runiqkey) security_chars = _decipher(security_chars) security_number = _decipher(security_number) security_decrement_number = _decipher( security_decrement_number) security_iterations = _decipher(security_iterations) reply = _decipher(reply) except: self.imprint( 'No se pudo desencriptar los datos por parámetros ...', WAR) _extract_post_data = False else: evalue_exp = [ True, True, True, True, False, True, True, True, True ] if (_extract_post_data == False): try: data = hibrid.decrypt(post_data, private_key) except Exception as Except: self.imprint( 'Error desencriptando datos. Intentando con el cifrado simetrico ...', WAR) try: data = simplycrypt.decrypt(token, post_data) if (data == None): raise except Exception as Except: self.imprint( 'No se desencriptaron los datos ni con el cifrado simetrico ...', COM) self.do_AUTHHEAD() return else: self.imprint( 'Los datos fueron desencriptados, por lo tanto, se usarán en el acceso público ...', INF) share = True evalue_exp = None else: # Credentials rusername = data.get('username') rpassword = data.get('passphrase') data_ = data.get('data') bot_id = data.get('id') runiqkey = data.get('uniqkey') security_chars = data.get('chars') security_number = data.get('security_number') security_decrement_number = data.get('decrement_number') security_iterations = data.get('iterations') reply = data.get('reply') # Evaluamos evalue_exp = list( map(evalue, [ rusername, rpassword, runiqkey, data_, bot_id, security_chars, security_number, security_decrement_number, security_iterations ])) if not (urlparse(self.path).path == '/' + RPATH): if (evalue_exp == [ False, True, False, True, True, True, True, True, True ]): if (check_credentials.check( rpassword, bot_id, logger, self.client_address, max_retry, retry_seconds, denied_method, resolve_dns, iterations=security_iterations, chars=security_chars, decrement_number=security_decrement_number, security_number=security_number)): self.found200() bot_information = wrap.read(bot_id, separate=True) _username = bot_information['username'] command = hibrid.encrypt( execute_command.execute( data_, bot_id, log=debug.log(self.client_address, '%s:(%s)' % (_username, bot_id), logger, resolve_dns, resolve_port)), bot_information['keys'][0]) self.wfile.write(command) else: self.error403() self.imprint('Quiere acceder como un bot!', COM) else: self.do_AUTHHEAD() else: if (evalue_exp == [ True, True, True, True, False, True, True, True, True ]): self.imprint( 'Verificando si las credenciales de "%s" son correctas ...' % (rusername), WAR) if (check_administrators.check( username=rusername, passphrase=rpassword, uniqkey=runiqkey, recover=recover, log=debug.log(self.client_address, rusername, logger, resolve_dns), address=self.client_address, max_retry=max_retry, retry_seconds=retry_seconds, denied_method=denied_method, iterations=security_iterations, chars=security_chars, decrement_number=security_decrement_number, security_number=security_number)): self.found200() admin_information = wrap.read(rusername, agent=wrap.USE_ADMIN, separate=True) self.imprint( '(%s): Actualizada la clave única de "%s" ...' % (rusername, runiqkey), PER) uniqkey_updated = generate_uniqkey.generate() if not (wrap.write(rusername, 'uniqkey', uniqkey_updated, agent=wrap.USE_ADMIN, separate=True) == True): self.error500() log.logger('¡No se pudo actualizar la clave única!', debug.COM) return self.imprint( '(%s): ... A: "%s"' % (rusername, uniqkey_updated), PER) command = execute_command_to_admin.execute( data_, rusername, debug.log(self.client_address, rusername, logger, resolve_dns), evalue(reply)) if (command == False): self.imprint('Ejecuto un comando erroneo', COM) command = hibrid.encrypt( (False, None, uniqkey_updated), admin_information['keys'][0]) self.wfile.write(command) return command = hibrid.encrypt((True, command, uniqkey_updated), admin_information['keys'][0]) self.wfile.write(command) else: self.error403() self.imprint('Ingreso credenciales incorrectas!', WAR) elif (share == True): self.found200() command = execute_public_command.execute( data, debug.log(self.client_address, 'Public', logger, resolve_dns)) if (command == False): self.imprint( 'Ejecuto un comando erroneo o hubo un error en la entrada de datos ...', COM) self.wfile.write(simplycrypt.encrypt(token, command)) else: self.error511()
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)