Módulos de sistema en Python - OS

Python nos tiene en su librería estándar algunos módulos de sistema de lo cuales podemos destacar tres: os, sys y subprocess.

Estos módulos nos permiten acceder a funcionalidades para conocer el entorno en el que nos encontramos, manejar los directorios, información sobre el interprete, ordenes del sistemas operativo. Para el día de hoy hare unos ejemplos sobre el modulo OS.

Módulo OS

El módulo os nos permite acceder a funcionalidades dependientes del Sistema Operativo. Sobre todo, aquellas que nos refieren información sobre el entorno del mismo y nos permiten manipular la estructura de directorios.

Archivos y directorios

En este modulo tenemos funcionalidades para manejar archivos y obtener información sobre ello, aqui un ejemplo que contiene algunas funciones principales (para mas información pueden ver la documentación aqui).

Pueden ver el código completo en github, hice un ejemplo en el cual el programa realiza lo siguiente:

1. Obtengo el directorio actual.
2. Luego creo un nuevo directorio con permisos solo de lectura y escritura.
3. El programa intenta cambiar al nuevo directorio creado.
4. Por ultimo como no puede cambiar su ubicación, le da al directorio creado los permisos de ejecución para de nuevo intentar cambiar con éxito al nuevo directorio.

Veamos:

cambiar_ubicacion(path_rel): cambia al directorio pasado como parametro, utiliza las siguientes funciones.

•  os.access(path, permisos) : nos permite saber si un archivo o directorio tiene el permiso indicado. El primer parámetro es la ubicación del directorio o archivo, el segundo parámetro pueden ser las siguientes variables:
  
  - os.F_OK (devuelve True si existe)
  - os.R_OK (devuelve True si tiene permiso de lectura)
  - os.W_OK (devuelve True si tiene permiso de escritura)
  - os.X_OK (devuelve True si tiene permiso de ejecución)
  
• os.chdir(path): nos permite cambiar al directorio que se le pasa como parámetro, retorna error en caso que no exista o no se puede cambiar a dicho directorio.

mostrar_permisos(path_rel): evalúa los diferentes permisos mencionados anteriormente.

Ademas se utilizan otras funciones como:

os.getcwd(): retorna el directorio actual.

os.path.abspath(path): retorna la ruta absoluta de la ubicación indicada como parámetro. Si le pasas un ".", indica que es el directorio actual.

os.mkdir(path,permisos): crea un directorio en la ruta indicada como primer parámetro, esta ruta puede ser relativa o absoluta, es decir, puede indicar la ruta desde la raíz o desde la ubicación actual. Los permisos se indican de forma octal (0600 indica permisos de lectura y escritura para el usuario actual).

os.chmod(path, permisos): modifica los permisos del archivo o directorio indicado en el primer parámetro, los permisos se pueden indicar con el modulo stat, el parametro S_IXUSR indica permisos de ejecución para el usuario actual, para mas información pueden ver aqui.

Variables de entorno

El módulo os también nos provee de un diccionario con las variables de entorno relativas al sistema. Se trata del diccionario environ:

import os

for variable, valor in os.environ.iteritems():

    print "%s: %s" % (variable, valor)

Path

El módulo os también nos provee del submódulo path (os.path) el cual nos permite acceder a ciertas funcionalidades relacionadas con los nombres de las rutas de archivos y directorios.

Entre las que mas destacan las podemos ver en esta imagen:

Para mas información pueden ver la propia documentación de Python en este enlace. Luego haré un ejemplo de los otros 2 módulos SYS y SUBPROCESS.

Enlaces:

https://github.com/phaoliop/ModOS-Py

https://docs.python.org/2/library/os.html

http://librosweb.es/libro/python/capitulo_10/modulos_de_sistema.html

Enviar un e-mail desde Python

Veamos como podemos enviar un correo electrónico desde Python utilizando la librería smtplib. Para el ejemplo de hoy usaremos la librería smtplib de Python para enviar un correo electrónico desde una cuenta Gmail, como recomendación usen una cuenta que no les sirva para enviar los correos.

Antes de todo debemos configurar nuestra cuenta, para que permita el acceso de aplicaciones menos seguras, es decir, que nos permita autenticar nuestra cuenta desde nuestro script en python.

Para ello nos dirigimos a nuestra cuenta de Gmail y habilitamos la opción "Permitir el acceso de aplicaciones menos seguras":

Ahora si podemos loguearnos, luego necesitaremos crear un archivo que contendrá el mensaje que vamos a enviar, en mi caso yo cree un archivo llamado "body.txt"  que contiene el siguiente mensaje:

El cual debemos indicar la ubicacion en nuestro script:

import time, datetime
import smtplib

file_log = '/home/paolo/Escritorio/body.txt'

def SendEmail(user, pwd, recipient, subject, body):
  
  gmail_user= user
  gmail_pass = pwd
  FROM = user
  TO = recipient if type(recipient) is list else [recipient]
  SUBJECT = subject
  TEXT = body
  
  message = """\From: %s\nTo: %s\nSubject: %s\n\n%s
  """ % (FROM, ", ".join(TO), SUBJECT, TEXT)
  try:
    server = smtplib.SMTP("smtp.gmail.com", 587)
    server.ehlo()
    print server.ehlo()
    server.starttls()
    server.ehlo()
    print server.ehlo()
    server.login(gmail_user, gmail_pass)
    print("logueado")
    server.sendmail(FROM, TO, TEXT)
    print("enviando")
    server.close()
    print ('Correo enviado satisfactoriamente!')
  except Exception as e:
    print(e)

def FormatAndSendLogEmail():
  with open(file_log, 'r+') as f:
    actualdate = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    data = f.read().replace('\n', '')
    data = 'Log capturado a las: '+ actualdate + '\n' + data
    print(data)
    SendEmail('unacuentafake@gmail.com', 'clavedelacuenta', 'correoamandar@gmail.com',
              'Nuevo log - '+actualdate, data)
    f.seek(0)
    f.truncate()
    


FormatAndSendLogEmail()
print("fin")

Enviando un e-mail

En nuestro script tenemos 2 funciones (una para pasarle los datos que requiere: FormatAndSendLoEmail y otra la funcion en si que envia el e-mail: SendEmail).

Lo primero que debemos hacer es modificar la variable de nuestro archivo que contiene el mensaje a enviar:

file_log = 'ruta/body.txt'

Luego debemos modificar los datos que pasamos a la funcion SendEmail:

SendEmail('unacuentafake@gmail.com', 'clavedelacuenta', 'correoamandar@gmail.com',
              'Nuevo log - '+actualdate, data)

Ademas si deseamos hacerlo con otro servidor de correo, debemos configurar esta parte

del código, en el caso de Gmail es asi:

server = smtplib.SMTP("smtp.gmail.com", 587)

Y por ultimo correr nuestro Script:

Si no tenemos ningún error, significa que todo ha salido bien.
Ahora veamos al correo enviado:

Y pues eso es todo, así de sencillo. Si no les aparece el correo en la bandeja
de entrada, revisen en Spam, por lo general aparece ahí.

Hilos en Python - Brute force

El trabajo con threads se lleva a cabo en Python mediante el módulo thread. Este módulo es opcional y dependiente de la plataforma. 

Pero además de thread, también contamos con el módulo threading que se apoya en el primero para proporcionarnos una API de más alto nivel, más completa, y orientada a objetos y es el que utilizaré para el ejemplo de hoy, un programa que realizará fuerza bruta utilizando un diccionario para encontrar la clave de algunos usuarios utilizando hilos (para mas informacion de hilos en python click aqui). 

Para el ejemplo primero he montado un servidor utilizando el framework web Django, el cual contiene un formulario de login con el siguiente html:

