import tkinter as tk

root = tk.Tk()
root.attributes('-type', 'dock')
root.eval('tk::PlaceWindow %s center' % root.winfo_pathname(root.winfo_id()))
root.geometry('200x200')
root.focus_force()
root.mainloop()

git pull origin master
git submodule update --remote

class Handler:
    pass

mkdir complements/erica-folder

import os
import tempfile
import secrets

class Handler:
    async def get(self):
        id = secrets.token_hex(16)
        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id

        )

        os.makedirs(workspace, exist_ok=True)
        
        await self.write(id)

import tempfile
import os

class Handler:
    async def post(self):
        wordlist = self.get_argument('wordlist')
        hash = self.get_argument('hash')
        hash_type = self.get_argument('hash_type')
        shake_length = str(self.get_argument('shake_length'))
        id = self.get_query_argument('id')
        
        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id
        
        )
        hash_filename = '%s/hash.txt' % (workspace)
        hash_type_filename = '%s/hash_type.txt' % (workspace)
        wordlist_filename = '%s/wordlist.lst' % (workspace)
        shake_length_filename = '%s/shake_length.txt' % (workspace)
        
        response = {
            'error'   : False,
            'message' : None
                
        }

        if (os.path.isdir(workspace)):
            if not (os.path.isfile(hash_filename)):
                with open(hash_filename, 'w') as fd:
                    fd.write(hash)
                    fd.flush()
                    os.fsync(fd)

            if not (os.path.isfile(hash_type)):
                with open(hash_type_filename, 'w') as fd:
                    fd.write(hash_type)
                    fd.flush()
                    os.fsync(fd)

            if not (os.path.isfile(shake_length_filename)):
                with open(shake_length_filename, 'w') as fd:
                    fd.write(shake_length)
                    fd.flush()
                    os.fsync(fd)

            with open(wordlist_filename, 'a', buffering=1) as fd:
                fd.writelines(wordlist)
                os.fsync(fd)

        else:
            response['error'] = True
            response['message'] = 'El identificador de trabajo "%s" no existe' % (id)

        await self.write(response)

import tempfile
import os
import hashlib

def set_status(status, workspace):
    with open('%s/status.txt' % (workspace), 'w') as fd:
        fd.write(status)

def crack(hash, hash_type, wordlist, workspace, shake_length):
    result = False

    if not (hash_type in hashlib.algorithms_guaranteed):
        set_status('No se encuentra la función "%s"' % (hash_type), workspace)
        return

    set_status('running', workspace)

    with open(wordlist, 'r') as fd:
        for word in fd:
            word = word.strip()
            hashfunc = getattr(hashlib, hash_type)(word.encode())

            if (hash_type[:5] == 'shake'):
                hash2cmp = hashfunc.hexdigest(shake_length)

            else:
                hash2cmp = hashfunc.hexdigest()

            if (hash == hash2cmp):
                result = True
                break

    if (result):
        set_status('success:%s' % (word), workspace)

    else:
        set_status('fail', workspace)

class Handler:
    async def get(self):
        id = self.get_query_argument('id')
        
        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id

        )
        hash_filename = '%s/hash.txt' % (workspace)
        hash_type_filename = '%s/hash_type.txt' % (workspace)
        wordlist_filename = '%s/wordlist.lst' % (workspace)
        shake_length_filename = '%s/shake_length.txt' % (workspace)

        response = {
            'error'   : False,
            'message' : None
                
        }

        if (os.path.isfile(hash_filename) and os.path.isfile(hash_type_filename) and os.path.isfile(wordlist_filename) and os.path.isfile(shake_length_filename)):
            with open(hash_filename, 'r') as fd:
                hash = fd.read().strip()

            with open(hash_type_filename, 'r') as fd:
                hash_type = fd.read().strip()

            with open(shake_length_filename, 'r') as fd:
                shake_length = int(fd.read())

            self.procs.create(crack, args=(hash, hash_type, wordlist_filename, workspace, shake_length))

        else:
            response['error'] = True
            response['message'] = 'Hay una incongruencia con los archivos del espacio de trabajo'

        await self.write(response)

