Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - WhiZ

Páginas: [1] 2 3 ... 16
1
Debates / Seguridad informática: ¿trabajo o hobbie?
« en: Abril 22, 2016, 09:59:26 pm »
Buenas a todos los underc0ders!

Hace mucho que, por diversas cuestiones, se me hace imposible participar en el foro y aportar con algún tutorial, una app o alguna de esas cosas que tanto me gusta. Sin embargo, hoy estuve pensando en algo que me llamó bastante la atención y se me ocurrió que podría ser un aporte interesante.

Actualmente, me encuentro trabajando como médico informático (una mezcla media rara jeje) y, más allá de los detalles, por primera vez tengo la posibilidad de ver un área de seguridad informática en acción.

Tantos años en este foro me llevaron a crearme una imagen del experto en seguridad informática que, al menos en mi caso, contrasta mucho con la imagen de la 'realidad'. En la empresa en la que trabajo, es muy común encontrar vulnerabilidades y es fácil evadir algunos mecanismos de seguridad desarrollados por el área de seguridad informática. Por otro lado, las personas que trabajan en dicha área, no son pentesters o algo así, sino que se la pasan evaluando usuarios y perfiles,  permisos de acceso por usuario / ip, etcétera. Parece, más bien, un trabajo administrativo y no el gran reto que yo siempre imaginé que tendría un experto en seguridad informática.

Todo esto me llevó a preguntarme: ¿generalmente es así el trabajo en este área? ¿Hace falta ser un experto reconocido o trabajar en una empresa que se dedique, específicamente, a hacer auditorías de seguridad informática para hacer la parte más interesante de esta profesión? De ser así, ¿sería más interesante y reconfortante hacerlo como hobbie?

Creo que este tema, además de interesante, resulta de mucha importancia, sobre todo para aquellos que piensan vivir de esto y que se pueden llevar una gran sorpresa el día de mañana, ¿no es así?

¿Qué opinan ustedes?

Enviado desde mi GT-I8260L mediante Tapatalk


2
Dudas y pedidos generales / Re:Python error.
« en: Marzo 12, 2016, 04:37:45 pm »
Buenas.

Lo mejor es que compartas tanto el código como el error. Para ver el error, abrí el cmd, movete hasta el directorio donde se encuentra el script (aparentemente el escritorio) y ejecutalo. No tendría porqué cerrarse la consola.

Más allá de este error en particular, es muy importante ver el código ya que inspeccionándolo, rápidamente podemos ver qué otros errores pueden llegar a existir.

Saludos!

3
Presentaciones / Re:Saludos soy JJx ("Nuevo")
« en: Enero 04, 2016, 12:28:55 am »
Bienveniodo @JJx! Es un gusto tenerte con nosotros!

Estamos para cualquier cosa que necesites. No dudes en traer preguntas que con ellas aprendemos todos :)

Saludos!
WhiZ

4
Python / [Python] Underch4t v1.0 (Parte 4)
« en: Enero 03, 2016, 09:34:09 pm »

UnderCh4t



Bienvenidos a la cuarta entrega de esta serie. Poco a poco vamos armando nuestro humilde pero querido UnderCh4t. Si es la primera vez que escuchás hablar de esta serie o, por el contrario, ya lo hiciste pero te interesa repasar algunos conceptos, entonces te invito a pasar por los posts anteriores:

    - Parte 1 - Creación del servidor
    - Parte 2 - Interfaz de conexión
    - Parte 3 - Poniendo al servidor en escucha y aceptando conexiones entrantes

Muy bien. Mencionamos dos problemas al final de la tercera entrega:
    - establecer una charla con el cliente (intercambiar información)
    - recibir más de un cliente y de forma simultánea.

Debido a que el tema de threading es un poco complejo (sólo un poco jeje), lo vamos a ir explicando de a poco, en dos entregas o más (dependerá del tiempo que disponga para escribir). Hoy, mientras tanto, nos enfocaremos en el primero de los problemas citados. Comencemos!



INTERCAMBIANDO INFORMACIÓN


Como vimos en la entrega anterior, hasta ahora no le damos un buen servicio al cliente. Cada vez que se conecta, se imprime su dirección de red y se cierran ambos sockets (el del cliente y el del servidor). Repasemos el código:

Código: Python
  1. # -*- coding: utf-8 -*-
  2. import socket
  3.  
  4. # creamos socket para el servidor
  5. servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6.  
  7. # establecemos interfaz de conexión
  8. servidor.bind(("0.0.0.0", 2236))
  9.  
  10. # modo pasivo y backlog
  11. servidor.listen(5)
  12.  
  13. # aceptamos al cliente
  14. cliente, direccion = servidor.accept()
  15.  
  16. print cliente
  17. print direccion
  18.  
  19. cliente.close()
  20. servidor.close()

Nuestro objetivo es mantener la conexión hasta que ambas partes decidan cerrarla. Sólo es posible saber eso si primero realizamos un intercambio de información entre ambas partes. Es decir, el servidor nunca se enterará que el cliente desea cerrar la conexión, al menos que reciba un mensaje por parte de él (y viceversa).

Por suerte, el objeto socket posee dos métodos que nos permiten hacer esto de forma sencilla: send y recv.

Para ser fieles a nuestras costumbres, recurramos a la documentación oficial y veamos cómo funciona cada uno.

El método send, como su nombre lo indica, nos permite enviar información al socket al que estamos conectados (ya sea cliente o servidor). Su sintaxis es la siguiente:

Código: Python
  1. data = "mensaje"
  2. flags = 0
  3. socket.send(data, flags)

Como vemos, el método recibe dos argumentos:
    - data: es la información que queremos transmitir.
    - flags: este argumento, de tipo entero y opcional, nos permite establecer cómo queremos que se envíe la información. Su valor, por defecto, es cero. Podemos ver otros de sus posibles valores por aquí.

Al finalizar, nos devuelve el número de bytes que fueron enviados. Esto es importante por el hecho de que somos nosotros, por medio de nuestra aplicación, los que debemos llevar la cuenta de cuántos bytes hemos enviado y cuántos quedan por enviar.

Por último, también es importante saber que este método es bloqueante, es decir, la aplicación quedará detenida en este punto hasta que finalice el envío de información.

El método recv es bastante similar al anterior y nos permite recibir la información enviada por el socket al que estamos conectados (ya sea cliente o servidor). Su sintaxis es la siguiente:

Código: Python
  1. bufsize = 1024
  2. flags = 0
  3. socket.recv(bufsize, flags)

Al igual que el método anterior, los argumentos que recibe son dos:
    - bufsize: es un entero que indica la cantidad máxima de datos que se recibirán por vez. Tal como se comenta en la documentación, se recomienda utilizar pequeñas potencias de 2 (por ejemplo, 1024, 2048 o 4096).
    - flags: este argumento, de tipo entero y opcional, nos permite establecer cómo queremos que se reciba la información (sí, es casi idéntico al argumento del método send). Su valor por defecto es cero pero podemos utilizar cualquiera de los flags que vemos por aquí.

Al finalizar, el método devuelve una dato de tipo str que corresponde al mensaje enviado por el otro extremo de la conexión.

De forma similar al anterior, este método es bloqueante. La aplicación se estancará en este punto hasta finalizar de recibir toda la información.

Muy bien. Ahora que ya sabemos como enviar y recibir información, es hora de codear un poco.

servidor.py
Código: Python
  1. # -*- coding: utf-8 -*-
  2. import socket
  3.  
  4. # creamos el socket del servidor
  5. servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6.  
  7. # establecemos interfaz de conexión
  8. servidor.bind(("0.0.0.0", 2236))
  9.  
  10. # modo pasivo y backlog
  11. servidor.listen(5)
  12.  
  13. # aceptamos conexiones entrantes
  14. cliente, direccion = servidor.accept()
  15.  
  16. # enviamos un mensaje al cliente
  17. msj = "Bienvenido a UnderCh4t! Escribí '/desconectar' para salir."
  18. cliente.send(msj)
  19.  
  20. # creamos un bucle para recibir información enviada por el cliente
  21. while True:
  22.     # recibimos la información enviada por el cliente
  23.     recv = cliente.recv(1024)
  24.  
  25.     # formateamos la información
  26.     recv = recv.lower().strip()
  27.  
  28.     # verificamos si hay que finalizar la conexión
  29.     if recv == "/desconectar":
  30.         cliente.close()
  31.         break
  32.  
  33.     # imprimimos en pantalla la información recibida
  34.     print recv
  35.  
  36. # cerramos el servidor
  37. servidor.close()

Quiero dejar en claro que hay muchas cosas que estamos dejando de lado. Esto lo digo por varias cosas pero, principalmente, por los errores y el manejo de los mismos. Poco a poco iremos mejorando nuestro código. Por ahora, sólo me interesa transmitir, uno a uno, los conceptos que vamos tratando.

Para los que se están preguntando por la línea en la que formateamos la información, les recuerdo que recv es una variable de tipo str, por lo que lower y strip son dos de sus tantos métodos (más información por aquí: lower - strip).

Si ponemos en marcha nuestro nuevo servidor, veremos que hemos ganado un poco de funcionalidad. El servidor se quedará recibiendo mensajes del cliente hasta que éste le indique su intención de cerrar la conexión (enviando el mensaje "/desconectar").

Muy bien. Esto es todo por hoy. Hagan pruebas, jueguen y experimenten con su servidor. Paciencia que en algún momento nos meteremos con el cliente. Mientras tanto, pueden usar telnet o netcat (recomiendo este último).

Saludos y hasta la próxima!
WhiZ

5
Python / Re:[Python] Underch4t v1.0 (Parte 3)
« en: Enero 02, 2016, 11:12:29 pm »
Duda: Al usar socket.accept() permito un cliente,posterior a recibirlo veo su IP:Puerto. Qué sucede si quiero prefiltrar IP's  previo a darle accept() para no tener que abrir/cerrar la petición del cliente? (por cualquier razón, quizá un baneo temporal)

Hola @po6xsecpo. Lamentablemente, eso no es posible, ni en python ni en ningún otro lenguaje. Lo único que podés hacer es algo así:
Código: Python
  1. import socket
  2.  
  3. blacklist = []
  4.  
  5. server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6. server.bind(("0.0.0.0", 2236))
  7.  
  8. server.listen(5)
  9. conn, address = server.accept()
  10.  
  11. if address[0] in blacklist:
  12.     conn.close()

Saludos!
WhiZ

6
Python / [Python] Underch4t v1.0 (Parte 3)
« en: Enero 02, 2016, 01:33:12 pm »

UnderCh4t



Bienvenidos a la tercera entrega de UnderCh4t, un sencillo chat en python que nos ayudará a comprender algunos de conceptos de gran importancia para todo programador.

Si es la primera vez que escuchás hablar de este tutorial, te recomiendo que pases primero por estos posts:
    - Parte 1
    - Parte 2