En una publicación anterior ya explique como realizar un login con Python (

ver aqui) , así que ahora cree mi propio login, uno sencillo para poder hacer el ejemplo en donde solo requiere 3 datos por método POST (user, clave, ingresar).

Aplicando fuerza bruta

Bueno para realizar el ataque por fuerza bruta, he creado algunos usuarios:

Ademas de un diccionario con las posibles claves de estos usuarios, para el ejemplo solo he creado 11 claves como prueba de las cuales entre ella están la de los usuarios que probare:

https://github.com/phaoliop/FuerzaBrutaPy/blob/master/midiccionario.txt

El código lo pueden ver desde el repositorio ver aqui. Podemos ver que se utilizan los 3 parámetros mencionados que son enviados por método POST:

payload = {

   "user":user,

   "clave":clave,

   "ingresar":"Ingresar"

  }


response = requests.post(url, data=payload)

Nuestro formulario se vería así:

Donde una vez que accedimos, nos mostrara un mensaje en un etiqueta <p> con id="info":

A lo cual debemos evaluar en nuestro programa para saber si los datos ingresados han sido correctos o no. Eso lo evaluaremos usando BeautifulSoup, en donde obtendremos el código en la etiqueta <p id="info"> de no existir significa que no logramos acceder y por lo tanto nuestra clave es incorrecta:

Utilizando hilos para validar múltiples cuentas:

Como ultimo paso, he utilizado 2 hilos para a la vez ir buscando las claves de 2 de los usuarios creados, esto se puede hacer para muchos mas usuarios o dividir en hilos las posibles claves de un usuario:

Para empezar a ejecutar un hilo, se utiliza su metodo hilo.start() y una vez realizado todo, probamos el programa:

Bueno, el programa te muestra tanto las claves incorrectas como la clave correcta. Los usuarios a probar son "prueba" -> "micontra123" y "unusuario" -> "clave123". 

Enlaces:

https://github.com/phaoliop/FuerzaBrutaPy

Sockets en Python - Chat local

La comunicación entre distintas entidades en una red se basa en Python en el clásico concepto de sockets. Los programas utilizan sockets para comunicarse con otros programas, que pueden estar situados en computadoras distintas. Los tipos y funciones necesarios para trabajar con sockets se encuentran en Python en el módulo socket , como no podría ser de otra forma.

Un socket queda definido por la dirección IP de la máquina, el puerto en el que escucha, y el protocolo que utiliza. Para el ejemplo de hoy he realizado un pequeño programa en Python para intercambiar mensajes al cual he llamado PyChatLocal en el cual podremos "mensajear" con otro ordenador que este en red local.

Creando un Socket [Servidor]

Para realizar nuestro ejemplo primero debemos crear un socket para lo que sera el servidor, que estara a la escucha de las conexiones.

Creamos un objeto socket:

escucha = socket.socket()

Con el metodo bind(()) indicaremos el puerto por la cual estará en la escucha, en este caso será el 1234 y el host podemos poner localhost o dejarlo vacío:

escucha.bind(('',1234))

Luego le indicaremos el numero de conexiones que pueden estar a la espera en nuestro socket servidor:

escucha.listen(3)

Para este ejemplo, la conexión se realizara entre 2 clientes, por lo cual lo he realizado así. Nuestro socket servidor acepta las conexiones de los 2 clientes que se comunicaran:

conn, addr = escucha.accept()

La funcion accept() nos retorna 2 variables, una es la conexion y otro es una tupla que contiene (direccion,puerto) del cliente que se ha conectado.

Por ultimo, se encarga de enviar los mensajes entre el cliente 1 y 2:

while True:
	#Intercambio de mensajes entre clientes
	recibido = conn.recv(1024)
	conn2.send(addr[0]+">"+recibido)
	recibido2 = conn2.recv(1024)
	conn.send(addr2[0]+">"+recibido2)

Con la función send() enviara el mensaje al cliente que ha realizado esa conexión con nuestro socket servidor. Por ultimo cierras las conexiones con close() para liberarlas.

Creando un Socket [Cliente]

Una vez creado nuestro socket servidor, ahora crearemos nuestro socket cliente. He realizado 2 puesto que para realizar la prueba en uno tenia Python 2.7 y en la otra maquina tenia Python 3.5 ambos archivos estan el repositorio PyChatLocal.

El programa recibe como parámetro la direccion IP en el cual esta ejecutándose nuestro socket servidor. Con la función connect(()) le pasamos como parámetro la dirección IP y el puerto por el cual esta escuchando, en este caso 1234, veamos:

host = sys.argv[1]
	try:
	#Conectar
	sock = socket.socket()
	sock.connect((host,1234))

Luego enviamos el contenido del mensaje que obtenemos de entrada y leemos los datos si es que existe alguna entrada con sock.recv(1024) el cual recibe como parámetro la cantidad de bytes a leer:

while True:
	#Intercambio de mensajes
	mensaje = raw_input()
	sock.send(mensaje+"\n")
	data = sock.recv(1024)
	print data

Por ultimo cerramos la conexion para liberarla y ya tenemos un sencillo programa para intercambiar mensajes, probablemente mas adelante lo mejore para una próxima publicación.

Para las pruebas lo hice desde una maquina Ubuntu como servidor, ademas un cliente y una maquina Windows como el otro cliente:

Enlaces:

https://github.com/phaoliop/PyChatLocal

Web Scraping con Python - Buscando letra de canciones Lyrics.py

Web scraping es una técnica utilizada mediante algún programa de software para extraer informacion de sitios web. Para el ejemplo de hoy veremos un pequeño proyecto hecho en python el cual he nombrado Lyrics_py y el como podemos "analizar" y extraer contenido de una pagina web para obtener la letra de alguna canción pasada como parámetro.

Hace un tiempo mencione en una de mis publicaciones un programa realizado en Java y en como este analizaba el contenido del HTML de Instagram para visualizar la foto de un perfil el cual el algoritmo para analizar el HTML lo habia hecho yo mismo, para este ejemplo de hoy realizado en Python he utilizado una librería llamada BeautifulSoup del paquete bs4 el cual nos da mucha facilidad para extraer contenido especifico.

Extrayendo datos con BeautifulSoup:

En primer lugar debemos tener el codigo HTML de donde vamos a extraer datos, en este caso sera el HTML de una búsqueda realizada en Google. Entonces primero hacemos una petición GET con los parámetros de busqueda para esto utilizaremos la librería requests, por ejemplo:

response = requests.get("https://www.google.com.pe/search?q=lyrics+shape+of+you")

Luego una vez realizada la petición, ya tenemos el HTML de respuesta con:

response.content

Ahora para extraer contenido con BeautifulSoup, existen diferentes formas, para el programa realizado utilizaremos 2:

#Utilizamos para extraer el contenido después de realizar una petición con requests

soup = BeautifulSoup(contenido,"lxml")


#Utilizamos para extraer el contenido de una porción de html

soup = BeautifulSoup(cadena,"html.parser")

Ahora para buscar algún contenido especifico o etiquetas en general, podemos hacerlo de la siguiente manera:

resultados = soup.find_all("div",{"class":"nombre_clase"})


resultados2 = soup.find_all("nav",{"id":"nombre_id"})

Como resultado nos devuelve una lista donde cada elemento es un resultado de nuestra búsqueda, si no queremos especificar alguno de los 2 parámetros ponemos True. Ademas esta libreria nos permite acceder al contenido de alguno de sus atributos como si fuera un diccionario, por ejemplo si queremos acceder al atributo href lo hacemos así:

elemento['href']

