elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recopilación Tutoriales y Manuales Hacking, Seguridad, Privacidad, Hardware, etc


  Mostrar Mensajes
Páginas: 1 2 3 [4] 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ... 29
31  Seguridad Informática / Seguridad / ¿Porque el comando shred hace tantas iteraciones (minimo 3) para un borrado seguro? | Seguridad en: 13 Diciembre 2021, 23:23 pm
Buenos dias.

Siempre he tenido una pregunta curiosa sobre el comando shred....

Como bien sabemos el comando shred, nos permite hacer un borrado seguro desde cualquier distribucion.

Yo acostumbro mucho a utilizar estos parametros

Citar
shred -vuz -n 10 <file>

Los parametros son:
  • -u: Elimina el archivo una vez sobrescrito
  • -z: Sobrescribe el archivo a zeros (supongo que es el que se encarga de convertir los bits 1 a 0)
  • -v: Pinta por pantalla el proceso de shred
  • -n: Numero de sobrescrituras que hace antes de eliminar el archivo (si esta el -u)

Ok, hasta aquí lo entiendo, pero la pregunta del millon..... ¿Porque tantas pasadas?

Yo lo entiendo así, y es que, el -z convierte los bits 1 a 0, haciendo que este no se pueda recuperar con alguna herramienta foranea (ejemplo: foremost).

Se dice que (o lo he leido/oido) que cuando más pasadas más seguro es y...¿menos posible de recuperar? eso me suena, pero de donde.

En caso de que se pueda recuperar,¿no es imposible auque sea una unica pasada (sobrescrito una iteracion)?

No acabo de entender porque tantas iteraciones...

Es por mera curiosidad...para entender más sobre su funcionamiento auque no he visto ningún sitio que explicara la razon de las iteraciones....

Además la salida que este imprime en pantalla....como lo interpreto??
Citar
$ shred -uzv -n 5 2021-12-04-23-07-11.031-VBoxSVC-1990.log
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 1/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 2/6 (000000)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 3/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 4/6 (ffffff)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 5/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 6/6 (000000)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: removing
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: renamed to 0000000000000000000000000000000000000000
shred: 0000000000000000000000000000000000000000: renamed to 000000000000000000000000000000000000000
shred: 000000000000000000000000000000000000000: renamed to 00000000000000000000000000000000000000
shred: 00000000000000000000000000000000000000: renamed to 0000000000000000000000000000000000000
shred: 0000000000000000000000000000000000000: renamed to 000000000000000000000000000000000000
shred: 000000000000000000000000000000000000: renamed to 00000000000000000000000000000000000
shred: 00000000000000000000000000000000000: renamed to 0000000000000000000000000000000000
shred: 0000000000000000000000000000000000: renamed to 000000000000000000000000000000000
shred: 000000000000000000000000000000000: renamed to 00000000000000000000000000000000
shred: 00000000000000000000000000000000: renamed to 0000000000000000000000000000000
shred: 0000000000000000000000000000000: renamed to 000000000000000000000000000000
shred: 000000000000000000000000000000: renamed to 00000000000000000000000000000
shred: 00000000000000000000000000000: renamed to 0000000000000000000000000000
shred: 0000000000000000000000000000: renamed to 000000000000000000000000000
shred: 000000000000000000000000000: renamed to 00000000000000000000000000
shred: 00000000000000000000000000: renamed to 0000000000000000000000000
shred: 0000000000000000000000000: renamed to 000000000000000000000000
shred: 000000000000000000000000: renamed to 00000000000000000000000
shred: 00000000000000000000000: renamed to 0000000000000000000000
shred: 0000000000000000000000: renamed to 000000000000000000000
shred: 000000000000000000000: renamed to 00000000000000000000
shred: 00000000000000000000: renamed to 0000000000000000000
shred: 0000000000000000000: renamed to 000000000000000000
shred: 000000000000000000: renamed to 00000000000000000
shred: 00000000000000000: renamed to 0000000000000000
shred: 0000000000000000: renamed to 000000000000000
shred: 000000000000000: renamed to 00000000000000
shred: 00000000000000: renamed to 0000000000000
shred: 0000000000000: renamed to 000000000000
shred: 000000000000: renamed to 00000000000
shred: 00000000000: renamed to 0000000000
shred: 0000000000: renamed to 000000000
shred: 000000000: renamed to 00000000
shred: 00000000: renamed to 0000000
shred: 0000000: renamed to 000000
shred: 000000: renamed to 00000
shred: 00000: renamed to 0000
shred: 0000: renamed to 000
shred: 000: renamed to 00
shred: 00: renamed to 0
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: removed

