Ir al contenido principal

Introducción a NetKit( II ): creando redes

Introducción_a_Netkit(I):Instalación
Introducción_a_NetKit(_III
):switches_y_enrutado
Introducción_a_NetKit
(IV):_Un_puente_a_Internet

Lo dicho es hecho, y a lo hecho...  seguimos con la segunda parte de la introducción a NetKit, ahora veremos como crear y configurar laboratorios pequeños ( sin routers, que es lo mismo pero hay que enrutar ), las conexiones hacia internet se demorarán probablemente hasta el fin de semana ya que se necesitan permisos de root en el host :P .

Nota: Recordad que las variables de entorno PATH y NETKIT_HOME tienen que estar como se especifica en la primera parte, la del man es opcional.

Por comodidad supondremos que tenemos un directorio solamente para esto ( mkdir ~/netkit ), $HOME/netkit/, desde ahí haremos y desharemos.

Por ahora nos limitaremos a un montaje mínimo, vamos a crear un laboratorio con dos máquinas ( m1 y m2 ) conectadas a un hub ( lo que aquí llaman un dominio de colisión ).

Lo primero será crear el archivo "lab.conf" en ~/netkit, el contenido será este:

===============================================================================

m1[0]=HUB1 m2[0]=HUB1

===============================================================================

La sintaxis es simple, en cada línea: < máquina >[ < índice de interfaz > ]=< dominio de colisión >

Ahora solo queda crear una carpeta con el nombre de cada máquina que esté en el laboratorio, en este caso m1 y m2, por ahora quedarán vacías pero todo lo que se meta ahí aparecerá en el '/' de la máquina .

Y ya está, si escribimosel siguiente comando levantaremos las dos máquinas lstart .   # ( o lstart ~/netkit )

Ahora mismo las máquinas están conectadas al mismo dominio de colisión ( el mismo "hub" ), pero no se pueden comunicar entre ellas ya que las interfaces no están configuradas, esto se puede hacer asignando una ip a una máquina y otra IP del mismo segmento a la otra, por ejemplo, 10.1.1.1 y 10.1.1.2, esto se puede hacer con: ifconfig < interfaz > < ip >

Siendo la interfaz en este caso eth0 ( si hubiera otra eth0 o eth1, y así ), y la ip la escojida para esa máquina.

Cuando nos aburramos de jugar podemos cerrar el laboratorio con:
*
* "lhalt ~/netkit" # o si ya estámos en el directorio lhalt .
*

  • Haciendo vhalt < máquina > a cada máquina
    *

  • Haciendo poweroff o halt desde la propia máquina virtual
    *

En caso de querer volver a iniciar el laboratorio nos dirá que ya existen archivos *.disk (que guardan el contenido de las máquinas) y que las opciones son borrarlos con lclean ~/netkit o continuar con lo anterior con lrestart ~/ netkit

Todo esto está muy bien si hay pocas máquinas, pero si el laboratorio es una red grande puede ser repetitivo levantar las interfaces una y otra vez, lo que se hace al principio se puede automatizar con un archivo < nombre máquina

.startup , que define lo que hará cada máquina, por ejemplo:

===============================================================================

!/bin/sh

ifconfig < interfaz > < ip >

===============================================================================

Nota: estos archivos necesitan permisos de ejecución, se les pueden dar con chmod +x < nombre de archivo >

Cuando hayamos acabado con las dos máquinas las iniciaremos y comprobamos que pueden comunicarse desde el principio.

Además el archivo lab.conf permite modificar otros parámetros de las máquinas, de esta forma se puede por ejemplo modificar la cantidad de memoria RAM de una máquina en concreto: < máquina >[MEM]=< memoria en megabytes >

Para más opciones consultad el man_de_lstart.

La próxima vez veremos como crear un laboaratorio más complejo, dos switches conectados estre sí, y cada uno a otra máquina, y veremos como hacer para enrutar el tráfico.

Hasta la próxima

Rompiendo captchas

Por cosas de la vida, últimamente ando trasteando con las arañas, crawleando cosas varias... y al final era inevitable toparse con los CAPTCHAs, así que se me ha presentado la ocasión de intentar vencerlos, por ahora esto es lo poco que he conseguido [ captcha_baker.py ], lo poco que hace el propio script es leer los pixels de la primera línea y pasar a blanco los que estén cerca de estos, y a negro el resto. Después corta las letras por las columnas en blanco.

El valor de la "cercanía" es modificable (de hecho la idea viene del parámetro "umbral" de la selección de color de GIMP).

