def apply(): gettext.getcontroller = create_translation.create( 'UTesla', localedir, language ) gettext.gettext = create_translation.create( 'argparse', localedir, language ) logging.critical = critical logging.error = error logging.warning = warning logging.info = info logging.debug = debug builtins.input = input_func
from modules.Infrastructure import utils from modules.Crypt import ed25519 from modules.Crypt import x25519_xsalsa20_poly1305MAC from utils.General import show_services from utils.General import (proc_control, proc_stream) from utils.extra import remove_badchars from utils.extra import procs_repr from utils.extra import parse_args from utils.extra import execute_possible_coroutine from utils.extra import counter from utils.extra import create_translation from config import defaults _ = create_translation.create("core") logger = logging.getLogger(__name__) class MainDataControl(utils.MainServer): def __init__( self, pool: object, user_length: int, public_key_length: int, headers_length: int, memory_limit: int, recv_timeout: int, *args, **kwargs ): super().__init__(user_length=user_length, *args, **kwargs)
import os import argparse from utils.extra import create_translation _ = create_translation.create( "generate_keys-config", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) information = { "description" : _("Generar el par de claves para el usuario"), "commands" : [ { "optionals" : [ { "args" : ("-out-public-key",), "help" : _("El nombre del archivo para almacenar la clave pública"), "type" : argparse.FileType("wb"), "dest" : "public_key", "required" : True }, { "args" : ("-out-private-key",), "help" : _("El nombre del archivo para almacenar la clave privada"), "type" : argparse.FileType("wb"),
import logging import inspect import time import hashlib import binascii from typing import (Any, AsyncIterator, Callable, Tuple, Union, Optional) import secrets from utils.extra import execute_possible_coroutine from utils.extra import create_translation from modules.Infrastructure import exceptions _ = create_translation.create("dbConnector") async def _execute_async_gen(gen): async for i in gen: return i async def _return_coroutine(coroutine): if (inspect.isasyncgen(coroutine)): async for i in coroutine: yield i else: result = await coroutine yield result
import os import sys import copy import inspect import importlib from cli_utils import exceptions from utils.extra import create_translation from config import defaults _ = create_translation.create("cli_utils") def _get_info(obj): if not (hasattr(obj, defaults.information_name)): raise exceptions.InformationNotFoundError(_("El diccionario '{}' no existe").format( defaults.information_name )) information = getattr(obj, defaults.information_name) if not (isinstance(information, dict)): raise TypeError(_("Tipo de dato incorrecto en el diccionario '{}'").format( defaults.information_name )) description = information.get("description") or "" workspaces = information.get("workspaces") or [] commands = information.get("commands") or ()
import os import logging import FormatEncode from utils.extra import create_translation _ = create_translation.create( "encoder", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) def MainParser(args): encoder = args.encoder file = args.file out = args.out option = args.option show_formats = args.show_formats limit_size = args.limit_size if (show_formats): for format in FormatEncode.encoders.keys(): print("*", format) else: if not (encoder in FormatEncode.encoders): logging.error(_("¡Debe seleccionar un codificador disponible!")) return
import argon2 from typing import Optional from modules.Infrastructure import exceptions from utils.extra import create_translation _ = create_translation.create("generate_hash") def generate(password: str, time_cost: int, memory_cost: int, parallelism: int, crypt_limits: Optional[dict] = None, *args, **kwargs) -> str: """Hash a `password` y retorna el hash codificado. Args: password: La contraseña en texto plano time_cost: La cantidad de calculo utilizado memory_cost: Define el uso de memoria en KiB parallelism: Define el número de subprocesos paralelos
import asyncio import inspect from typing import Dict, Any, Callable from utils.extra import execute_possible_coroutine from utils.extra import create_translation _ = create_translation.create("parse_args") POSITIONAL_ONLY = inspect._POSITIONAL_ONLY POSITIONAL_OR_KEYWORD = inspect._POSITIONAL_OR_KEYWORD VAR_POSITIONAL = inspect._VAR_POSITIONAL KEYWORD_ONLY = inspect._KEYWORD_ONLY VAR_KEYWORD = inspect._VAR_KEYWORD empty = inspect._empty class ConvertionException(Exception): def __init__(self, key, exception, *args, **kwargs): """ Cuando la conversión entre tipos es inválida, pero es conveniente saberla explícitamente para dar el aviso al usuario-cliente o por la depuración. """ super().__init__(*args, **kwargs) self.exception = exception self.key = key
import os import pathlib import importlib import inspect import logging from typing import (Iterator, Union, Tuple) import tornado.autoreload from utils.extra import remove_badchars from utils.extra import create_translation from config import defaults _ = create_translation.create("show_services") class HandlerAux(object): pass def return_handle(filename: str, ext: str, autoreload: bool = False) -> object: """Importa un archivo de python Importar un archivo y a la misma vez lo analiza para obtener una clase para ser usada como un servicio. Args: filename: La ruta del archivo
import binascii import asyncio from typing import Any, Optional, Dict, Tuple, NoReturn, Union, Callable from modules.Infrastructure import errno from modules.Infrastructure import parse from modules.Infrastructure import options from modules.Crypt import x25519_xsalsa20_poly1305MAC, ed25519 from utils.extra import counter from utils.extra import parse_args from utils.extra import create_translation from config import defaults _ = create_translation.create("utils") class MainHeaders: """Crea y administra los encabezados""" def __init__(self, headers={}): self.headers = copy.deepcopy(headers) def _add(self, dictionary, key, value, *args, **kwargs): value = self._check_type(value, *args, **kwargs) if not (key in dictionary): dictionary[key] = [value] elif (isinstance(dictionary[key], list)): dictionary[key].append(value)
import os import logging from typing import Optional, Union import aiofiles from modules.Infrastructure import exceptions from utils.Crypt import hibrid from utils.extra import create_translation from utils.General import parse_config translation_config = parse_config.parse()["Languages"] _ = create_translation.create("parser", translation_config["localedir"], translation_config["language"]) class Parser: """ Crea la infraestructura de UTesla Attributes: session: La sesión ECDH user_dir: El directorio de las claves de los usuarios local_key: La clave de firmado del remitente """ def __init__(self, session: "x25519_xsalsa20_poly1305MAC.InitSession", local_key: bytes,
import aiofiles import tornado.tcpclient import tornado.iostream from modules.Crypt import x25519_xsalsa20_poly1305MAC from modules.Crypt import ed25519 from modules.Infrastructure import options from modules.Infrastructure import utils from utils.extra import create_translation from utils.General import parse_config config = parse_config.parse() _ = create_translation.create("client") class UTeslaStreamControl(utils.MainClient): def __init__(self, user: str, public_key_length: int = options.PUBLIC_KEY_LENGTH, headers_length: int = options.HEADERS_LENGTH, memory_limit: int = options.MEMORY_LIMIT, *args, **kwargs): """Inicia el controlador de flujo Inicia el controlador de flujo para el intercambio de datos entre el cliente y el servidor.
import asyncio import threading import multiprocessing import sys import copy from typing import Callable, Optional, Union, Any from utils.extra import create_translation _ = create_translation.create("proc_control") class invalidTarget(Exception): " Si el objetivo deseado no se encuentra " class ThreadSafe(threading.Thread): def __init__(self, *args, **kwargs): threading.Thread.__init__(self, *args, **kwargs) self.killed = False def start(self): self.__run_backup = self.run self.run = self.__run threading.Thread.start(self) def __run(self): sys.settrace(self.global_trace) self.__run_backup() self.run = self.__run_backup
async def MainParser(args): _ = create_translation.create( "add_network", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) network = args.network token = args.token username = args.username server_key = args.server_key public_key = args.import_public_key private_key = args.import_private_key only = array_strip.strip(args.only) exclude = array_strip.strip(args.exclude) priority = args.priority if not (os.path.isfile(server_key)): logging.error(_("¡La clave pública del servidor no existe!")) return elif not (os.path.isfile(public_key)) or not (os.path.isfile(private_key)): logging.error(_("¡La clave pública o privada del usuario no existe!")) return else: with open(server_key, "rb") as fd: server_key_data = fd.read() with open(public_key, "rb") as fd: public_key_data = fd.read() with open(private_key, "rb") as fd: private_key_data = fd.read() config = parse_config.parse() server_conf = config.get("Server") try: (addr, port, path) = netparse.parse(network, default_path="/get_services") except Exception as err: logging.error(_("La dirección '%s' no es válida: %s"), network, err) return net = "%s:%d" % (addr, port) net_hash = hashlib.sha3_224(net.encode()).hexdigest() db = await create_pool.create(server_conf.get("mysql_db")) init_path = server_conf.get("init_path") server_key_dst = "%s/servkeys/%s" % (init_path, net_hash) service_path = server_conf["services"] networkid = await db.return_first_result("extract_networkid", net) try: (UControl, UClient, __) = await client.simple_client( addr, port, username, server_key_data, public_key=public_key_data, private_key=private_key_data, uteslaclient=uteslaclient.UTeslaClient()) except tornado.iostream.StreamClosedError as err: logging.error(_("Hubo un error conectado a %s:%d: %s"), addr, port, err) return UClient.set_stream_control(UControl) UControl.set_token(token) services = UClient.get_services(path) logging.warning(_("Obteniendo servicios...")) try: async for service_name in services: status_code = UControl.request.get_status_code() status = UControl.request.get_status() if (status_code == 0): service_name = os.path.basename(service_name) service_abs = "%(service_path)s/%(service_name)s/%(service_name)s.py" % { "service_path": service_path, "service_name": service_name } for __ in range(2): if (networkid is None): logging.debug( _("La red '%s' no existe, pero se agregará..."), net) await db.return_first_result("insert_network", net, token, username) networkid = await db.return_first_result( "extract_networkid", net) else: break if (networkid is None): logging.error( _("¡No se pudo obtener el identificador de la red '%s' en la base de datos!" ), net) continue else: if (isinstance(networkid, tuple)): (networkid, ) = networkid if (os.path.isfile(service_abs)): logging.warning( _("El servicio '%s' ya existe de manera local. No se agregará." ), service_name) continue if (service_name in exclude): logging.warning( _("El servicio '%s' no se agregará o actualizará porque está en la lista de exclusión" ), service_name) elif (only != []) and not (service_name in only): logging.warning( _("No se incluirá el servicio %s porque sólo se prefieren algunos servicios y éste no está incluido ahí" ), service_name) else: serviceid = await db.return_first_result( "extract_serviceid", service_name) if (serviceid is None) or not (await db.return_first_result( "network_in_service", networkid, *serviceid)): logging.info( _("Agregando servicio '%s' de la red '%s'"), service_name, net) await db.return_first_result("insert_service", networkid, service_name, priority) else: logging.warning( _("'%s' ya está registrado en la red '%s'"), service_name, net) else: logging.error(_("Ocurrió un error con la petición: %s"), status) break if (UControl.request.get_status_code() != -1) and (UControl.request.get_status_code() != 0): logging.error(_("Error obteniendo los servicios: %s"), UControl.request.get_status()) except tornado.iostream.StreamClosedError as err: logging.error(_("Hubo un error interpretando los datos: %s"), err) if (UControl.request.get_status_code() != 0) and (UControl.request.get_status_code() != -1): logging.error(_("Posible error: %s"), UControl.request.get_status()) else: if not (os.path.isfile(server_key_dst)): logging.debug(_("Copiando '%s' a '%s'..."), server_key, server_key_dst) shutil.copy(server_key, server_key_dst) logging.info(_("Hecho."))
import os from utils.extra import create_translation _ = create_translation.create( "add_network-config", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) information = { "description" : _("Agregar una red"), "commands" : [ { "positionals" : [ { "args" : ("network",), "help" : _("La red a conectar") } ] }, { _("Claves") : [ { "args" : ("-s", "--server-key"), "help" : _("La clave pública del servidor"), "required" : True
import os import time import logging import tornado.iostream import uteslaclient from modules.Infrastructure import client from utils.General import parse_config from utils.extra import netparse from utils.extra import generate_hash from utils.extra import create_pool from utils.extra import create_translation _ = create_translation.create( "change_passwd-config", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) async def MainParser(args): user = args.user password = args.password new_password = args.new_password token_limit = args.token_limit time_cost = args.time_cost memory_cost = args.memory_cost parallelism = args.parallelism remote = args.remote network = args.network server_key = args.server_key
import inspect from typing import Tuple, Union, Optional import nacl.signing from modules.Crypt import utils from utils.extra import create_translation from config import defaults _ = create_translation.create("ed25519") def _tuple(): return utils.key_repr("Ed") def generate() -> Tuple["nacl.signing.VerifyKey", "nacl.signing.SigningKey"]: """Genera el par de claves Ed25519 Returns: Una tupla con la clave de verificación y la clave para firmar """ tuple = _tuple() signingKey = nacl.signing.SigningKey.generate() return tuple(signingKey.verify_key, signingKey) def to_raw( keys: Tuple["nacl.signing.VerifyKey", "nacl.signing.SigningKey"] = None
import asyncio from typing import Callable, Optional from utils.extra import execute_possible_coroutine from utils.extra import create_translation _ = create_translation.create("proc_stream") def is_valid_stream(stream: object, *, exception: bool = False) -> bool: """Verifica si una función es válida Verifica si una función es válida y contiene el método `close`, además verifica si es invocable para proceder. Args: stream: Un objeto, estilo `socket.socket()` o `open()` exception: Si es **True**, en caso de no ser válido el `stream` se llama una excepción Returns: Si `exception` es **False** se retornará un booleano. Si `stream` es válido se retorna **True**, si no, **False** Raises: TypeError: Si `exception` es **True** y `stream` es inválido """
# Permite usar constantes para mayor legibilidad y con el # objetivo de describir en un solo código de estado el error # en particular. from errno import * from utils.extra import create_translation _ = create_translation.create("errno") ENOTOK = 1000 ENOACT = 1001 ETOKEXPIRED = 1002 ESERVER = 1003 ENOUSR = 1004 ECLIENT = 1005 ETOKLIMIT = 1006 ENOSRV = 1007 default_messages = { ENOTOK: _("El token es requerido para la autenticación"), ENOACT: _("No se ha definido la acción o no está habilitada"), ETOKEXPIRED: _("El token ha expirado"), ESERVER: _("Error interno en el servidor"), ENOUSR: _("El usuario no existe"), ECLIENT: _("Petición inválida"), ETOKLIMIT: _("Límites de tokens alcanzados"), ENOSRV: _("El servicio no está habilitado"), EPERM: _("Permiso denegado") }
from inspect import namedtuple from typing import Tuple from utils.extra import create_translation _ = create_translation.create("netparse") def __set_correct_path(path): if (path != "/") and (path[:1] != "/"): path = "/" + path return path def __check_port(port): try: port = int(port) except ValueError: raise ValueError(_("Puerto inválido")) else: if (port < 0) or (port > 65535): raise ValueError(_("Puerto inválido")) return port def parse(net: str, default_port: int = 17000,
import os import logging from utils.extra import create_pool from utils.extra import create_translation _ = create_translation.create( "set_priority", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) async def MainParser(args): identificator = args.identificator priority = args.priority only_networks = args.only_networks db = await create_pool.create() logging.debug(_("Cambiando prioridad del identificador '%d'"), identificator) if (only_networks): exists = await db.return_first_result("is_network_exists_for_id", identificator) else: exists = await db.return_first_result("is_service_exists_for_id", identificator)
from modules.Infrastructure import client from modules.Infrastructure import errno from utils.General import parse_config from utils.extra import netparse from utils.extra import create_translation server_config = parse_config.parse()["Server"] server_data = os.path.join(server_config["init_path"], server_config["server_data"]) logger = logging.getLogger(__name__) exp_func = lambda level: logger.isEnabledFor(level) _ = create_translation.create( "admin", os.getenv("UTESLA_LOCALES_SERVICES") or \ "services-locales" ) class Handler: @staticmethod def __set_correct_path(path, /): if (path != "/") and (path[:1] == "/"): path = path[1:] return path def SET_CONTROLLER(self, controller, /): self.controller = controller controller.template.set_function_expression(exp_func)
import os import logging import tornado.iostream import table import uteslaclient from modules.Infrastructure import client from modules.Infrastructure import dbConnector from utils.extra import create_pool from utils.extra import create_translation from utils.extra import netparse _ = create_translation.create( "show_services", os.getenv("UTESLA_LOCALES_PLUGINS") or \ "modules/Cmd/locales-shared" ) async def MainParser(args): limit = args.limit only = args.only remote = args.remote network = args.network token = args.token username = args.username server_key = args.server_key public_key = args.public_key private_key = args.private_key n = 1