Si alguíen me lo puede explicar, para entender....se lo agradeceria.

Gracias de antemano.  :D
32  Sistemas Operativos / GNU/Linux / Re: problema al instalar paquetes de escritorio lxde :( en: 8 Diciembre 2021, 01:00 am
Buenas. Intenta hacer un apt-get install -f a ver si puedes descargar las dependencias. Otra manera seria hacerlo manualmente pero es un tostón, pues es muy tedioso.

Espero haberte ayudado.

Sent from my VTR-L09 using Tapatalk
33  Programación / Scripting / Re: ¿Como coger el PID de un proceso hijo que ha hecho Event.set()? | Python3 multiprocessing Event en: 6 Diciembre 2021, 12:23 pm
En realidad, mi pregunta era.... Como matar un proceso zombie cuando el proceso cliente se cierra.








Para solucionar esto lo que hice es.... cuando esta escuchando clientes, además de iniciar un proceso hijo que será el cliente que se quiere conectar, creo un hilo en el proceso padre que estará en escucha de un evento que lo paso como parametro al proceso hijo del cliente.

Y este que se activa al querrer cerrar el cliente, gracias al hilo obtendrá el evento activado y se encargará de unir el proceso hijo del cliente al proceso padre. Después hace un break para acabar el hilo

Y finalmente se cierra el cliente.

Pasos que he hecho:

Primero, cuando escucho a los clientes, añado:
Código
  1. while sockSSL:
  2.    connection, address = sockSSL.accept()
  3.    eventChildStop = multiprocessing.Event()
  4.    subprocess = multiprocessing.Process(target=ClientListener, name="client", args=(connection, address,eventChildStop))
  5.  
  6.    # This thread is responsible of close the client's child process
  7.    threading.Thread(target=ClientListener.exitSubprocess,name="closeChildProcess",args=(eventChildStop,subprocess,)).start()
  8.    subprocess.start()
  9.    time.sleep(1)
  10.  

Después in the nuevo metodo de la clase ClientsListener, cambio:
Código
  1. @staticmethod
  2. def handlerEvent(event,childProcesses):
  3.    while True:
  4.        if event.is_set():
  5.            print(childProcesses)
  6.            # terminate child process
  7.            break
  8.        time.sleep(.5)
  9.  
por
Código
  1. # This method get as argument the process child. For join it at parent process
  2. @staticmethod
  3. def exitSubprocess(event,process):
  4.    while True:
  5.        if event.is_set():
  6.            process.join()
  7.            break
  8.        time.sleep(.5)
  9.  
cambio el nombre del metodo. No es que, añada otro, sino que cambio el nombre.

en el proceso hijo al cerrar le añado un time.sleep de un 1 segundo para que le de tiempo al hijo a unir el proceso hijo al proceso padre.
En el ultimo finally.
Código
  1. class ClientListener:
  2.    def __init__(self,conn,addr,event):
  3.        try:
  4.            self.conn, self.addr = conn, addr
  5.            self.nick = ""
  6.            self.__listenData()
  7.        except (KeyboardInterrupt,SystemExit) as err:
  8.            print(logFile().message(f"The host {self.nick} ({self.addr[0]}:{self.addr[1]}) left", True, "INFO"))
  9.        except BaseException as err:
  10.            type, object, traceback = sys.exc_info()
  11.            file = traceback.tb_frame.f_code.co_filename
  12.            line = traceback.tb_lineno
  13.            print(logFile().message(f"{err} in {file}:{line}", True, "ERROR"))
  14.        finally:
  15.            try:
  16.                ListClients().remove(self.conn)
  17.                self.conn.close()
  18.            except:
  19.                None
  20.            finally:
  21.                Client(self.conn,self.addr).registre(self.nick,"DISCONNECTED",False)
  22.                event.set()
  23.                # This will delay 1 second to close the proccess, for this gives time at exitSubprocess method to join the client's child process with the parent process
  24.                time.sleep(1)
  25.  

Muchas gracias por vuestra atención y tiempo  :D
34  Programación / Bases de Datos / Re: ayuda relacionar tablas en: 14 Noviembre 2021, 15:25 pm
Aquí el campo dinero de la primera tabla sobra.
el campo edad debe ser un FK a la PK de la segunda tabla


-----------------------------------------
|     PRIMERA TABLA              |
-----------------------------------------
|  #* id  INT(11)                         |
|  *   nombre VARCHAR(20)     |
|  F* edad INT(3)                      |
|________________________|
                   \ | / (M)
                     |
                     |   (N)
-----------------------------------------
|     SEGUNDA TABLA              |
-----------------------------------------
|  #* id  INT(11)                         |
|    * edad INT(3)                       |
|    * dinero INT(20)                   |
------------------------------------------

Eso se hace con SQL. Creo que y lo más seguro es que PHPMyAdmin te permita hacer relaciones M:N por interfaz. El codigo sería

Código
  1. CREATE TABLE PRIMERA_TABLA (
  2.   id INT(11) NOT NULL AUTO_INCREMENT,
  3.   nombre VARCHAR(20) NOT NULL,
  4.   edad INT(3) NOT NULL,
  5.   CONSTRAINT PRIMERA_TABLA_PK PRIMARY KEY (id)
  6. );
  7.  
  8. CREATE TABLE SEGUNDA_TABLA (
  9.   id INT(11) NOT NULL AUTO_INCREMENT,
  10.   edad INT(3) NOT NULL,
  11.   dinero INT(20) NOT NULL,
  12.   CONSTRAINT SEGUNDA_TABLA_PK PRIMARY KEY (id)
  13. );
  14.  
  15. ALTER TABLE PRIMERA_TABLA ADD CONSTRAINT PRIMERA_TABLA_PK FOREIGN KEY (edad) REFERENCES SEGUNDA_TABLA(id);
  16.  
35  Programación / Scripting / ¿Como coger el PID de un proceso hijo que ha hecho Event.set()? | Python3 multiprocessing Event en: 13 Noviembre 2021, 20:47 pm
Buenas. Estoy haciendo una arquitectura servidor-multicliente con sockets in python3

Para esto utilizo la libreria multiprocessing
Código
  1. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  2. sock.bind(("",PORT))
  3. sock.listen(CLIENTS)
  4. print(logFile().message(f"running ClassAdmin server, listen {CLIENTS} clients by port {PORT}...",True,"INFO"))
  5. sockSSL = context.wrap_socket(sock,server_side=True)
  6. childProcess = [] # This storages the childs processes
  7. event = multiprocessing.Event() # listening events of childs processes
  8. threading.Thread(target=Client.handlerEvent,name="exitChildProcess",args=(event,childProcess,)).start()
  9. while sockSSL:
  10.    connection, address = sockSSL.accept()
  11.    subproccess = multiprocessing.Process(target=Client,name="client",args=(connection,address,event))
  12.    subproccess.start()
  13.    childProcess.append(subproccess)
  14.    time.sleep(1)
  15.  
En este código, la variable  'event' is un evento de la libreria multiprocessing que esta en escucha de que algún proceso hijo lo active.

Código
  1. threading.Thread(target=Client.handlerEvent,name="exitChildProcess",args=(event,childProcess,)).start()
  2.  

Ejecuto un hilo que ejecutará el metodo estatico handlerEvent de la clase Client que se encargará de ver si la variable 'event' es activado
Código
  1. @staticmethod
  2. def handlerEvent(event,childProcesses):
  3.    while True:
  4.        if event.is_set():
  5.            print(childProcesses)
  6.            # terminate child process
  7.            break
  8.        time.sleep(.5)
  9.  

En el while ejecuto un subproceso, haciendo que para cada cliente que se conecte este se ejecutará en un proceso hijo.

La clase Client es la siguiente:
Código
  1. class Client:
  2. def __init__(self,conn,addr,event):
  3.    try:
  4.        self.conn, self.addr = conn, addr
  5.        print(logFile().message(f"Client {self.addr[0]} connected by port {self.addr[1]}", True, "INFO"))
  6.        self.__listenData()
  7.    except (KeyboardInterrupt,SystemExit) as err:
  8.        print(logFile().message(f"The client {self.addr[0]} left", True, "INFO"))
  9.    except BaseException as err:
  10.        type, object, traceback = sys.exc_info()
  11.        file = traceback.tb_frame.f_code.co_filename
  12.        line = traceback.tb_lineno
  13.        print(logFile().message(f"{err} in {file}:{line}", True, "ERROR"))
  14.    finally:
  15.        try:
  16.            self.conn.close()
  17.        except:
  18.            None
  19.        finally:
  20.            event.set()
  21. #[...]
  22. @staticmethod
  23. def handlerEvent(event,childProcesses):
  24.    while True:
  25.        if event.is_set():
  26.            print(childProcesses)
  27.            # terminate child process
  28.            break
  29.        time.sleep(.5)
  30.  

La idea es la siguiente:
El cliente se conecta y este se ejecuta la clase Client en un proceso hijo. Y así para cada cliente que se conecte. En el segundo cliente se ejecuta la clase Client en otro proceso hijo y así consecutivamente....

Vale, pues. El init de la clase tengo try...except para si el cliente se cierra este ejecuta el exception (alguno de los dos). Pero siempre cuando se cierra un cliente se ejecutará el finally (el primero). Que se encargará de hacer:
Código
  1. self.conn.close()
  2.  
Y después se ejecutará el finally:
Código
  1. event.set()
  2.  

Por la cual el metodo handlerEvent de la clase Client detectará que el event es true
Código
  1. @staticmethod
  2. def handlerEvent(event,childProcesses):
  3.    while True:
  4.        if event.is_set():
  5.            print(childProcesses)
  6.            # terminate child process
  7.            break
  8.        time.sleep(.5)
  9.  
y ejecutará lo que hay dentro del if. Mi idea es coger el PID del proceso hijo que ha hecho el event.set(). Pues así puedo hacer un for y matar el proceso que coincida con el PID. Pero como lo hago?



En el cliente cuando hago el:
Código
  1. event.set()
  2.  
puedo obtener el PID del proceso hijo haciendo:
Código
  1.        finally:
  2.            print(os.getpid())
  3.            event.set()
  4.  

Sí hago esto si me obtiene el PID del hijo, pues este PID tendría que enviarlo al handlerEvent() como puedo hacer esto?





Si alguíen tiene alguna idea de como puedo hacerlo o alguna alternativa, lo agradeceria.

Gracias.
36  Programación / Scripting / Re: necesito ayuda con un problema en python soy nuevo en esto en: 13 Noviembre 2021, 20:19 pm
Código
  1. import subprocess
  2. import optparse
  3.  
  4. parser = optparse.OptionParser()
  5.  
  6. parser.add_option("-i", "--interface", dest = "interface", help="Interface para cambiar Direccion MAC")
  7. parser.add_option("-m", "--mac", dest = "new_mac", help="Nueva Direccion MAC")
  8.  
  9.  
  10. (options, arguments) = parser.parse_args()
  11.  
  12. interface = options.interface
  13. new_mac = options.new_mac
  14.  
  15. print("Cambiando Direccion Mac para " + interface + " a " + new_mac)
  16.  
  17. subprocess.call(["sudo ifconfig", interface, "down"])
  18. subprocess.call(["sudo ifconfig", interface, "hw", "ether", new_mac])
  19. subprocess.call(["sudo ifconfig", interface, "up"])
  20.  

┌──(kali㉿kali)-[~]
└─$ /usr/bin/python /home/kali/Documents/mac-changer.py                                                                                                                                          1 ⨯
Traceback (most recent call last):
  File "/home/kali/Documents/mac-changer.py", line 15, in <module>
    print("Cambiando Direccion Mac para " + interface + " a " + new_mac)
TypeError: cannot concatenate 'str' and 'NoneType' objects

MOD: Etiqueta GeSHi

Cuando quieres concatenar string con una variable, en python debes de convertir de la salida de esta variable en un string. Para poderlo hacer hay varias formas:

metodo con str():
Código
  1. print("Cambiando Direccion Mac para " + str(interface) + " a " + str(new_mac))
  2.  

metodo 2:
Código
  1. print(f"Cambiando Direccion Mac para {interface} a {new_mac}")
  2.  

Además veo que la salida de algunas de las variables devuelve None. Por eso te dice NoneType

Recomendación al postear:
Te recomiendo que al postear detalles lo más posible el problema. No se especifica que tipo de valores (string,int...) debe de retornar interface ni new_mac. Me imagino que es string pero no estoy seguro.
37  Programación / Scripting / Como obtengo los datos de la autorizacion (Basic Auth) en un request API | Python Django en: 18 Septiembre 2021, 21:33 pm
Buenos dias, ¿como estais?  :D

Tengo un pequeño problemilla. Os cuento, estoy haciendo una API en Django [sin Django REST Framework  :silbar:] y esta API el usuario puede utilizarla si se autentifica con metodo Basic Auth

Donde pone Username es la Password
Y donde pone password es el OTP

Mi API hace esto:
Código
  1. @csrf_exempt
  2.    def requests(self,req,table:str,columns:list=False):
  3.        try:
  4.            try:
  5.                if not loginAdmin(req.headers['password'], int(req.headers['otp'])):
  6.                    raise Exception("Access denied")
  7.            except:
  8.                raise Exception("You need authentication")
  9.            conn = sqlite3.connect(Environment().pathDB())
  10.            cursor = conn.cursor()
  11.  
es parte del codigo, pues yo estoy aqui seleccionando las keys password y otp del header, pero segun me he informado de que se muestra en el header en la key "Authorization" con encriptacion BASE64
https://learning.postman.com/docs/sending-requests/authorization/#basic-auth

Pero yo he hecho return de req.headers y no hay ninguna key llamada "Authorization" o "Authorization", pero en el postman si se ve

He estado buscando info y segun dicen si con req.META hay una HTTP_AUTHORIZATION, pero no se muestra ninguno
Citar
GATEWAY_INTERFACESERVER_PROTOCOLREQUEST_METHODQUERY_STRINGREQUEST_URISCRIPT_NAMEPATH_INFOPATH_TRANSLATEDHTTP_HOSTHTTP_USER_AGENTHTTP_ACCEPT_ENCODINGHTTP_ACCEPTHTTP_CONNECTIONSERVER_SIGNATURESERVER_SOFTWARESERVER_NAMESERVER_ADDRSERVER_PORTREMOTE_ADDRDOCUMENT_ROOTREQUEST_SCHEMECONTEXT_PREFIXCONTEXT_DOCUMENT_ROOTSERVER_ADMINSCRIPT_FILENAMEREMOTE_PORTmod_wsgi.script_namemod_wsgi.path_infomod_wsgi.process_groupmod_wsgi.application_groupmod_wsgi.callable_objectmod_wsgi.request_handlermod_wsgi.handler_scriptmod_wsgi.script_reloadingmod_wsgi.listener_hostmod_wsgi.listener_portmod_wsgi.enable_sendfilemod_wsgi.ignore_activitymod_wsgi.request_startmod_wsgi.request_idmod_wsgi.script_startwsgi.versionwsgi.multithreadwsgi.multiprocesswsgi.run_oncewsgi.url_schemewsgi.errorswsgi.inputwsgi.input_terminatedwsgi.file_wrapperapache.versionmod_wsgi.versionmod_wsgi.total_requestsmod_wsgi.thread_idmod_wsgi.thread_requests

Aqui dejo la API:
Código
  1. from sources import loginAdmin,Environment,logFile
  2. import sqlite3,re
  3. from django.urls import  path
  4. from django.http import JsonResponse, HttpResponse, QueryDict
  5. from django.views.decorators.csrf import csrf_exempt
  6.  
  7. """
  8. ==========================API REST==========================
  9. SYNTAX:
  10.    127.0.0.1/api[/table,table1,table3,...][/column]?<key>=[>|<|>=|<=]<value>&[|]<key>=[>|<|>=|<=]<value>&LIMIT=<min>[,max]
  11. ============================================================
  12. IMPORTANT:
  13.    For do a request you need authentication with password and OTP
  14.  
  15. EXAMPLES:
  16.    GET:
  17.        127.0.0.1/api/server -> SELECT * FROM server
  18.        127.0.0.1/api/server?LIMIT=5 -> SELECT * FROM server LIMIT 5
  19.        127.0.0.1/api/server?password=ejem&id=1&LIMIT=5,7 -> SELECT * FROM server WHERE password='ejem' AND id=1 LIMIT 5,7
  20.        127.0.0.1/api/server/otp,id -> SELECT otp,id FROM server
  21.        127.0.0.1/api/server/otp?id=1&password=hola -> SELECT otp FROM server WHERE id=1 AND password='hola'
  22.        127.0.0.1/api/server/otp?id=1&|password=hola -> SELECT otp FROM server WHERE id=1 OR password='hola'
  23.  
  24.    POST:
  25.        127.0.0.1/api/server -> INSERT INTO server (otp,ejem) VALUES (1234,'1233da')
  26.            Body x-www-form-urlencoded
  27.                key     value
  28.                --------------------
  29.                otp     1234
  30.                ejem    1233da
  31.  
  32.        IMPORTANT: The params in the url doesn't affect
  33.  
  34.    PUT:
  35.        127.0.0.1/api/server?port=8899&|password=h -> UPDATE server SET otp='1234', ejem='1233da' WHERE port=8899 OR password='h'
  36.            Body x-www-form-urlencoded
  37.                key     value
  38.                --------------------
  39.                otp     1234
  40.                ejem    1233da
  41.  
  42.    DELETE:
  43.        127.0.0.1/api/server?port=8899&password=h -> DELETE FROM server WHERE port=8899 AND password='h'
  44.            not body data
  45. """
  46.  
  47. class getData:
  48.    def __init__(self,data):
  49.        self.list = QueryDict(data)
  50.        self.output = ''
  51.  
  52.    # This method returns key1,key2,key3...
  53.    # For clause as SELECT, INSERT
  54.    def getKeys(self):
  55.        for t in self.list:
  56.            self.output+=f'{t},'
  57.        self.output = re.sub(r",$","",self.output)
  58.        return self.output
  59.  
  60.    # This method returns value1,value2,value3...
  61.    # For clause as SELECT, INSERT
  62.    def getValues(self):
  63.        for t in self.list:
  64.            try:
  65.                if int(self.list[t]):
  66.                    self.output+=f'{self.list[t]},'
  67.            except:
  68.                self.output += f"'{self.list[t]}',"
  69.        self.output = re.sub(r",$","",self.output)
  70.        return self.output
  71.  
  72.    # This method returns key1=value1, key2=value2, key3=value3
  73.    # being '=' the 'delimitator'
  74.    # For clause as UPDATE
  75.    def keysValues(self,delimitator):
  76.        for value in self.list:
  77.            self.output+=f"{value}{delimitator}'{self.list[value]}', "
  78.        self.output = re.sub(r", $", "", self.output)
  79.        return self.output
  80.  
  81. class Database:
  82.    # if there are columns, show it
  83.    def columns(self,columns):
  84.        if columns:
  85.            return  columns
  86.        else:
  87.            return "*"
  88.  
  89.    # This method add the operator specified in the url
  90.    def keyWhere(self,key):
  91.        operator = re.sub(r"[^>|<|=]","",key)
  92.        value = re.sub(r"[>|<|=]","",key)
  93.        if operator == "":
  94.            operator="="
  95.        try:
  96.            if int(value):
  97.                return f"{operator}{value}"
  98.        except:
  99.            return f"{operator}'{value}'"
  100.  
  101.    def LimitClause(self,params):
  102.        if params:
  103.            output = ''
  104.            for key in params:
  105.                if key=="LIMIT":
  106.                    output=f" LIMIT {params[key]}"
  107.            return output
  108.        else:
  109.            return ""
  110.  
  111.    # This method add AND or OR in each condition in WHERE
  112.    def WhereClause(self,params):
  113.        if params:
  114.            output=''
  115.            for key in params:
  116.                if key=="LIMIT":
  117.                    continue
  118.                operator = "OR" if key[0]=="|" else "AND"
  119.                if list(params).index(key) > 0:
  120.                    output+=f" {operator} {key[1::] if operator=='OR' else key}{self.keyWhere(params[key])}"
  121.                else:
  122.                    output += f"WHERE {key[1::] if operator=='OR' else key}{self.keyWhere(params[key])}"
  123.            return output
  124.        else:
  125.            return ""
  126.  
  127.    @csrf_exempt
  128.    def requests(self,req,table:str,columns:list=False):
  129.        try:
  130.            try:
  131.                if not loginAdmin(req.headers['password'], int(req.headers['otp'])):
  132.                    raise Exception("Access denied")
  133.            except:
  134.                raise Exception("You need authentication")
  135.            conn = sqlite3.connect(Environment().pathDB())
  136.            cursor = conn.cursor()
  137.            if req.method == "GET":
  138.                data = cursor.execute(f"SELECT {self.columns(columns)} FROM {table} {self.WhereClause(req.GET.dict())}{self.LimitClause(req.GET.dict())}")
  139.                data = list(data)
  140.                conn.close()
  141.                if len(data) == 0:
  142.                    data = None
  143.                return JsonResponse({
  144.                    "result": data
  145.                })
  146.            elif req.method == "POST":
  147.                if columns:
  148.                    raise Exception("POST not allowed")
  149.                cursor.execute(f"INSERT INTO {table} ({getData(req.body).getKeys()}) VALUES ({getData(req.body).getValues()})")
  150.                conn.commit()
  151.                conn.close()
  152.                return JsonResponse({"INSERT":True})
  153.            elif req.method == "PUT":
  154.                if columns:
  155.                    raise Exception("PUT not allowed")
  156.                cursor.execute(f"UPDATE {table} SET {getData(req.body).keysValues('=')} {self.WhereClause(req.GET.dict())}")
  157.                conn.commit()
  158.                conn.close()
  159.                return JsonResponse({"UPDATE": True})
  160.            elif req.method == 'DELETE':
  161.                if columns:
  162.                    raise Exception("DELETE not allowed")
  163.                cursor.execute(f"DELETE FROM {table} {self.WhereClause(req.GET.dict())}")
  164.                conn.commit()
  165.                conn.close()
  166.                return JsonResponse({"DELETE": True})
  167.        except sqlite3.Error as err:
  168.            return HttpResponse(logFile(True).message(f"DB -> {err}",True))
  169.        except Exception as err:
  170.            return HttpResponse({f"Error in the API REST -> {err}"})
  171. urlpatterns=[
  172.    path('<table>',Database().requests),
  173.    path('<table>/<columns>',Database().requests)
  174. ]
  175.  

¿Como yo puedo mostrar los datos del Auth? Muchas gracias.

P.D: Cualquier comentario, sugerencia u opinion sobre la mejora del código, lo agradecería mucho. Mil gracias.
38  Programación / Scripting / Re: Ya voy 11 meses estudiando Python en: 12 Septiembre 2021, 23:44 pm
@Panic0

Por lo general las librerías se aprenden en base a las necesidades que tengas. Si necesitas hacer una petición HTTP, te das cuenta que existe una librería muy buena llamada requests, pero luego te das cuenta que necesitas realizar peticiones asincrónicas, entonces ves que aiohttp es para ti. Quizá lo que necesites es procesar grandes cantidades de datos desde un CSV o una hoja de cálculo, entonces pandas puede ser para ti. Pero quizá necesites conectarte a una base de datos de MSSQL, entonces pyodbc es para ti, aunque quizá quieras algo más específico como el conector de MySQL o quizá SQLAlchemy dado que prefieres crear y mantener el esquema de las tablas con código de python o un estilo pythonista (un ORM, básicamente), o quizá quieras irte por una base de datos NOSQL como MongoDB, entonces mongoengine pueda adaptarse a ti. Quizá quieras combinar todo esto, pero también desees proporcionar una manera para que otras aplicaciones puedan conectarse con tus funcionalidades, entonces quizá te interese crear una API, lo cual puedes hacer con FastAPI, por ejemplo, o cualquier otro framework capaz.

Como ves, no es aprender siguiendo unos pasos, es algo muy dinámico.

~ DtxdF
Estoy de acuerdo en lo que dice @DtxdF, a medida que vayas haciendo proyectos veras diferentes librerias y sus funcionamientos. Si quieres aprender librerias orientadas a hacking etico, lo mejor es que hagas proyectos orientados a esta tematica, aquí te dejo unas cuantas:
- Fuerza Bruta
- Backdoor
- Scrapping Web
- Proxy server
- keylogger
- Ramsomware

Son proyecto un tanto complejos, pero puedes empezar por algo básico como el Brute Force y Backdoor. Lo recomiendo hacerlos, para entender como funcionan estos tipos de malwares
39  Programación / Scripting / Re: Curso django en: 12 Septiembre 2021, 23:37 pm
Hola a todos, alguien tiene/conoce algún curso gratuito de python3 django??



Gracias


-P
Buenas
Tienes un curso super bien en Youtube en el canal de PildorasInformaticas: https://www.youtube.com/watch?v=7XO1AzwkPPE&list=PLU8oAlHdN5BmfvwxFO7HdPciOCmmYneAB
40  Programación / Scripting / Acceder a una variable de una clase de un modulo python desde el exterior en: 12 Septiembre 2021, 23:36 pm
Código:
.
├── ClassAdmin
│   ├── ClassAdmin
│   │   ├── __init__.py
│   │   ├── settings.py
│   │   ├── static
│   │   │   ├── css
│   │   │   │   ├── fonts.css
│   │   │   │   ├── pageLogin.css
│   │   │   │   └── styles.css
│   │   │   ├── data.json
│   │   │   ├── fonts
│   │   │   │   └── Allura-Regular.ttf
│   │   │   ├── images
│   │   │   │   ├── ClassAdminLogo.png
│   │   │   │   └── wallpaper.png
│   │   │   └── js
│   │   ├── templates
│   │   │   ├── pageLogin.html
│   │   │   └── src
│   │   │       └── base.html
│   │   ├── urls.py
│   │   ├── views.py
│   │   └── wsgi.py
│   ├── ClassAdmin.sqlite3
│   └── manage.py
└── sources
    └── __init__.py

Buenas, tengo un modulo llamado sources que es una carpeta con el archivo __init__.py, en el propio archivo esta la siguiente clase:
Código
  1. class Environment:
  2.    def __init__(self):
  3.        self.directory = os.environ.get("CLASSADMIN")
  4.    def pathDB(self):
  5.        if platform.system() == "Windows":
  6.            return f"{self.directory}\\ClassAdmin\\ClassAdmin.sqlite3"
  7.        elif platform.system() == "Linux":
  8.            return f"{self.directory}/ClassAdmin/ClassAdmin.sqlite3"
  9.    def pathLog(self,name:str):
  10.        if platform.system() == "Windows":
  11.            return f"{self.directory}/{name}.log"
  12.        elif platform.system() == "Linux":
  13.            return f"/var/log/{name}.log"
  14.  
  15.  

Y desde el archivo settings.py haciendo el import quiero acceder a la variable directory que esta en el init de la clase Environment.
Código
  1. from sources import *
  2. STATIC_ROOT = f'{Environment().directory}/ClassAdmin/ClassAdmin/static'
  3.  
Pero esto me devuelve None
Citar
[Errno 2] No such file or directory: 'None/ClassAdmin/ClassAdmin/static/data.json'

Porque pasa esto? si al hacer una clase con una variable self en el init puedes acceder a ella, no entiendo.

Que esta ocurriendo?
Gracias
Páginas: 1 2 3 [4] 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ... 29
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines