Menú

Mostrar Mensajes

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

Mostrar Mensajes Menú

Mensajes - WhiZ

#1
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.
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
Bienveniodo @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta! 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)
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:

    - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
    - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
    - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

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
# -*- coding: utf-8 -*-
import socket

# creamos socket para el servidor
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# establecemos interfaz de conexión
servidor.bind(("0.0.0.0", 2236))

# modo pasivo y backlog
servidor.listen(5)

# aceptamos al cliente
cliente, direccion = servidor.accept()

print cliente
print direccion

cliente.close()
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, 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
data = "mensaje"
flags = 0
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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
bufsize = 1024
flags = 0
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

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.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Código: python
# -*- coding: utf-8 -*-
import socket

# creamos el socket del servidor
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# establecemos interfaz de conexión
servidor.bind(("0.0.0.0", 2236))

# modo pasivo y backlog
servidor.listen(5)

# aceptamos conexiones entrantes
cliente, direccion = servidor.accept()

# enviamos un mensaje al cliente
msj = "Bienvenido a UnderCh4t! Escribí '/desconectar' para salir."
cliente.send(msj)

# creamos un bucle para recibir información enviada por el cliente
while True:
    # recibimos la información enviada por el cliente
    recv = cliente.recv(1024)

    # formateamos la información
    recv = recv.lower().strip()

    # verificamos si hay que finalizar la conexión
    if recv == "/desconectar":
        cliente.close()
        break

    # imprimimos en pantalla la información recibida
    print recv

# cerramos el servidor
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í: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta).

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)
Enero 02, 2016, 11:12:29 PM
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
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 @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. 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
import socket

blacklist = []

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("0.0.0.0", 2236))

server.listen(5)
conn, address = server.accept()

if address[0] in blacklist:
    conn.close()


Saludos!
WhiZ
#6
Python / [Python] Underch4t v1.0 (Parte 3)
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:
    - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
    - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

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
# -*- coding: utf-8 -*-
import socket

# creamos el socket
mi_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# establecemos interfaz de conexión
ip = "127.0.0.1"
puerto = 8000
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
import socket

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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, la sintaxis es la siguente:

Código: python
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
# -*- coding: utf-8 -*-
import socket

# creamos el socket
mi_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# establecemos interfaz de conexión
ip = "127.0.0.1"
puerto = 8000
mi_socket.bind((ip, puerto))

# ponemos al socket en modo pasivo y establecemos el número
# máximo de conexiones entrantes que el sistema puede encolar.
backlog = 5
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
conn, address = socket.accept()


Tal y como vemos en la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, 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
>>> print conn
<socket._socketobject object at 0x0000000001FBF660>
>>> print address
('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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta (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
# -*- coding: utf-8 -*-
import socket

# creamos servidor
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# creamos interfaz de conexión
server.bind(("0.0.0.0", 8080))

# ponemos al servidor en escucha
# (backlog: 5)
server.listen(5)

# recibimos conexiones entrantes
conn, address = server.accept()

# imprimimos los datos devueltos por
# el método accept
print conn
print address

# cerramos la conexión con el cliente
conn.close()

# cerramos el servidor
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.
    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: batch
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: batch
python pyinstaller.py --onefile --console --paths=C:\Python27\Lib\site-packages\mechanize-0.2.5\ test.py


El código de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta es el siguiente:
Código: python
import mechanize

print "Mechanize funcionando!"


Espero que te sirva!

Saludos!
WhiZ
#8
Python / Re:[Python] Underch4t v1.0 (Parte 2)
Diciembre 21, 2015, 08:55:40 PM
No tienes permitido ver los links. Registrarse o Entrar a mi cuentaSe te escapó un (
Código: python
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
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.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Genial @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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)
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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
def _bind(self):
    msj = "Estableciendo interfaz de conexión ({0}:{1})"
    self._mostrar_info(msj.format(self.__ip, self.__puerto))
    try:
        self.__servidor.bind((self.__ip, self.__puerto))
    except Exception as e:
        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
self.__servidor.bind((self.__ip, self.__puerto))


Como siempre, lo primero que haremos será pegarle una ojeada a la No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. 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.

CitarEsto 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
import socket
mi_socket = socket.socket(AF_INET, SOCK_STREAM)
direccion = ("127.0.0.1", 8000)
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: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.




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
Hola @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta! 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!!
Diciembre 10, 2015, 07:43:33 PM
Feliz cumple @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta!


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

jaja espero que tengas un gran día!

Saludos!
WhiZ
#12
Diseño UX/UI / Re:Firma de Navidad - 2015.
Diciembre 10, 2015, 07:07:33 PM
Te quedó excelente @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta! Muchas gracias por tu tiempo y dedicación!

Saludos!
WhiZ
#13
Hola @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta! 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
# -*- coding:utf-8 -*-
from PyQt4 import QtCore

texto = QtCore.QString(u'niño')

print texto


Como vemos, la variable texto almacena un dato de tipo No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. 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
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta y a No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

La pregunta que nos hacemos a continuación es: ¿cómo lo resolvemos?. Para esto, QString nos aporta un método llamado No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que nos facilita la tarea. El mismo nos crea un dato de tipo No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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
# -*- coding:utf-8 -*-
from PyQt4 import QtCore

texto = QtCore.QString(u'niño')

try:
    print texto
except UnicodeDecodeError:
    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
# -*- coding:utf-8 -*-
from PyQt4 import QtCore

texto = QtCore.QString(u'niño')
u_texto = str(texto.toUtf8()).decode('utf-8')  # convertimos a unicode

print "Tipo:", type(u_texto)
print "Texto:", u_texto


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


Ahora voy a probar algo más simple:
Código: python
# -*- coding:utf-8 -*-
from PyQt4 import QtCore

texto = QtCore.QString(u'niño')
u_texto = unicode(texto)  # convertimos a unicode

print "Tipo:", type(u_texto)
print "Texto:", u_texto


Veamos qué pasa al ejecutarlo:
Código: text
Tipo: <type 'unicode'>
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)
Diciembre 09, 2015, 04:14:14 PM
No tienes permitido ver los links. Registrarse o Entrar a mi cuentaEn la línea 7 del primer script tenemos un error, la asignación del parámetro al atributo puerto está como:
Código: python
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 ;)

No tienes permitido ver los links. Registrarse o Entrar a mi cuentaEn la línea 4 del método _crear_socket(self)
Código: python
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.

No tienes permitido ver los links. Registrarse o Entrar a mi cuentaGracias 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)
Diciembre 09, 2015, 01:56:48 PM


UnderCh4t



Este es un pequeño servidor que acabo de crear en Python en respuesta a No tienes permitido ver los links. Registrarse o Entrar a mi cuenta de @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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
import socket
import sys

class Servidor(object):
    def __init__(self, ip, puerto, max_con=5):
        self.__ip = ip
        self.__puerto = puerto
        self.__max_con = max_con
        self.__clientes = {} # { socket, [ip, puerto]}

    ##########
    # SOCKET #
    ##########
    def ejecutar(self):
        try:
            self._crear_socket()
            self._bind()
            self._escuchar()
            self._cerrar_socket()
        except KeyboardInterrupt:
            self._cerrar_socket()
        except Exception as e:
            self._mostrar_error(e, critico=True)

    def _crear_socket(self):
        pass

    def _bind(self):
        pass

    def _escuchar(self):
        pass

    def _atender_cliente(self):
        pass

    def _cerrar_socket(self):
        pass

    ###########
    # PROCESO #
    ###########
    def _mostrar_info(self, msj):
        print " [+] {}".format(msj)

    def _mostrar_error(self, error, critico):
        print " [!] Error: {}".format(error)
        if critico:
            self._salir()

    def _salir(self):
        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
def _crear_socket(self):
    self._mostrar_info("Creando socket")
    try:
        self.__servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.__servidor.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    except Exception as e:
        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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta de python es quien nos permite realizar esta tarea. Para crear un socket, debemos escribir lo siguiente:
Código: python
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, podemos indicar la familia, el tipo y el protocolo que querramos utilizar:
Código: python
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
familia = socket.AF_INET # IPv4
tipo = socket.SOCK_DGRAM # UDP
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, 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
mi_socket = socket.socket()
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 (No tienes permitido ver los links. Registrarse o Entrar a mi cuenta), 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 -> No tienes permitido ver los links. Registrarse o Entrar a mi cuenta ;) ). 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
mi_socket = socket.socket()
nivel = SOL_SOCKET # Nivel del socket
opcion = SO_REUSADDR # Opción a modificar
valor = True # Sí, queremos reutilizar el socket
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
def _crear_socket(self, familia, tipo, opciones):
    self._mostrar_info("Creando socket")
    try:
        self.__servidor = socket.socket(familia, tipo)
        for opcion in opciones:
            nivel, opcion, valor = opcion[:]
        self.__servidor.setsockopt(nivel, opcion, valor)
    except Exception as e:
        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
Diciembre 03, 2015, 06:16:12 PM
Como te dije antes, excelente aporte @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta!

Otra librería interesante para realizar este tipo de tareas es No tienes permitido ver los links. Registrarse o Entrar a mi cuenta. Aquí dejo un código equivalente al último que presentaste:
Código: python
import mechanize

br = mechanize.Browser()
br.open("http://biblioteca.underc0de.org/")

for link in br.links():
  if "?dir" in link.url:
    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 y cumpleaños / Re:Retorno!
Noviembre 24, 2015, 04:44:31 PM
Excelente noticia che! Qué alegría tenerte de nuevo con nosotros!


Abrazo grande facu!

Saludos!
WhiZ
#18
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
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.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
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 No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

En No tienes permitido ver los links. Registrarse o Entrar a mi cuenta 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
No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
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,  @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, aunque un tanto más invasiva y llamativa, es ingresar como administrador a esa u otra PC y, ahí sí, hacer lo que dijo @No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.

Saludos!
WhiZ