Bien. Si hacemos un poco de memoria, en las entregas pasadas hemos estado enfocándonos en nuestro servidor. Más concretamente, hemos aprendido a crear un socket y a establecer una interfaz de conexión. Con todo esto, ya estamos en condiciones de poner a trabajar a nuestro servidor. Veamos cómo... ;)



PONIENDO AL SERVIDOR EN ESCUCHA


Debido a que esta vez las cosas van a ser un poco más complicadas, lo que voy a hacer es lo siguiente: primero, vamos a repasar las cosas que ya vimos en las entregas anteriores; en segundo lugar, vamos a poner el servidor en escucha y a atender las conexiones entrantes -es decir, los clientes que se conecten al servidor-.

Ya sabemos cómo crear el servidor y establecer la interfaz de conexión:
Código: Python
  1. # -*- coding: utf-8 -*-
  2. import socket
  3.  
  4. # creamos el socket
  5. mi_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6.  
  7. # establecemos interfaz de conexión
  8. ip = "127.0.0.1"
  9. puerto = 8000
  10. mi_socket.bind((ip, puerto))

Bueno, muy fácil hasta aquí. Lo que viene ahora es poner el servidor en escucha. Sin embargo, antes me gustaría charlar algunas cosas. Sé que todavía no tocamos el tema de los clientes pero voy a ir adelantando algunas cosas (nada que los vaya a complicar, no se preocupen). Tal como hacemos con el servidor, al momento de crear un cliente debemos definir un socket. ¿Cómo lo hacemos? Tan simple como esto:

Código: Python
  1. import socket
  2.  
  3. mi_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Mmm... Esto me resulta bastante familiar, ¿no les parece? Sí. Esta misma línea la usamos para crear el socket en nuestro servidor. Interesante, ¿no?

Esto significa que cada vez que creamos un socket, éste sirve tanto para crear un servidor como un cliente, y debemos, por tanto, indicar qué rol tendrá el mismo en la conexión. En el caso del servidor (al cliente lo veremos en otro momento), lo hacemos con el método listen.

Tal y como vemos en la documentación oficial, la sintaxis es la siguente:

Código: Python
  1. socket.listen(backlog)

El método listen, en pocas palabras, pone al socket en modo pasivo y establece el número de conexiones TCP entrantes que el sistema puede encolar.

Analicemos bien esto:

    - Poner al socket en modo pasivo: decimos que un socket se encuentra en modo pasivo cuando está listo para ser usado como un servidor y, por el contrario, en modo activo cuando será utilizado como cliente.

    - Encolar conexiones entrantes: cuando el servidor se pone en marcha sólo tiene que esperar a que los clientes se conecten a él. Cuando esto sucede, se atiende al cliente de forma individual y dedicada. Esto significa que si el servidor está conectado con un cliente, los demás deberán esperar a que ésta conexión finalice para ser atendidos. Podemos comparar esto con la caja de un supermercado: el cajero atiende a un cliente a la vez. Los demás deberán ponerse en fila y esperar su turno.

    - Establecer número máximo de conexiones en la cola: con el método listen podemos indicar cuál es el número máximo de clientes que vamos a permitir en nuestra cola (es el llamado backlog). Si volvemos al ejemplo del supermercado, el cajero puede indicar el número máximo de clientes que tendrá la cola. Si el máximo fuera de cinco personas, la sexta será notificada de tal situación y le negarán el acceso a la cola (sí, tendrá que irse a otra caja o volver a probar en otro momento).

Si llevamos esto al código, nos queda algo así:
Código: Python
  1. # -*- coding: utf-8 -*-
  2. import socket
  3.  
  4. # creamos el socket
  5. mi_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6.  
  7. # establecemos interfaz de conexión
  8. ip = "127.0.0.1"
  9. puerto = 8000
  10. mi_socket.bind((ip, puerto))
  11.  
  12. # ponemos al socket en modo pasivo y establecemos el número
  13. # máximo de conexiones entrantes que el sistema puede encolar.
  14. backlog = 5
  15. mi_socket.listen(backlog)

Bien, ahora que ya hemos puesto al socket en modo pasivo (está escuchando: listen) y que hemos establecido el límite de conexiones a encolar (backlog), ya estamos en condiciones de recibir a nuestros clientes.



ACEPTANDO CONEXIONES ENTRANTES


Cuando decimos recibir a nuestros clientes, estamos hablando de aceptarlos. Justamente, para realizar esta tarea, existe el método accept. Para utilizar este método, sólo tenemos que escribir lo siguiente:

Código: Python
  1. conn, address = socket.accept()

Tal y como vemos en la documentación oficial, para utilizar este método, es necesario haber creado una interfaz de conexión previamente. Una vez ejecutado, el método devuelve (return) una tupla de dos elementos:
    - conn: un nuevo objeto socket utilizado para enviar y recibir información de la conexión.
    - address: dirección vinculada al socket que se encuentra en el otro extremo de la conexión (es decir, la dirección del cliente). Como dijimos en la entrega anterior, una dirección de red se compone, en el caso de las familias AF_INET (IPv4), de una tupla con dos valores: IP y puerto.

Si volvemos al código anterior y evaluamos los valores retornados, tendríamos algo así:

Código: Python
  1. >>> print conn
  2. <socket._socketobject object at 0x0000000001FBF660>
  3. >>> print address
  4. ('127.0.0.1', 2580)