import os
import tempfile

class Handler:
    async def get(self):
        id = self.get_query_argument('id')

        workspace = '%s/erica_%s' % (
            tempfile.gettempdir(), id
            
        )
        response = {
            'error'   : False,
            'message' : None
                
        }

        status_file = '%s/status.txt' % (workspace)

        if (os.path.isfile(status_file)):
            with open(status_file, 'r') as fd:
                response['message'] = fd.read().strip()

        else:
            response['error'] = True
            response['message'] = 'No se puede leer el estado de la operación'

        await self.write(response)

import os
import sys
import asyncio
import logging
import hashlib
import tempfile
import sqlite3
import multiprocessing

from modules.Infrastructure import client
from utils.General import parse_config
from utils.extra import create_pool

conf = parse_config.parse()
client_conf = conf['Client']
server_conf = conf['Server']
username = server_conf['user_server']
public_key = server_conf['pub_key']
private_key = server_conf['priv_key']
client.config = client_conf
db_name = '%s/erica.db' % (tempfile.gettempdir())
tmp_wordlist = '%s/erica-wordlist.lst' % (tempfile.gettempdir())

information = {
    'description' : 'Realizar un ataque por diccionario',
    'commands'    : [
        {
            'argumentos principales' : [
                {
                    'args'     : ('-o', '--option'),
                    'help'     : 'El comando a ejecutar en el servidor',
                    'choices'  : ('get_job', 'write', 'crack', 'crack_local', 'status', 'reset'),
                    'default'  : 'get_job'

                }


            ]

        },
        
        {
            'argumentos requeridos por el comando \'write\'' : [
                {
                    'args' : ('-w', '--wordlist'),
                    'help' : 'La lista de palabras a usar'

                }

            ]

        },

        {
            'argumentos requeridos por el comando \'write\' y \'crack_local\'' : [
                {
                    'args'     : ('-H', '--hash'),
                    'help'     : 'La suma de verificación a atacar'

                },

                {
                    'args'     : ('-t', '--hash-type'),
                    'help'     : 'La función hash a usar'

                }

            ]

            },

        {
            'optionals'       : [
                {
                    'args'    : ('-l', '--lines'),
                    'help'    : 'Dividir el archivo en N líneas para cada servidor',
                    'default' : 1000000,
                    'type'    : int

                },

                {
                    'args'    : ('-i', '--interval'),
                    'help'    : 'El intervalo en segundos para comprobar si el trabajo a concluido',
                    'type'    : int,
                    'default' : 15

                },

                {
                    'args'    : ('-m', '--max-workers'),
                    'help'    : 'El máximo de procesos trabajando en la operación localmente',
                    'default' : multiprocessing.cpu_count(),
                    'type'    : int

                },

                {
                    'args'    : ('-L', '--shake-length'),
                    'help'    : 'La longitud del resultado en la función shake y derivados',
                    'default' : 32,
                    'type'    : int

                }

            ]

        }

    ],
    'version'     : '1.0.0'

}

def get_lines(filename):
    count = 0

    with open(filename, 'r') as fd:
        while (line := fd.readline()):
            count += 1

    return count

def crack(args):
    (wordlist, hash, hash_type) = args
    func = getattr(hashlib, hash_type)

    with open(wordlist, 'r') as fd:
        for i in fd:
            i = i.strip()
            hash2cmp = func(i.encode()).hexdigest()

            if (hash2cmp == hash):
                logging.info('Operación concluida localmente: %s (%s(%s))',
                             hash, hash_type.upper(), i)
                return True

        logging.warning('No se pudo satisfacer la operación localmente')

        return False

def chunk(fd, lines, parts):
    chunks = []

    index = 0
    count = 0

    for i in range(parts):
        chunks.append([])

    while (line := fd.readline()):
        if not (line.strip()):
            continue

        if (index == parts):
            index = 0

            yield chunks

            for i in range(parts):
                chunks[i] = []

        chunks[index].append(line)
            
        if (count == lines):
            index += 1
            count = 0

            continue
            
        count += 1

    if (chunks != []):
        yield chunks

def execute_sql_command(cmd, args=(), write=False):
    with sqlite3.connect(db_name) as sqlite_db:
        cursor = sqlite_db.cursor()
        cursor.execute('CREATE TABLE IF NOT EXISTS jobs(job VARCHAR(32) NOT NULL, network TEXT NOT NULL)')
        sqlite_db.commit()

        cursor.execute(cmd, args)

        if (write):
            sqlite_db.commit()

        else:
            return cursor.fetchall()

def getJob(net):
    result = execute_sql_command(
        'SELECT job FROM jobs WHERE network = ? LIMIT 1', (net,)

    )

    if (result != []):
        return result[0][0]

def writeControl(net, response):
    error = response['error']
    message = response['message']

    if (error):
        logging.warning('Ocurrió un error interno en el servidor "%s": %s', net, message)

    else:
        logging.info('Se ha escrito una parte del diccionario en el servidor %s', net)

def jobsControl(net, response):
    execute_sql_command('INSERT INTO jobs(job, network) VALUES (?, ?)', (response, net), True)

    logging.info('El trabajo "%s" se creó en el servidor "%s"', response, net)

def crackControl(net, response):
    error = response['error']
    message = response['message']

    if (error):
        logging.warning('Ocurrió un error interno en el servidor "%s": %s', net, message)

    else:
        logging.info('Se ha iniciado el ataque en el servidor "%s" 3:-)', net)

def statusControl(net, response):
    error = response['error']
    message = response['message']

    if (error):
        logging.warning('Ocurrió un error interno en el servidor "%s": %s', net, message)

    else:
        if (message == 'running'):
            logging.warning('La operación todavía se sigue efectuando')

        elif (message[:7] == 'success'):
            logging.info('Operación realizada con éxito, se ha obtenido la palabra correcta en la lista de palabras almacenada en el servidor "%s": %s', net, message[8:])

        elif (message == 'fail'):
            logging.warning('No se pudo obtener la palabra con éxito usando la lista de palabras almacenada en el servidor "%s" :-(', net)

        else:
            logging.warning('Estado desconocido en el servidor "%s": %s', net, message)

async def execute_command(net, cmd, data, callback, *args, method='POST', **kwargs):
    url = '%s/erica/%s' % (net, cmd)
    url_hash = hashlib.sha3_224(net.encode()).hexdigest()
    pub_key_file = '%s/servkeys/%s' % (
        server_conf['init_path'], url_hash
    
    )

    UClient = client.UTeslaClient(username)

    await UClient.set_user_keys(public_key, private_key)
    await UClient.set_server_key(pub_key_file)
    
    try:
        result = await UClient.fetch(
            url, data, method=method

        )

    except Exception as err:
        logging.warning('Ocurrió en la petición hacia el servidor "%s": %s', url, err)

        response = None

    else:
        response = UClient.get_message(result.body)

    if (response):
        return callback(net, response, *args, **kwargs)

    else:
        logging.warning('No se obtuvo ningún dato por parte del servidor %s...', net)

async def MainParser(args):
    hash = args.hash
    hash_type = args.hash_type
    wordlist = args.wordlist
    lines = args.lines
    interval = args.interval
    max_workers = args.max_workers
    option = args.option
    shake_length = args.shake_length

    db = await create_pool.create(server_conf['mysql_db'])
    networks = await db.get_networks(show_all=True)
    jobs = []
    
    if (option == 'get_job') and (os.path.isfile(db_name)):
        logging.warning('No se puede obtener nuevos trabajas hasta que se haga un reinicio para evitar alteraciones. Use el comando \'reset\' para permitir esta operación')
        return

    if (wordlist is None) and (option == 'write'):
        logging.warning('¡No se definió la ruta del diccionario a usar!')
        return

    if (hash is None or hash_type is None) and (option == 'write' or option == 'crack_local'):
        logging.warning('Falta definir el \'hash\' y/o la función a usar')
        return

    if (option == 'get_job' or option == 'status' or option == 'crack'):
        callbacks = {
            'get_job' : jobsControl,
            'crack'   : crackControl,
            'status'  : statusControl

        }

        for _, net, token in networks:
            data = {
                'token' : token

            }

            job = getJob(net)

            params = {
                'crack'   : '?id=%s' % (job),
                'status'  : '?id=%s' % (job)

            }

            jobs.append(
                execute_command(net, option + params.get(option, ''), data, callbacks[option], method='GET')

            )

    elif (option == 'write'):
        local_machine = '<Local Machine>'
        networks = networks + ((None, local_machine, None),)
        parts = len(networks)

        with open(wordlist, 'r') as fd:
            with open(tmp_wordlist, 'w', buffering=1) as tmp_fd:
                for words in chunk(fd, lines, parts):
                    for (_, net, token), chunk_val in zip(networks, words):
                        if (net == local_machine):
                            tmp_fd.writelines(chunk_val)

                        else:
                            data = {
                                'token'     : token,
                                'body'      : {
                                    'wordlist'  : chunk_val,
                                    'hash'      : hash,
                                    'hash_type' : hash_type,
                                    'shake_length'    : shake_length

                                }

                            }

                            cmd = 'write?id=%s' % (
                                getJob(net)

                            )

                            logging.warning('Escribiendo %d líneas en %s...', len(chunk_val)-1, net)
                            await execute_command(net, cmd, data, writeControl)

    elif (option == 'crack_local'):
        processes = multiprocessing.Pool(max_workers)
        processes.map(crack, [(tmp_wordlist, hash, hash_type)])
        processes.close()
        processes.join()

    elif (option == 'reset'):
        files2del = [
            tmp_wordlist,
            db_name

        ]

        for file in files2del:
            if (os.path.isfile(file)):
                os.remove(file)
                logging.warning('¡%s se ha eliminado!', file)

    await asyncio.gather(*jobs)

./UTesla
# Si se desea usar la versión 3.8 de python explícitamente
# python3.8 ./UTesla

./UTeslaCLI add -u utesla -p uteslapasswd123@ -i /tmp/key.pub

./UTeslaCLI erica
./UTeslaCLI erica -w /tmp/wordlist.lst -t md5 -H 9d2b9e517b4c13d92a91472d1d1d4acb -o write -l 30000

def __init__(self):
        while True:  
            try:
                self.host = str(input("Host address: "))
                self.ftp = FTP(self.host)
                print(self.ftp.getwelcome())
                break
            except:
                print("Couldn't connect to host")
                pass
 
        self.user = input("Username: ")
        self.passwd = getpass()
        self.ftp.login(self.user, self.passwd)

while True:
    # Pedimos los datos correspondientes

    try:
        host = input("Host address: ")
        user = input("Username: ")
        passwd = getpass.getpass()

    except (EOFError, KeyboardInterrupt):
        # Para no caer en un bucle infinito, es mejor que el usuario
        # rompa el bucle de una manera más limpia, ya sea pulsando
        # CTRL-C o CTRL-D (en Windows creo que sería CTRL-Z).

        print('Operation cancelled by user :-(')
        break

    # Como se puede apreciar se instancia la clase 'ftpClient' por lo
    # cual estaremos separando funcionalidades, por ende mejora el
    # mantenimiento y usabilidad. Ahora tu clase se podría usar en otro
    # código para un uso diferente o podría usarse directamente en el
    # código como lo estamos haciendo.

    try:
        ftpclient = ftpClient(
            host, user, passwd

        )

    except Exception as err:
        # Es recomendable mostrar la excepción al momento de su ejecución
        # porque puede que el error no sea debido a un error de conexión,
        # puede que sea por un error de código o por cualquier cosa que
        # no podremos saber, lo cual generaría conflictos a la hora de
        # arreglarlo o depurarlo.

        print('Couldn\'t connect to host:', str(err))