Esto son algunos ejemplos en especifico de como he utilizado BeautifulSoup para lo que va en el ejemplo realizado, para mas información sobre esta librería y como utilizar, pueden ver en este enlace.

Buscando la letra de una canción:

En general para buscar una letra de una canción, voy a Google y le ingresamos lyrics nombre_cancion, pues para el ejemplo realizado haremos lo mismo pero mediante python a travez de una petición get como mencionamos anteriormente. Ahora una vez obtenido los resultados de la búsqueda, que manualmente seria algo así:

En caso de que Google play music tenga resultados de tu búsqueda, Google te la mostrará primero y luego estarán otros 10 resultados en donde puede visualizar la letra de la canción. Para una primera version (0.1) nos basamos en que todas las letras las tiene Google play music (aunque sabemos que no es asi), pero primero debemos extraer los enlaces a los cuales nos redireccionaria para visualizar la letra completa y los enlaces de los otros 10 resultados de búsqueda:

Extrayendo datos de resultados de búsqueda:

Para obtener los resultados,existen 2 posibles opciones, cuando solo están los 10 resultados de búsqueda y cuando ademas también existe resultado en Google play music. Luego de eso necesitamos obtener el enlace a donde nos redireccionaria si hiciéramos click, es decir, si lo hiciéramos de forma manual.

Veamos como extraer los datos:

Almacenamos en un diccionario "nombre_pagina": "enlace" , para tener las posibles paginas en donde debe buscar nuestro programa y mejorar sus opciones de búsqueda mas adelante.

Una vez obtenido todos los enlaces de redireccionamiento, podemos analizar estos resultados, para ello debemos realizar otra petición get si es posible. Para la búsqueda en Google play music acceder a los datos que buscamos seria así:

#Obtenemos el contenedor de los datos en general

datos = soup.find_all("div", {"class": "content-container lyrics"})



#Obtenemos el titulo y nombre del artista

titulo = soup.find_all("div", {"class": "title fade-out"})

artista = soup.find_all("div", {"class": "album-artist fade-out"})

Por ultimo para extraer la letra de la canción seria así:

encode('utf-8') para los contenidos con caracteres especiales.

Donde la variable datos es una lista que tenia el contenido de la letra de la canción por párrafos para este ejemplo en especifico.

Para ver el proyecto pueden ver en el GitHub del proyecto.

Lyrics.py

Bueno el programa es facil de usar, lo indica en el mismo README.md del proyecto. Dependencias:

• BeautifulSoup
• requests
• lxml

Para instalar dependencias con pip:

pip install -r requirements.txt

Luego ejecutan:

python lyrics.py "nombre_cancion"

Les dejo un ejemplo para buscar la letra de la canción "Shadow of the day": 

Enlaces:

https://github.com/phaoliop/Lyrics_py

Loguearse a una web con python

Existen diferentes formas de hacer un login a una pagina web, en esta ocasión decidí poner una parte del código utilizado anteriormente para loguearse a una web en Python.

Para este ejemplo el login ha sido realizado mediante una petición POST de la librería requests de Python, los datos enviados mediante esta petición depende de la url en donde realizará el login.

Para el ejemplo se envían los siguientes datos:

payload {
       "Usuario":user,
       "Password":clave,
       "btnEntrar":"Entrar",
}

Para saber que datos son enviados mediante el método POST pueden descargarse la pagina html del login y en la etiqueta form cambiarle el método POST por GET y ademas la dirección url donde se realizará la acción para que no te direccione a la pagina descargada, pueden editar la pagina con cualquier editor de texto. Para el ejemplo descargue el login de esta pagina. Veamos como hacerlo en la imagen:

Datos editados: action="datos.html" method="get" (donde datos.html es una copia de la pagina login.html descargada)

Los datos enviados aparentemente son miusuario y miclave, pero veamos en la siguiente imagen que todos los datos enviados son:

username=miusuario&password=miclave&return=&61523a137fcedfbcb0f2faa936635de7=1