Como vemos, conn es un objeto socket y address una tupla con dos valores: el primero es la IP -en este caso, una Loop IP-, el segundo valor corresponde al puerto. Recuerden que estos dos valores (IP y puerto) corresponden al cliente que acabamos de recibir (aceptar). El objeto socket es el que nos permitirá comunicarnos con ese cliente.

Esto significa que si quiero enviarle información al cliente, tendré que hacerlo por medio de conn, y lo haremos a la IP 127.0.0.1 y al puerto 2580. Esto lo veremos con más detalle en las próximas entregas pero les comento esto ahora para que se vayan haciendo una idea ;)

Muy bien, en el día de hoy hemos aprendido a poner nuestro servidor en escucha (listen), indicando el número máximo de conexiones entrantes a encolar (backlog), y a aceptar cada una de estas conexiones entrantes (accept). Para poner en práctica todo esto, pueden crear un archivo llamado servidor.py (ahora les paso el contenido) y conectarse a él por medio de telnet o netcat (más adelante veremos cómo crear nuestro propio cliente).

[b[servidor.py[/b]
Código: Python
  1. # -*- coding: utf-8 -*-
  2. import socket
  3.  
  4. # creamos servidor
  5. server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6.  
  7. # creamos interfaz de conexión
  8. server.bind(("0.0.0.0", 8080))
  9.  
  10. # ponemos al servidor en escucha
  11. # (backlog: 5)
  12. server.listen(5)
  13.  
  14. # recibimos conexiones entrantes
  15. conn, address = server.accept()
  16.  
  17. # imprimimos los datos devueltos por
  18. # el método accept
  19. print conn
  20. print address
  21.  
  22. # cerramos la conexión con el cliente
  23. conn.close()
  24.  
  25. # cerramos el servidor
  26. server.close()

Para finalizar, déjenme comentarles dos cosas. En primer lugar, hay un método nuevo que no habíamos visto todavía: close. Como sabemos, tanto server como conn son objetos socket. Esto significa que ambos presentan los mismos métodos. Este nuevo método, sirve para cerrar un socket. En este caso, primero cerramos el socket conn y luego el que creamos para el servidor.

En segundo lugar, por si no se dieron cuenta, en el código que acabamos de hacer tenemos un gran problema: sólo podemos recibir un cliente. Luego de crear la conexión, cerramos ambos sockets y se termina todo. Evidentemente, esto no nos sirve si queremos tener un chat funcional. En las próximas entregas veremos cómo prolongar la conexión con un cliente (bucles) y cómo interactuar con varios clientes a la vez (threads).

Nos vemos en la próxima entrega con más de UnderCh4t ;)

Saludos!
WhiZ

7
Hola @$francisco! Esto tendría que funcionar.

    1. Descargar el source de mechanize.
    2. Extraer en C:\Python27\Lib\site-packages\ (quedaría C:\Python27\Lib\site-packages\mechanize-0.2.5\).
    3. Instalar mechanize: dentro del directorio mechanize-0.2.5, ejectuar el siguiente comando:

Código: Text
  1. python setup.py install

    4. Buscar el archivo _mechanize.py (se encuentra en C:\Python27\Lib\site-packages\mechanize-0.2.5\mechanize\).
    5. Copiar el archivo al directorio C:\Python27\lib\site-packages\.
    6. Renombrar el archivo (quedaría C:\Python27\Lib\site-packages\mechanize.py).
    7. Crear el ejecutable:

Código: Text
  1. python pyinstaller.py --onefile --console --paths=C:\Python27\Lib\site-packages\mechanize-0.2.5\ test.py

El código de test.py es el siguiente:
Código: Python
  1. import mechanize
  2.  
  3. print "Mechanize funcionando!"

Espero que te sirva!

Saludos!
WhiZ

8
Python / Re:[Python] Underch4t v1.0 (Parte 2)
« en: Diciembre 21, 2015, 08:55:40 pm »
Se te escapó un (
Código: Python
  1. msj = "Estableciendo interfaz de conexión ({0}:{1})")

Se aprende mucho con estos post, se agradece WhiZ  :D
Saludos!

Gracias @Barlan por el aviso. En realidad me lo traje de la llamada al método mostrar_info. Al principio, lo puse así:
Código: Python
  1. self._mostrar_info("Estableciendo interfaz de conexión ({0}:{1})".format(self.__ip, self.__puerto))

Como quedaba muy largo, metí el mensaje en una variable y ahí fue cuando me llevé el paréntesis de cierre jeje.

Como dije, muchas gracias por la notificación. En instantes lo modifico.

Genial @WhiZ he estado leyendo mucho sobre este fabuloso modulo y esto me cae como anillo al dedo, enserio GRACIAS

No, al contrario. Gracias a vos por tomarte el tiempo de pasar por aquí ;)

Saludos!
WhiZ

9
Python / [Python] Underch4t v1.0 (Parte 2)
« en: Diciembre 19, 2015, 05:33:38 pm »

UnderCh4t



Comenzamos la segunda entrega de este mini tutorial: creando nuestro propio chat con Python. El mío se llama UnderCh4t y si es la primera vez que escuchás hablar de él,  te invito a que pases por aquí y lo conozcas ;)



INTERFAZ DE CONEXIÓN


Hasta ahora no hemos hecho mucho: sólo creamos la estructura general de nuestro servidor (que, como veremos a lo largo del curso, irá sufriendo algunas modificaciones) y hemos desarrollado el método que nos permite crear el socket que vamos a utilizar para interactuar con nuestros clientes.

Si nos basamos en el método ejecutar (método guía del programa), ahora le toca el turno al método bind. Veamos primero su código:

Código: Python
  1. def _bind(self):
  2.     msj = "Estableciendo interfaz de conexión ({0}:{1})"
  3.     self._mostrar_info(msj.format(self.__ip, self.__puerto))
  4.     try:
  5.         self.__servidor.bind((self.__ip, self.__puerto))
  6.     except Exception as e:
  7.         self._mostrar_error(e, critico=True)

Nuevamente, dejando de lado los logs y el manejo de errores, lo único que nos interesa en este método es la siguiente línea:

Código: Python
  1. self.__servidor.bind((self.__ip, self.__puerto))

Como siempre, lo primero que haremos será pegarle una ojeada a la documentación oficial. En ella, podemos ver que el método bind tiene como objetivo establecer una interfaz de conexión, es decir, enlazar el socket a una dirección, la cual variará según la familia de dirección que utilicemos.

Citar
Esto ya lo vimos en la primera parte pero para los que todavía no saben de qué estamos hablando, vamos con un rápido repaso. Cuando creamos un socket, debemos indicar cómo queremos que sea, es decir, qué familia, tipo y protocolo queremos que utilice. Dentro de las familias de sockets, las más utilizadas son:
    - AF_INET (IPv4)
    - AF_INET (IPv6)
    - AF_UNIX (utilizada para comunicación entre procesos en una misma computadora).

Entonces, cuando creamos un socket, se le asigna una familia de direcciones pero no una dirección en particular. Para esto, debemos llamar al método bind, pasándole como argumento la dirección que queremos asignar al socket.

Como dijimos antes, cada familia de sockets tiene su forma de indicar esta dirección. La familia AF_INET, por ejemplo, utiliza una tupla con dos valores: host (dominio o dirección IP) y puerto. El código quedaría así:

Código: Python
  1. import socket
  2. mi_socket = socket.socket(AF_INET, SOCK_STREAM)
  3. direccion = ("127.0.0.1", 8000)
  4. mi_socket.bind(direccion)

En este caso, primero creamos el socket - indicamos familia y tipo de socket (al protocolo, no indicado, lo determina el sistema)- y luego vinculamos el socket a una dirección. La dirección es una tupla que contiene una dirección IP (127.0.0.1) y un puerto (8000).

Con respecto a las direcciones de las otras familias, debido a que se escapa a los objetivos de este tutorial, no vamos a decir mucho; simplemente que la familia AF_UNIX utiliza una cadena para indicar la dirección, mientras que la familia AF_INET6 requiere una tupla con cuatro valores: host, puerto, flujo de información e identificador de ámbito. No se preocupen que esto no es algo que tengan que saber para este curso. Sin embargo, si alguno tiene ganas de aprender más del asunto, aquí dejo algunos links de interés: AF_UNIX y IPv6.



Bueno, esto es todo por ahora. Originalmente, mi idea era hacer una segunda parte más extensa pero, considerando que lo que viene es un poco más complejo, decidí hacer una entrega más corta que no los complique y les permita entender estos nuevos conceptos sin dificultad.

Vayan leyendo y repasando estas dos primeras partes que les van a servir de base para la entrega que viene.  ;)

Saludos!
WhiZ

10
Dudas y pedidos generales / [Python] Añadir fecha a nombre de archivo
« en: Diciembre 15, 2015, 07:55:05 am »
Hola @Electrónico! Podrías en algún momento subir el código? Existen varias formas de hacer lo que pedís. Ver cómo armaste el script me permitirá darte una respuesta más personalizada.

Saludos!
WhiZ

11
Off Topic / Re:Feliz cumpleaños Jimeno!!
« en: Diciembre 10, 2015, 07:43:33 pm »
Feliz cumple @Jimeno!


Ehhh... perdón... ésa no era la tarjeta :P

jaja espero que tengas un gran día!

Saludos!
WhiZ

12
Diseño Gráfico / Re:Firma de Navidad - 2015.
« en: Diciembre 10, 2015, 07:07:33 pm »
Te quedó excelente @iatsm! Muchas gracias por tu tiempo y dedicación!

Saludos!
WhiZ

13
Hola @$francisco! Revolviendo un poco la sección de "Dudas y pedidos generales" me encontré con este post tuyo (no lo había visto en su momento jeje).

Sinceramente, desconocía esta técnica y, por ende, su intención. Luego de un pequeño análisis, llegué a la conclusión de que se utiliza, no para imprimir en pantalla caracteres especiales - ya que eso se puede hacer de forma directa con el método toUtf8 - sino para convertir el dato de QByteArray a unicode.

Para que se entienda bien, te explico paso por paso. Vamos a suponer que tenemos el siguiente código:
Código: Python
  1. # -*- coding:utf-8 -*-
  2. from PyQt4 import QtCore
  3.  
  4. texto = QtCore.QString(u'niño')
  5.  
  6. print texto

Como vemos, la variable texto almacena un dato de tipo QString. Si queremos imprimir su contenido en pantalla - que es lo que hacemos en el código anterior -, lo único que veremos será el siguiente error:
Código: Text
  1. UnicodeEncodeError: 'ascii' codec can't encode character u'\xf1' in position 2: ordinal not in range(128)

Para entender mejor qué significa este UnicodeEncodeError, podemos recurrir a esta wiki y a este blog.

La pregunta que nos hacemos a continuación es: ¿cómo lo resolvemos?. Para esto, QString nos aporta un método llamado toUtf8 que nos facilita la tarea. El mismo nos crea un dato de tipo QByteArray que, tal y como se dice en la documentación, no es más que una representación en UTF-8 del contenido de QString. Con este nuevo objeto, ya somos capaces de imprimir los caracteres especiales sin problema.

El código que presento a continuación, es capaz de manejar el error e imprimir el texto en pantalla:
Código: Python
  1. # -*- coding:utf-8 -*-
  2. from PyQt4 import QtCore
  3.  
  4. texto = QtCore.QString(u'niño')
  5.  
  6. try:
  7.     print texto
  8. except UnicodeDecodeError:
  9.     print texto.toUtf8()

Bien. Con esto queda resuelto el tema de imprimir datos de tipo QString con caracteres especiales. Sin embargo, todavía no respondo a tu pregunta: ¿por qué transformar un dato de tipo QString a QByteArray, luego a str y, por último, a unicode? xD

Lo primero que tengo que pensar es que la intención no es, simplemente, imprimir un QString con caracteres especiales. Como acabamos de decir, no hace falta más que llamar al método toUtf8 para hacerlo. Entonces, lo siguiente que se me viene a la mente es que la idea es convertir el dato de QString a unicode. Suponiendo que ése es el objetivo, hagamos un análisis de la situación y averiguemos el porqué de esta técnica:
Código: Python
  1. # -*- coding:utf-8 -*-
  2. from PyQt4 import QtCore
  3.  
  4. texto = QtCore.QString(u'niño')
  5. u_texto = str(texto.toUtf8()).decode('utf-8')  # convertimos a unicode
  6.  
  7. print "Tipo:", type(u_texto)
  8. print "Texto:", u_texto

Al ejecutar el script, obtenemos la siguiente salida:
Código: Text
  1. Tipo: <type 'unicode'>
  2. Texto: niño

Ahora voy a probar algo más simple:
Código: Python
  1. # -*- coding:utf-8 -*-
  2. from PyQt4 import QtCore
  3.  
  4. texto = QtCore.QString(u'niño')
  5. u_texto = unicode(texto)  # convertimos a unicode
  6.  
  7. print "Tipo:", type(u_texto)
  8. print "Texto:", u_texto

Veamos qué pasa al ejecutarlo:
Código: Text
  1. Tipo: <type 'unicode'>
  2. Texto: niño

Conclusión: como dije al principio, aparentemente, la técnica no se utiliza para imprimir un dato de tipo QString que contenga caracteres especiales sino para convertirlo al tipo unicode. No obstante, existe una forma más sencilla que consiste en llamar a la función unicode y pasarle como argumento el dato tipo QString. Con esta información en nuestras manos, sólo se me ocurren dos cosas: es, simplemente, una alternativa más compleja para hacer la conversión ó, posiblemente, una técnica que, además de la hacer la conversión, nos otorga algunos beneficios que desconozco.

Bueno, esto es todo lo que se me ocurre luego de analizar todo por un rato. Si alguien tiene algo más que aportar, adelante ;)

Saludos!
WhiZ

14
Python / Re:[Python] Underch4t v1.0 (Parte 1)
« en: Diciembre 09, 2015, 04:14:14 pm »
En la línea 7 del primer script tenemos un error, la asignación del parámetro al atributo puerto está como:
Código: Python
  1. self.__port = port
Y el parámetro es "puerto". Por ende dará error.

Sí, es cierto. Pasa que a la aplicación la hice en inglés y la estoy traduciendo para el tuto jeje. Voy a tener más cuidado. Gracias por el aviso ;)

En la línea 4 del método _crear_socket(self)
Código: Python
  1. self.__servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Al usar self.__servidor, estás declarando e inicializando el objeto self.__servidor ó este debía existir previamente entre los atributos de la clase Socket(object) ?

__servidor es una instancia de socket() que pertenece a la clase Servidor. Es decir, estoy declarando e inicializando el objeto.

Gracias por el aporte. Estaré al tanto de la serie
No, gracias a vos por tu interés :)

Saludos!
WhiZ

15
Python / [Python] Underch4t v1.0 (Parte 1)
« en: Diciembre 09, 2015, 01:56:48 pm »

UnderCh4t


Este es un pequeño servidor que acabo de crear en Python en respuesta a este post de @Theraritho5.

Voy a ir explicando, paso a paso, cómo armar el servidor y, finalmente, pongo todo el código completo.

Debido a que mi idea es ir explicando todo el proceso sin dejar cabos sueltos, ésta va a ser el primero de una serie de artículos en los que intentaré guiarlos en este maravilloso mundo de los sockets.

Comencemos!



CREANDO EL SERVIDOR


Lo primero que haremos es una clase llamada Servidor, la cual, en primera instancia, podrá realizar las siguientes tareas:
    - Sockets (vengan por acá los que no saben de qué estamos hablando ;) ):
        · crear un socket (servidor)
        · establecer interfaz de conexión: esto es, adjudicar ip y puerto local a la que se deberán conectar los clientes
        · poner el servidor en escucha
        · atender conexiones entrantes
        . cerrar socket
    - Informar estado del proceso
    - Manejar errores

Veamos cómo quedaría el código:
Código: Python
  1. import socket
  2. import sys
  3.  
  4. class Servidor(object):
  5.     def __init__(self, ip, puerto, max_con=5):
  6.         self.__ip = ip
  7.         self.__puerto = puerto
  8.         self.__max_con = max_con
  9.         self.__clientes = {} # { socket, [ip, puerto]}
  10.  
  11.     ##########
  12.     # SOCKET #
  13.     ##########
  14.     def ejecutar(self):
  15.         try:
  16.             self._crear_socket()
  17.             self._bind()
  18.             self._escuchar()
  19.             self._cerrar_socket()
  20.         except KeyboardInterrupt:
  21.             self._cerrar_socket()
  22.         except Exception as e:
  23.             self._mostrar_error(e, critico=True)
  24.  
  25.     def _crear_socket(self):
  26.         pass
  27.  
  28.     def _bind(self):
  29.         pass
  30.  
  31.     def _escuchar(self):
  32.         pass
  33.  
  34.     def _atender_cliente(self):
  35.         pass
  36.  
  37.     def _cerrar_socket(self):
  38.         pass
  39.  
  40.     ###########
  41.     # PROCESO #
  42.     ###########
  43.     def _mostrar_info(self, msj):
  44.         print " [+] {}".format(msj)
  45.  
  46.     def _mostrar_error(self, error, critico):
  47.         print " [!] Error: {}".format(error)
  48.         if critico:
  49.             self._salir()
  50.  
  51.     def _salir(self):
  52.         sys.exit(" [+] Finalizando aplicación")

Bien. Hasta aquí no hay mucho que decir. Hasta ahora hemos creado una clase 'Servidor' con dos grupos de métodos: los que se encargan de la conexión y los que se encargan de informar proceso y errores.

Vayamos con los métodos de conexión. El primero que vemos es el método 'ejecutar'. Este método constituye la guía de nuestra aplicación. Él se va a encargar de ir llamando, uno a uno, a cada método necesario para establecer nuestras conexiones.

Lo primero que hace es llamar a '_crear_socket'. Al menos que cambiemos un poco su contenido, no creo que pase mucho jeje. Vamos con eso:
Código: Python
  1. def _crear_socket(self):
  2.     self._mostrar_info("Creando socket")
  3.     try:
  4.         self.__servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  5.         self.__servidor.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  6.     except Exception as e:
  7.         self._mostrar_error(e, critico=True)

Voy a intentar explicar, de forma sencilla, qué significa todo esto que acabamos de escribir. Más allá del manejo de errores, los logs y el debugging, lo que realmente queremos es que este método nos cree un socket. La pregunta es: ¿cómo hacemos eso? El módulo socket de python es quien nos permite realizar esta tarea. Para crear un socket, debemos escribir lo siguiente:
Código: Python
  1. mi_socket = socket.socket()

Todo muy lindo hasta acá pero los que saben y entienden de redes se estarán preguntando: ¿qué características tendrá este socket? ¿sobre qué protocolos se llevará a cabo la comunicación? Bueno, por defecto, el objeto utilizará los protocolos IP y TCP. ¿Y si quisiera utilizar UDP, en vez de TCP? ¿Puedo hacerlo? Absolutamente. Tal como se indica en la documentación oficial, podemos indicar la familia, el tipo y el protocolo que querramos utilizar:
Código: Python
  1. mi_socket = socket.socket(familia, tipo, protocolo)

Para no complicarnos, sólo nos centraremos en la familia y el tipo. Dentro de las familias de direcciones, encontramos las siguientes:

    - AF_INET: le indica al kernel que vamos a utilizar el protocolo IPv4.
    - AF_INET6: le indica al kernel que vamos a utilizar el protocolo IPv6.
    - AF_UNIX: a diferencia de las familias INET que están ligadas a una tupla ip-puerto, las familias UNIX se vinculan a un archivo específico de tu sistema de archivos. Nos sirve, por ejemplo, para comunicación entre procesos de un mismo host.

Dentro de los tipos, los más utilizados son:
    - SOCK_STREAM: le indica al kernel que para transmitir los datos vamos a utilizar un protocolo confiable (TCP, por ejemplo).
    - SOCK_DGRAM: le indica al kernel que para transmitir los datos vamos a utilizar un protocolo no confiable (como es el caso de UDP)

Entonces, si quisiéramos hacer una conexión basada en los protocolos IP y UDP, bastaría con escribir lo siguiente:
Código: Python
  1. familia = socket.AF_INET # IPv4
  2. tipo = socket.SOCK_DGRAM # UDP
  3. mi_socket = socket.socket(familia, tipo)

¿Vamos bien hasta ahí? Si es así, entonces continuemos que queda bastante por delante. Tenemos que saber que, una vez creado nuestro socket, podemos acceder a las opciones del mismo para modificarlas. Para hacerlo, el objeto socket nos brinda un método que nos facilita la tarea: setsockopt().

Tal y como nos indica la documentación oficial, para modificar una opción debemos indicar el nivel del socket (ya lo veremos unos renglones más abajo),  la opción que queremos modificar y el valor:
Código: Python
  1. mi_socket = socket.socket()
  2. mi.socket.setsockopt(nivel, opcion, valor)

Cuando hablamos de nivel, nos referimos, por decirlo de forma sencilla, al protocolo en el que se encuentra la opción que queremos modificar. Cada nivel tiene un valor que lo identifica, por ejemplo:
    - SOL_SOCKET: es el nivel del socket y el valor que lo identifica es 1.
    - SOL_TCP: es el nivel del protocolo TCP, cuyo identificador es el 6.
    - SOL_UDP: nivel del protocolo UDP, identificado por el número 17.

Como a nosotros sólo nos interesa acceder a las opciones del socket, vamos a utilizar SOL_SOCKET para indicar el nivel.

Dentro de las opciones (acá pueden ver un listado completo), a mi me interesa una en particular: SO_REUSEADDR. Esta opción nos permite reutilizar un socket local que se encuentre en estado TIME_WAIT, sin tener que esperar su tiempo natural de expiración (para los que no engancharon nada -> leer ;) ). La opción sólo acepta valores booleanos, es decir, reutiliza el socket o no lo utiliza (reutilizar: SI/NO).

