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