Depende de Image Magick para convertir las imágenes a BMP, Python_Image Library para recortar las letras y tesseract-ocr para reconocer las letras.

No funciona demasiado bien, pero estoy bastante contento con el resultado para ser una primera prueba.

Los parámetros son:

===============================================================================

./captcha_baker.py []

===============================================================================

El número de letras no es realmente necesario, se puede poner a 0 para no considerarlo. El umbral por defecto es 15. Por último unas muestras.

El tipo de captchas para el que esta pensado:

===============================================================================

$ ./captcha_baker.py img.png 0 75 Convirtiendo a img.bmp ... 24 Leyendo primera fila Aplicando un umbral de 75 Guardando base: output.bmp Partiendo nosecuantas letras Letra 1: L Letra 2: L Letra 3: I Letra 4: B Resultado: LLIB

===============================================================================

Uno que me encotré por ahí [ Python_ocr_or_How_to_break_captchas ]:

===============================================================================

$ ./captcha_baker.py captcha.bmp 0 75 24 Leyendo primera fila Aplicando un umbral de 75 Guardando base: output.bmp Partiendo nosecuantas letras Letra 1: W Letra 2: 6 Letra 3: 8 Letra 4: 8 Letra 5: H Letra 6: P Resultado: W68HP

===============================================================================

Y uno que no consigue separar las letras porque no hay columnas en blanco, pero algo hace...

===============================================================================

$ ./captcha_baker.py img.jpeg 0 150 Convirtiendo a img.bmp ... 24 Leyendo primera fila Aplicando un umbral de 150 Guardando base: output.bmp Partiendo nosecuantas letras Letra 1: \ Resultado: \ $

===============================================================================

Peeero si se ve el archivo intermedio, antes de cortar:

se puede ver que el que escribe metió la pata al programar la clase BMP ... ah! y que algo sí que limpia.

Nos vemos

Cálculos con Python

Mientras no saco tiempo para algo más elaborado, cálculos de raíces e interpolación con Python! * Cálculo de raíces con el método_de_Newton-Raphson: *

def newton( indice, funcion_der, funcion, x ):

for i in xrange(indice):

 x -= funcion( x ) / float(funcion_der( x ))

return x

El primer parámetro es el número de iteraciones a realizar, el segundo indica la función derivada, después la función, y por último el punto de partida. Por ejemplo: it = 5

print "Raíces [ %s iteraciones]" % it

print "Función: Raíz estimada Valor real"

Newton-Raphson para x

n = newton( it, lambda x: 1, lambda x: x, 10 )

print "x : %s %s" % (n, n)

Newton-Raphson para x + 1

n = newton( it, lambda x: 1, lambda x: x+1, 10 )

print "x + 1 : %s %s" % (n, n+1)

Newton-Raphson para 2x

n = newton( it, lambda x: 2, lambda x: 2*x, 10 )

print "2x : %s %s" % (n, 2n)

Newton-Raphson para x**2

n = newton( it, lambda x: 2x, lambda x: x*2, 10 )

print "x2 : %s %s" % (n, n2)

Salida: Raíces [ 5 iteraciones]

Función: Raíz estimada Valor real

x : 0.0 0.0

x + 1 : -1.0 0.0

2*x : 0.0 0.0

x**2 : 0.3125 0.09765625

* Interpolación con el polinomio_de_Lagrange: *

Este se realiza en dos pasos, primero se obtiene el polinomio de Lagrange para un conjunto de puntos def dd(p1, p2):

return (p1[1] - p2[1]) / ( p1[0][0] - p2[0][-1] )

def lagrange(points):

d = [(points[0][1],[])]

refs = map( lambda x: x[0][0], points)

x = 1

while len(points) > 1:

   p = []

   for i in xrange(len(points) - 1 ):

       p.append((points[i][0] + [points[i+1][0][-1]] ,dd(points[i], points

[i+1])))

   if p[0][1] != 0: # Si se multiplica por 0 ni se considera

       d.append((p[0][1], refs[:x]))



   points = p

   x += 1

return d

Se pasa a lagrange() un array de duplas ( punto, valor en ese punto ).

A continuación se aplica el polinomio a un punto: def xprod( l, x ):

v = 1

for i in l:

   v *= ( x - i )

return v

def solve( l, x ):

return sum(map(lambda y: y[0] * xprod( y[1], x), l)) Se pasa a solve() el polinomio y el punto a esclarecer.

Otra opción es mostrar cómodamente la función:

def fprod( l ):

if len(l) == 0: return ""