Bien, ahora que entendemos un poco mejor cómo es esto de las opciones, vamos a modificar esta opción:
Código: Python
  1. mi_socket = socket.socket()
  2. nivel = SOL_SOCKET # Nivel del socket
  3. opcion = SO_REUSADDR # Opción a modificar
  4. valor = True # Sí, queremos reutilizar el socket
  5. mi_socket.setsockopt(nivel, opcion, valor)

Bien. Con esto queda concluido nuestro método para crear sockets. Con todo lo visto, ya son capaces de adaptar el método a sus necesidades. De hecho, podríamos modificar un poco el método para que sea más flexible:

Código: Python
  1. def _crear_socket(self, familia, tipo, opciones):
  2.     self._mostrar_info("Creando socket")
  3.     try:
  4.         self.__servidor = socket.socket(familia, tipo)
  5.         for opcion in opciones:
  6.             nivel, opcion, valor = opcion[:]
  7.         self.__servidor.setsockopt(nivel, opcion, valor)
  8.     except Exception as e:
  9.         self._mostrar_error(e, critico=True)



Con esto doy por concluida esta primera parte. En los próximos días iré desarrollando los demás métodos que tenemos pendientes y más ;)

Saludos!
WhiZ

P.D.: muchas gracias @po6xsecpo por la correción.

16
Python / Re:Web Scraping
« en: Diciembre 03, 2015, 06:16:12 pm »
Como te dije antes, excelente aporte @MagoAstral!

Otra librería interesante para realizar este tipo de tareas es mechanize. Aquí dejo un código equivalente al último que presentaste:
Código: Python
  1. import mechanize
  2.  
  3. br = mechanize.Browser()
  4. br.open("http://biblioteca.underc0de.org/")
  5.  
  6. for link in br.links():
  7.   if "?dir" in link.url:
  8.     print "{0} : {1}".format(link.text, link.url)

Este código no es más que para ejemplificar y, por supuesto, se podría mejorar muchísimo. Pero eso ya quedaría para otro post  ;)

Saludos!
WhiZ

17
Presentaciones / Re:Retorno!
« en: Noviembre 24, 2015, 04:44:31 pm »
Excelente noticia che! Qué alegría tenerte de nuevo con nosotros!


Abrazo grande facu!

Saludos!
WhiZ

18
Igualmente me sirvió mucho la ayuda que me dieron, ahora ya entendí por completo el proceso de SQLi, el básico por lo menos, igualmente seguramente tenga muchas cosas más para aprender del tema.

Ahora voy a pasar a temas como XSS, RFI, LFI, igualmente si tienen algún consejo de por donde seguir, es bienvenido.

Si realmente te interesa aprender temas relacionados a seguridad informática, te voy a hacer dos sugerencias: primero, buscate libros o manuales que expliquen detalladamente los fundamentos de cada ataque. Personalmente, me gustan mucho los hacker's handbooks. Seguro te van a gustar a vos también. En segundo lugar, esto no es algo que vayas a aprender sólo leyendo teoría y, obviamente, si no querés meterte en problemas, lo aconsejable es que practiques en entornos controlados por vos. Te dejo esta página en la que podrás encontrar muchas aplicaciones web con todo tipo de vulnerabilidades. Son muy fáciles de montar y completamente entretenidas.

Espero que te sirva!

Saludos!
WhiZ

19
entiendo tu sugerencia y es excelente idea, aunque en el sitio que uso mi bruteforcer no necesito hacerlo de esa forma porque sus medidas de seguridad contra bruteforcing de contraseñas a sus usuarios son muy pobres.

Más allá de la página que estés auditando en este momento, siempre te conviene hacer un código flexible. En todo caso, lo que yo haría es un script que pregunte cómo realizar el ataque: por usuario o por contraseña.

Pasando al real motivo de mi post (la aplicacion de multi-threading) a mi script para acelerar el proceso, he leido y creo entender un mas o menos como funciona la clase mencionada pero no logro aplicarlo a mi script. He leido que lo mas recomendable en casos parecidos al mio es usar colas con el modulo Queue, aunque no comprendo bien como hacerlo funcionar con mi script y poder seguir usando la parte del contador de passwords.

En las aplicaciones que emplean varios hilos, si éstos necesitan acceder a un mismo recurso, lo ideal es bloquear el acceso al mismo mientras esté siendo utilizado. En tu caso, podés hacer esto con la clase Lock del módulo threading.

En Python para todos de Raul González Duque, precisamente en la sección "Sincronización" del capítulo "Threads", podés encontrar una buena explicación.

Espero que te sirva!

Saludos!
WhiZ

20
Dudas y pedidos generales / Re:Sacar password de red wifi de mi PC
« en: Octubre 20, 2015, 08:24:41 am »
Tambien podes hacer lo siguiente:

Clickeas en propiedades:


Ahora vamos a la pestaña de seguridad, y marcamos la opción de mostrar caracteres:


Saludos!
ANTRAX

No tiene privilegios suficientes para hacer eso. Quiere averiguar la clave desde una cuenta limitada.

Otra alternativa,  @Nitro_X_Net, aunque un tanto más invasiva y llamativa, es ingresar como administrador a esa u otra PC y, ahí sí, hacer lo que dijo @ANTRAX.

Saludos!
WhiZ

Páginas: [1] 2 3 ... 16