Script para escanear una red local

Ayer en la noche detecte un intruso en mi red local, lo más usual fue restringir el acceso por MAC address, que fue lo que hice. Pero que hubiera pasado si no hubiera revisado la lista de accesos, seguramente no me hubiera dado cuenta. Es por eso que me tome el tiempo para hacer un pequeño script que te notificara cuando hay una nueva conexión en tu red local.

Basicamente para el script use Python como lenguaje, y un herramienta para escaneo ARP-SCAN, todo esto para un sistema operativo GNU/Linux (Ubuntu o ElementaryOS).

Instalamos el arp-scan:

sudo apt-get install arp-scan

Con esta herramienta escanearemos las red en la cual esta conectada la PC, en este caso específico en la interface wlan0, con el siguiente comando:

sudo arp-scan --interface=wlan0 --localnet

Lo que nos retorna lo siguiente:

Interface: wlan0, datalink type: EN10MB (Ethernet)
Starting arp-scan 1.8.1 with 256 hosts (http://www.nta-monitor.com/tools/arp-scan/)
192.168.0.1	f0:7b:cb:89:ca:36	Hon Hai Precision Ind. Co.,Ltd.
192.168.0.10	ac:22:0b:84:e8:42	(Unknown)
192.168.0.11	5c:f9:38:a8:d9:32	(Unknown)
192.168.0.13	a8:16:b2:f8:04:5b	(Unknown)
192.168.0.19	00:c0:ca:75:70:98	ALFA, INC.

La primera ip, es del router (192.168.0.1) y las siguientes son de los hosts conectados a la red local (obviando la IP de la PC donde se realiza el escaneo), en este caso tenemos 5 hosts conectados a la red local (4 detectados + 1 de la PC)

Otra funcionalidad que use, son las notificaciones de Ubuntu, ese mensaje que aparece cuando se detecta una red wifi nueva, o cuando la batería de la laptop debe cargarse.

Para esto use el siguiente código:

#!/usr/bin/python
from gi.repository import Notify
Notify.init ("Hello world")
Hello=Notify.Notification.new ("Nueva notificacion","Hola, esta es una nueva notificacion","dialog-information")
Hello.show ()

Lo que nos muestra:

example_extension

Con estas herramientas procedemos a desarrollar el script:

#!/usr/bin/python
from gi.repository import Notify
import subprocess, re, os

path = os.path.dirname(__file__)
with open(os.path.join(path, 'ips')) as i:
    ipOrigin = i.read().splitlines()
f = open(os.path.join(path, 'ips'), 'rw+')
arpScan = "arp-scan --interface=wlan0 --localnet"
process = subprocess.Popen(arpScan.split(), stdout=subprocess.PIPE)
output = process.communicate()[0]
for line in  output.split("\n") :
    ips = re.findall( r'[0-9]+(?:\.[0-9]+){3}', line)
    for ip in ips:
        if ip not in ipOrigin:
            Notify.init ("Hello world")
            Hello=Notify.Notification.new ("Nueva conexion",ip,"dialog-information")
            Hello.show ()
        f.write(ip+'\n')
f.close()

Ese es el codigo inicial, que seguramente ire mejorando, pero la idea es almacenar las ip’s de los host’s en un archivo (llamado ips) para luego realizar un nuevo escaneo y buscar nuevas conexiones.

El codigo lo puse en github, para futuros cambios y versiones: https://github.com/jfabian/scan-lan

Antes de poder usarlo le damos permisos de ejecución (chmod +x), creamos el archivo ips y luego:

$ sudo ./scan

Y notificara una nueva conexión:

test_scan_lan

Lo último sería colocarlo en el crontab del sistema operativo, para que se ejecute cada cierto tiempo.

Abrimos el editor del crontab:

sudo crontab -e

Y agregamos la siguiente linea (el cron se ejecutara cada minuto):

*/1 * * * * env DISPLAY=:0 /usr/bin/python /opt/scan-lan/scan > /tmp/scan-lan.log

Previamente hemos colocado nuestro script scan y el archivo ips en una carpeta de nombre scan-lan dentro de /opt.

Reiniciamos el cron:

sudo service cron restart

Y listo, tenemos nuestro script funcionando.

El siguiente paso será empaquetarlo y colocarlo en un repo de Ubuntu 😀

Anuncios

Experiencias con ElementaryOS

Hace varios dias escucho hablar de ElementaryOS, una distro basada en Linux (específicamente en Ubuntu) que se ve recontra amigable y muy simple.

Logo ElementaryOS

Su instalación es muy parecida a Ubuntu (por no decir idéntica) y el resultado me gusto mas aun, es muy ligera. Me gusto mucho la distribución y la estoy usando a partir de ahora.

El escritorio se ve muy amigable:

Captura de pantalla de 2013-11-20 20:57:48

Y como comente, el consumo de recursos es poco:

Captura de pantalla de 2013-11-20 20:58:16

Distro recomendada 😀

Iniciandonos en Bottle

Bottle es un micro framework web muy útil interesante, practico a la hora de hacer pequeños proyectos web’s donde no se requiere mucha lógica en la capa de datos, controladores, etc.

Para empezar tenemos que instalarlo mediante pip (recomendable en Python2.7):

pip install bottle

Luego de ello haremos nuestra primera aplicación:

#!/usr/bin/env python
# importamos la libreria
import bottle

#definimos la ruta y la función que "cargara"
@bottle.route('/')
def index():
    return "<h1>Hola Mundo</h1>"

#levantamos el servidor web que tiene bottle
bottle.run(host='localhost', port=8080)

Luego accedemos a http://localhost:8080 en nuestro navegador y veremos el mensaje “Hola Mundo”.

Como se demostró, es muy sencillo levantar una aplicación web usando bottle. A opinión personal es útil cuando necesitamos aplicaciones muy simples o cuando necesitemos mostrar resultados de alguna otra aplicación.

Ya esta entre nosotros Mozilla Firefox 17!

Ha unas fue lanzado la version 17 de Mozilla Firefox, con novedades interesantes, bug corregidos y algunas observaciones.

Lo primero a tomar en cuenta es la inclusion de Social API, que hara que se tenga una integracion con facebook de manera muy interesante, podras ver tus notificaciones, solicitud de amistad en una barra de Mozilla Firefox. Asi como una barra de chat al lado derecho.

Para activarlo solo hay que ingresar a este link: https://www.facebook.com/about/messenger-for-firefox estando logueado y activarlo.

Y entre las caracteristicas mas resaltantes podemos mencionar:

  • Bloque por defecto en plugins que no estan actualizados.
  • Modificacion del inspector de paginas para facilitar la modificacion del DOM, y mejores en todo el panel de desarrollo en general.
  • Nuevas funciones en el SVG (FillPaint y StrokePaint)
  • Mapas de Javascript iterables.
  • Iconos mas grandes en la barra de notificacion.
  • Mayor seguridad en los iframes con la implementacion de sandbox.

Para ver a detalle pueden revisar este link: https://developer.mozilla.org/en-US/docs/Firefox_17_for_developers

Desarrollando en Ruby usando RVM

Al momento de desarrollar usando Ruby como lenguaje, surge a veces el incoveniente de trabajar con versiones diferentes a las que se maneja en produccion, para ello existe una solucion, usar RVM (Ruby Version Manager) que permite manejar diferentes versiones de Ruby, asi como mantener distintas “instancias” donde instalar las gemas de manera independiente. Algo muy similar al virtualenv usado en Python. (En otro articulo hablo un poco mas sobre virtualenv)

Instalacion

Lo primero que debemos ver, son los requisitos para poder instalar el paquete, necesitaremos tener git y curl instalado.

pacman -S git curl

Luego procedemos a descargar el paquete mediante curl (notar que estamos instalando la version mas estable de RVM).

curl -L get.rvm.io | bash -s stable

O si queremos descargar solo el script y luego procedemos a instalarlo:

$ curl -L get.rvm.io > rvm-install
$ chmod +x rvm-install
$ ./rvm-install

Luego tenemos que agregarlo al .bashrc:

[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"

Luego de todo esto, y si hicimos los pasos correctos, ya tenemos hemos instalado correctamente rvm, para verificarlo solo basta con:

$ rvm notes

Y saldran todas las caracteristicas de la instalacion.

Instalacion de Ruby

Hasta ahora solo hemos instalado el rvm pero aun no tenemos Ruby instalado, para ver la lista de enviroments disponibles en rvm usamos el siguiente comando:

$ rvm list known

Ahora procedemos a instalar Ruby

$ rvm install <version_ruby>

Podemos reemplazarlo por cualquier version, por ejemplo:

$ rvm install 1.9.2

Luego usamos la version de Ruby

$ rvm use 1.9.2

Ahora ya tenemos la version deseada de Ruby y podemos usarla:

$ ruby --version

Y podemos instalar otra version, y cambiarlo sin problemas. Toda la configuracion se guarda en carpetas independientes dentro de ~/.rvm.

Gemsets

Ahora que podemos manejar varias versiones de Ruby, tambien necesitamos tener “instancias” separadas para las gemas. Dichas instancias se denominan: Gemsets.

Para crearlo debemos seleccionar la version de Ruby que usaremos y luego ejecutar el comando correspondiente:

$ rvm use <ruby_version>
$ rvm gemset create <gemset_name>

Luego seleccionamos el Gemset a usar:

$ rvm use <ruby_version>@<gemset_name> --default

O tambien podemos crearlo y usarlo directamente:

$ rvm use <ruby_version>@<gemset_name> --create

Una vez seleccionado el Gemset a utilizar, podemos instalar las gemas que necesitemos, y cambiar de Gemset las veces que necesitemos y con la version de Ruby que querramos, manteniendo una independencia de codigo, y permitiendo manejar diferentes versiones para proyectos diferentes.

Bonus Track

Hay algunos comandos utiles de rvm que necesitaremos:

Nombre del Gemset actual

$ rvm gemset name

Lista de todos los Gemset disponibles para la actual version de Ruby

$ rvm gemset list

Lista de todos los Gemset disponibles todas las versiones de Ruby

$ rvm gemset list_all

Actualizando

$ rvm get latest

Instalacion de mongodb [Archlinux]

Cada vez se escucha mas sobre base de datos NoSQL, en especial de MongoDB, son muchas las ventajas al momento de trabajar gran cantidad de datos. Al estar basado en el modelo clave-valor, hace que el procesamiento sea mas rapido (si se implementa de una manera adecuada).

La instalacion es sencilla, esta en los repositorios oficiales de Archlinux:

pacman -S mongodb

Una vez instalado, accedemos ejecutando:

mongo

Podemos ver las base de datos que existen con el comando show dbs:

> show dbs
local	(empty)
test	0.203125GB
>

Virtualenv y setuptools en CentOS

Una de las principales recomendaciones al momento de trabajar en Python es usar virtualenv mas que todo por que nos ayuda a mantener librerias instaladas, versiones aislados por aplicacion.

En el caso de CentOS, no viene en la lista de repositorios, por lo que hay que instalarlo manualmente, antes de nada se necesitaran una serie de paquetes:

yum install gcc gdbm-devel readline-devel ncurses-devel zlib-devel bzip2-devel sqlite-devel db4-devel openssl-devel tk-devel bluez-libs-devel libjpeg-devel zlib-devel freetype-devel

Luego tenemos que instalar el setuptools el cual incluye el easy_install que nos permitira instalar el virtualenv.

Descargamos el codigo, en este caso al ser Centos 6.x se tiene instalado Python 2.6

wget pypi.python.org/packages/2.6/s/setuptools/setuptools-0.6c10-py2.6.egg

Luego procedemos con la instalacion del setuptools

sh setuptools-0.6c10-py2.6.egg

Ahora actualizamos e instalamos el virtualenv:

easy_install-2.4 -U setuptools
easy_install-2.4 virtualenv

Y con esto ya lo tenemos instalado.

PD. Pueden darse una vuelta por el manual oficial de virtualenv, para sacarle maximo provecho.

Leer PDF en Mozilla Firefox usando Evince

Generalmente cuando estamos buscando informacion nos encontramos con documentos PDF, si tenemos instalado el Adobe Reader no tendremos problemas para leerlo en el navegador, pero a veces usarlo puede afectar el rendimiento. No hay nada como algo nativo, y en el caso de GNU/Linux es mejor usar evince.

Mozilla Firefox wordmark

Es muy sencilla la configuracion, para esto es necesario usar un paquete llamado mozplugger, dependiendo la distribucion que uses lo puedes encontrar en los repositorios o, como es mi caso, instalarlo mediante el AUR (en otro post indico como instalar paquetes desde el AUR).

Una vez terminada la instalacion, tenemos que realizar los siguientes pasos:

Asegurarnos de eliminar el archivo pluginreg.dat:

rm ~/.mozilla/firefox/<profile_dir>/pluginreg.dat

Editamos el archivo /etc/mozpluggerrc, buscando la linea que contenga:

define(ACROREAD, [repeat swallow(acroread) fill : acroread -openInNewWindow /a "$fragment" "$file"])

Y lo cambiamos por:

define(ACROREAD, [repeat swallow(evince) fill needs_xembed : evince "$file"])

Reiniciamos el Mozilla Firefox y probamos intentando abrir cualquier archivo PDF desde la web, se nota la diferencia en temas de consumo de recursos.

Convertir libros PDF a MOBI para Kindle Fire [Arch Linux]

Hace unos meses vengo usando una Kindle Fire de Amazon, a razgos generales me parece una muy buena tablet para lectura. No es muy grande y tiene una muy buena resolucion, muy recomendado :).

La mayoria de nuestros archivos estan en formato PDF, pero para aprovechar mejor la lectura en una kindle fire, es necesario cambiarlo de formato, para esto vamos a usar Calibre.

En Arch Linux (y en cualquier distribucion GNU/Linux) la instalacion es muy simple, tenemos que ejecutar este comando en la terminal:

sudo python -c "import sys; py3 = sys.version_info[0] > 2; u = __import__('urllib.request' if py3 else 'urllib', fromlist=1); exec(u.urlopen('http://status.calibre-ebook.com/linux_installer').read()); main(install_dir='/opt')"

Para mas informacion sobre la instalacion puede revisar la documentacion.

Lo que haremos a continuacion es convertir un libro y sincronizarlo con la Kindle Fire:

  1. Agregamos libros a nuestra coleccion (icono superior izquierda).
  2. Seleccionamos el libro (que ya esta agregado en nuestra libreria) y seleccionamos el icono “Convertir Libro”.
  3. Escogemos el formato MOBI, que es para la Kindle Fire, tambien hay otros formatos.
  4. Listo!

Calibre tiene un visor de libros en formato MOBI, EPUB, ademas al conectar la Kindle Fire reconoce el dispositivo y te permite sincronizar los libros en ambos lados, un repositorio para conseguir ebook’s en linea, en general genial.

A continuacion dejo un Screencast, donde muestro todo lo que pude hacer con el Calibre:

Usando Calibre en Arch Linux from Jesus Fabian Cubas on Vimeo.

Problemas al actualizar el paquete fontconfig en Arch Linux

Como todos los dias, hoy realice un pacman -Syu en Arch Linux y me encontre con el siguiente error:

error: error al realizar la transacción (archivos en conflicto)
fontconfig: /etc/fonts/conf.d/20-unhint-small-vera.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/29-replace-bitmap-fonts.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/30-metric-aliases.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/30-urw-aliases.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/40-nonlatin.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/45-latin.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/49-sansserif.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/50-user.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/51-local.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/60-latin.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/65-fonts-persian.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/65-nonlatin.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/69-unifont.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/80-delicious.conf existe en el sistema de archivos
fontconfig: /etc/fonts/conf.d/90-synthetic.conf existe en el sistema de archivos
Ocurrieron errores, no se actualizaron paquetes

La solucion a este problema, consiste en eliminar de manera manual los archivos:

rm /etc/fonts/conf.d/20-unhint-small-vera.conf
rm /etc/fonts/conf.d/29-replace-bitmap-fonts.conf
rm /etc/fonts/conf.d/30-metric-aliases.conf
rm /etc/fonts/conf.d/30-urw-aliases.conf
rm /etc/fonts/conf.d/40-nonlatin.conf
rm /etc/fonts/conf.d/45-latin.conf
rm /etc/fonts/conf.d/49-sansserif.conf
rm /etc/fonts/conf.d/50-user.conf
rm /etc/fonts/conf.d/51-local.conf
rm /etc/fonts/conf.d/60-latin.conf
rm /etc/fonts/conf.d/65-fonts-persian.conf
rm /etc/fonts/conf.d/65-nonlatin.conf
rm /etc/fonts/conf.d/69-unifont.conf
rm /etc/fonts/conf.d/80-delicious.conf
rm /etc/fonts/conf.d/90-synthetic.conf

Luego de esto ya podemos actualizar el paquete fontconfig

 pacman -Sy fontconfig

Ahora el contenido dentro de la carpeta /etc/fonts/conf.d/ seran links simbolicos a /etc/fonts/conf.avail/, lo podemos comprobar con ls -al

Para mas informacion podemos revisar el articulo en la wiki de Arch.

Que tal les fue su actualizacion a ustedes?