str(input("Host address: "))

os.system("cls")

import os

def clear():
    if (os.name == 'nt'):
        # Si la máquina es 'Windows' o similar:

        os.system('cls')

    else:
        os.system('clear')

        # Personalmente me gusta más este "hack" que se explicará
        # mejor con enlaces que dejaré dentro de un rato.
        #
        # El siguiente código sería más eficiente que ejecutar
        # 'os.system("clear")' porque usa códigos 'ANSI' en vez
        # de generar muchísimas llamadas y una bifurcación para
        # ejecutar 'clear', aunque usar estos códigos depende de
        # la plataforma y puede generar uno que otro comportamiento
        # inesperado dependiendo de la situación, aun así es 
        # conveniente si no le importa lo que dije xD.
        #
        # print('\033[1J\033[1H', end='')

        print("""
            
             ___    _____  ___       ___    _                     _   
            (  _`\ (_   _)(  _`\    (  _`\ (_ )  _               ( )_ 
            | (_(_)  | |  | |_) )   | ( (_) | | (_)   __    ___  | ,_)
            |  _)    | |  | ,__/'   | |  _  | | | | /'__`\/' _ `\| |  
            | |      | |  | |       | (_( ) | | | |(  ___/| ( ) || |_ 
            (_)      (_)  (_)       (____/'(___)(_)`\____)(_) (_)`\__)
 
            1. Download Files for FTP server
            2. Upload Files for FTP server
        """)

def menu(self):
    ...

def main(self):
    ...

self.option

import requests
import bs4
import re
 
request = requests.get('http://www.python.org.ar/trabajo/')
BeautifulSoup = bs4.BeautifulSoup(request.text, 'html.parser')
body = BeautifulSoup.body
 
for h4 in body.findAll('h4'):
    url = h4.a
 
    if (re.match(r'/trabajo/', url.get('href'))):
        print('URL:', url.get('href'))

URL: /trabajo/devops-engineer-6/
URL: /trabajo/automation-engineer/
URL: /trabajo/senior-javascript-developer-2/
URL: /trabajo/lider-tecnico-desarrollador-backend-django-sql-aws/
URL: /trabajo/senior-python-backend/
URL: /trabajo/back-end-software-engineer/
URL: /trabajo/desarrollador-python-32/
URL: /trabajo/sr-python-dev-con-django/
URL: /trabajo/python-developer-team-leader/
URL: /trabajo/sr-dev-pythonreact-pref-arquitectura-y-nuevos-desa/
URL: /trabajo/python-dev-senior-remoto/
URL: /trabajo/100-remote-python-developer-us-client/
URL: /trabajo/ingeniero-de-requerimientos-sr/
URL: /trabajo/python-developer-53/
URL: /trabajo/ssr-qa-automation-engineer-python-80-remoto/
URL: /trabajo/desarrollador-python-31/
URL: /trabajo/senior-python-developer-100-remoto/
URL: /trabajo/data-engineer-3/
URL: /trabajo/data-analyst-con-tableau-power-bi-qlik-o-google-an/
URL: /trabajo/devops-bash-python-ruby/
URL: /trabajo/senior-python-developer-9/
URL: /trabajo/full-stack-dev-o-front-end-dev/
URL: /trabajo/buscamos-freelance-developer-para-finalizacion-y-m/

conn.send('terminate')

conn.send(command.encode())