En nuestro payload mencionado anteriormente para este login probablemente seria:

payload = {
       "username":"miusuario",
       "password":"miclave",
       "return":"",
       "61523a137fcedfbcb0f2faa936635de7"="1",
}

Por lo general son los datos que debería tener nuestra variable payload.

Una vez que sabemos los datos que se envían, el siguiente paso es analizar el resultado que retorna. Pues esto depende de cada pagina, es mas fácil cuando tienes una cuenta valida para saber que resultado esperas cuando los datos ingresados son correctos y a la vez saber que datos retorna cuando tu contraseña o usuario son incorrectos. En esta parte depende de la pagina y de uno mismo como analizar el contenido que retorna.

Aquí un ejemplo de como seria analizar el contenido que retorna:

Esto es asumiendo que retorna un id="mensaje-respuesta" con contenido que indica "Cuenta correcta"

Los demás como ya lo he mencionado depende del login y el contenido que retorna la petición, ademas de un poco de ingenio para hacer peticiones seguidas u otra cosa que se te pueda ocurrir. Para ver todo el contenido del código pueden ingresar aqui donde ademas hay una variable proxies por si quieren acceder mediante un proxy, saludos y happy hack.

Enlaces:

https://github.com/phaoliop/Loginwithpy/blob/master/Data/login.py

Lista de claves por defecto - UNMSM

Me tome el tiempo de ver cuantas cuentas aun continúan usando su clave por defecto y los resultados realmente me sorprendieron.  En total son alrededor de 7015 usuarios que sus cuentas han sido validadas, para no afectar a nadie he ocultado los últimos caracteres de los usuarios y de las contraseñas, por mi parte yo solo hice esto con la intención de informar.

Asumo que cada uno debe saber que la clave que esta usando, por si desean verificar si aparecen en la lista, puedes verificar aqui (presionen f3 e ingresen los primeros caracteres de su correo o dni).

Datos encontrados: 

Los datos encontrados user:password (Total: 7015)

Debo agregar que son cuentas de pre-grado que estudiaban hasta el 2015, probablemente si hubiera validado hasta los del estudiantes de pre-grado y demás personal dentro de la universidad en el 2017, los resultados hubieran sido aun mayores.

Entre los datos encontrados, decidí separar para obtener cuantas cuentas son por facultad:

1. MEDICINA = 772
2. DERECHO Y CIENCIA POLÍTICA = 715
3. LETRAS Y CIENCIAS HUMANAS = 416
4. FARMACIA Y BIOQUÍMICA = 146
5. ODONTOLOGÍA = 136
6. EDUCACIÓN = 429
7. QUÍMICA E INGENIERÍA QUÍMICA = 309
8. MEDICINA VETERINARIA = 79
9. CIENCIAS ADMINISTRATIVAS = 427
10. CIENCIAS BIOLÓGICAS = 167
11. CIENCIAS CONTABLES = 500
12. CIENCIAS ECONÓMICAS = 332
13. CIENCIAS FÍSICAS = 202
14. CIENCIAS MATEMÁTICAS = 278
15. CIENCIAS SOCIALES = 550
16. INGENIERÍA GEOLÓGICA = 428
17. INGENIERÍA INDUSTRIAL = 363
18. PSICOLOGÍA = 193
19. INGENIERÍA ELECTRÓNICA = 330
20. INGENIERÍA DE SISTEMAS E INFORMÁTICA = 243
    
    ----------------------------------------------------------------
    TOTAL = 7015

En primero lugar recomendarles que cambien su clave, probablemente muchos ni utilicen su cuenta, pero puede que haya personas que se aprovechen de esto, por mi parte solo ha sido para informarles, avisen y happy hack!.

Enlaces:

https://github.com/phaoliop/Loginwithpy/blob/master/preusers_pwd.txt

https://github.com/phaoliop/Loginwithpy/blob/master/estadisticas_facus.txt