a = []

for i in l:

   a.append("x +%s" % -i if i < 0 else "x %s" % -i if i != 0 else "x")

return "(%s)" % ')('.join(a)

def form( l ):

return ' + '.join(map( lambda y: str(y[0]) + fprod( y[1] ),l)) Se le pasaría a form() el polinomio como parámetro.

Por ejemplo: l = lagrange([ # Point, value

     ([1], 1 ),

     ([2], 4 ),

     ([3], 9 )

          ])

print "f(x) = %s"%form(l)

print "\n# Valores de muestra #\n"

for i in xrange( 4, 10):

print "f(%s) = %s" % (i, solve(l, i))

l = lagrange([( [0], 5 )])

print "\n######################\n"

print "f(x) = %s"%form(l)

Salida: f(x) = 1 + 3(x -1) + 1(x -1)*(x -2)

Valores de muestra

f(4) = 16

f(5) = 25

f(6) = 36

f(7) = 49

f(8) = 64

f(9) = 81

f(x) = 5

Lo malo que está quizá demasiado compactado :/

Saludos

One liners( 10 ): limpiando metadatos

Para limpiar los metadatos de una imágen ( habiendo importado la clase Image de PIL ): Image.open( entrada ).save( salida )

O, como un script independiente:

!/usr/bin/env python

from PIL import Image

from sys import argv

if len(argv)!=3: print "%s " % argv[0]

else:Image.open(argv[1]).save(argv[2])

Saludos

Comienzo del desarrollo de un plugin de Liberateca para Moovida

Pues eso, la idea es poder navegar a través de las series/temporadas/ capítulos de liberateca con moovida, un media center multiplataforma escrito en python si no recuerdo mal.

El código está aqui: [ http://codigoparallevar.co.cc/files/ liberateca_moovida_dev.zip ]

Se descomprime y ejecuta "build_and_install.sh" y ya se encarga eso de todo ;), pero... - Para usarlo hay que pasarse por la configuración de los complementos en el menú principal de Moovida e introducir las credenciales ( aún no son persistentes, hay que meterlas cada vez que se inicia el programa ), el resto es obvio

  • Aún no reproduce xD ( mañana sin falta )

  • El código es muy sucio, como no encontre ningún decente, hubo que hacer uso de "copy-paste oriented programming".

  • El logo es el de la página principal para ir tirando, yo soy un negado para lo que necesite un poco que gusto con el diseño, si alguien se ofrece para encargarse de los iconos seguro que quedaría mucho mejor de lo que puedo conseguir.

Enfin, ahí queda, voy a sobar que son horas =_=

ps: Si alguien da por casualidad con un tutorial sobre como hacer los plugins me arregla la vida, que llevo dos días para hacer esto :P

Un bot eliza para IRC

Bueno, pues me encontré en [ http://www.jezuk.co.uk/cgi-bin/view/software/ eliza ] un bot eliza programado en python que puede ser usado directamente o como módulo, así que traducido a español y con la_librería_de_IRC pues ya está listo un bot para hacer la gracia.

Todo junto aquí [ wilson.zip ]  (hay que ejecutar a wilson.py)

Conversación surrealista típica

Es una IA cutre, pero sirve para reirse un rato con algún despistado :P

Enfin eso es todo, se ve que faltan ideas, saludos

Arkanoid con Pygame

Este juego lo había escrito para un concurso de programación hace varios meses, pero no conseguí que las colisiones funcionaran bien, ahora que ya he conseguido arreglarlo minimamente y he añadido un par de cambios, este es el resultado:  

Aquí [ game_ark.zip ] está el código, solo hay que ejecutar pyng.py

No espereis gran cosa, fue sobretodo un acercamiento a la programación de juegos, pero tenía ganas de verlo funcionar :P .

Hasta otra

Generador de shellcodes para Gnu/Linux en Javascript

No se me ocurre mucho que contar, he subido un pequeño experimento, un generador de shellcodes a [ http://codigoparallevar.co.cc/utils/shellcode.html ], no es gran cosa, lanza un execve al archivo indicado. Ojo, que no separa los parámetros con espacios, solo es la ruta, pero todo se andará. Lo que hace es simplemente mostrar un código estático e incluir los "push" para introducir los datos necesarios.

Enfin, es poca cosa pero puede servir para salir de un aprieto.

A portarse bien...

One liners( 9 ): colorines

main(){int o=!o;for(;;o=rand()%8)printf("\e[0;%xm%x\e[0m",48+o,o);}

F*ck Yeah! C one liners :D}