Invertir los canales de sonido

Otro script más que engrosa las listas de lo programado solo por programar [http://pastebin.com/FzQmDxKP].

Recibe como parámetros el archivo original y el nombre del que se creará y copia el sonido del primero en el segundo cambiando el canal de la derecha por el de la izquierda y viceversa.

Meh... pues si que quedo pequeño el post =P.

[Offtopic] Thunderbird te avisa si te olvidas de adjuntar algo

Parece que thunderbird añadió la característica de avisar al usuario de que falta algo por adjuntar si observa algo en el mensaje que indica que se debería haber hecho (algo como nombrar un tipo de archivo común)

Improvisando un cifrado de flujo/generador de números aleatorios

A veces hay que hacer un pequeño sistema de cifrado para la ocasión que no tiene porque ser criptográficamente seguro, una chapuzilla vamos, veremos como improvisar uno.

El hola mundo con el alfabeto fonético

La idea original era hacer define de las letras "fonéticas" a su equivalente normal y despues unirlas, todo con el preprocesador, pero parece que este funciona al reves, primero cambia las funciones y después lo demás, ademas no se puede usar la recursividad (que un archivo se incluya a si mismo), porque cada nivel vuelve a ver el archivo original. Así que habrá que conformarse con esto, que es bastante menos elegante, pero enfin...

De heuristicas, antivirus y malware

Antes de nada, ningun ordenador fue infectado por malware en el proceso y lo que viene a continuación se hizo con el único fin de pasar el rato, si lees esto con la esperanza de saber como infectar más ordenadores o algo por el estilo, lo siento (... en realidad no) pero no estas en el lugar indicado, ve con root.

Pues presento un programa que genera otros programas ensamblando componentes (una shell inversa, un proxy SOCKS4 , un bot IRC... ), al principio no tenía ningun propósito pero parece que los módulos por separado pueden servir para echarle un vistazo a la euristica de los antivirus.

Un wallpaper nuevo cada día (con CFDG)

Trasteando con CFDG, por decirlo así, el "padre" en 2D de Structure Synth, y tras comprobar que tiene la misma capacidad que su versión en 3D de generar gráficos aleatorios "interesantes", y que el fondo de pantalla ya lleva un buen tiempo siendo el mismo, ¿que mejor que hacer que este lo genere un programa, haciendo que sea nuevo cada vez? :D

La idea es bastante simple, hacer un script que llame a CFDG sobre un código hecho antes cada vez que se quiera (que el usuario se loguee o cada cierto tiempo aprovechando cron).

El script en sí es bastante sencillo, algo así lo haría perfectamente

---

 #!/usr/bin/env bash

wide=1280
high=800

cfdg back.cfdg -oback.png -w $wide -h $high &

---

Por supuesto, habría que cambiar wide por el ancho de la pantalla y high por su alto, para generar una imágen óptima.

El resto no es más dificil, hacer un archivo de CFDG, este por ejemplo genera espirales que parecen hechas con rotulador (¿?) , es grande para incluir más variaciones:

---

startshape init

rule init{
    dot { saturation 1}
}

// Dot made
rule dot 0.01 {
     SQUARE { }
     dot { s 0.995 rotate 1 x 1 hue -1  }
}

rule dot  {
     SQUARE { }
     dot { s 0.995 rotate -1 x 1 hue 1 }
}

rule dot 0.9 {
     SQUARE { }
     dot { s 1.005 rotate 1 x - 1}
}

/*// Comment this for removing color
rule init 1000{
    dot { saturation 1 brightness 0.9 }
}

rule dot 0.01{
    dot { brightness 0.90 }
}

rule dot 0.01{
    dot { brightness 0 }
}

rule dot 0.01{
    dot { brightness 0.4 }
}

rule dot 0.005{
    dot { hue 180 }

}
//*/

---

(El /* se puede eliminar para tener algo de colorido, para gustos...)
Y la imagen resultante de ejecutar el script se utiliza de fondo de pantalla, el resultado podría ser algo así en este caso:

Aunque claro, la gracia está en el cambio. Cómo hacer que se ejecute el script es cosa de cada uno, la forma más facil en las distribuciones con gnome (para Xfce, KDE lo mismo) es a través de Sistema > Preferencias > Aplicaciones al inicio, aunque (como ya se dijo antés), cron puede ser una opción interesante para que se renueve incluso cuando no se hace logout.

Hasta otra.

ps: La instalación de CFDG no tiene ningún misterio, se descomprime, se hace make para compilar y sudo cp cfdg /usr/bin/ para instalar.

[Referencias]
CFDG HowTo

Hablando por el terminal

Hoy traigo algo medio OffTopic, para pasar el rato.

Un intérprete de comandos ya permite pasarse horas programando cosas más o menos útiles, pero si además le añadimos un sintetizador de voz, las posibilidades solo las limita la imaginación.

eSpeak es un programa (disponible a través del paquete correspondiente) que permite usar un sintetizador de voz por línea de comandos (aunque tambien tiene una gui), la entrada por defecto se hace por stdin, así que utilizando tuberías (pipes) se pueden hacer cosas bastante curiosas, el parámetro más a tener en cuenta es la voz (que regulará la pronunciación), por defecto es el inglés, pero con -ves se puede configurar para castellano, la sintaxis, es -v[código del idioma]

Algunos ejemplos de su uso pueden ser

---

fortune | espeak -ves

---

para que lea una frase aleatoria

o

---

i=1
while [ $i -le 10 ]
    do
    j=1
    while [ $j -le 10 ]
        do
        r=$(( $i * $j))
        echo "$i por $j es = a $r"
        j=$(($j + 1))
    done
    i=$(($i + 1))
done|espeak -ves

---

o en una línea

---

i=1;while [ $i -le 10 ]; do j=1; while [ $j -le 10 ]; do r=$(( $i * $j)); echo "$i por $j es = a $r"; j=$(($j + 1)); done; i=$(($i + 1)); done|espeak -ves

---

para que diga la tabla del 1 al 10

El resto es cuestión de imaginación, combinado con un poco de scripting puede servir para que avise cuando la temperatura del PC sube demasiado, cuando llegue una hora preconfigurada (típica alarma)  o cuando alguien está hablando con nosotros por el IRC... lo difícil es encontrar algo para lo que sea realmente necesario :)

Hasta otra.

[Referencias]
http://espeak.sourceforge.net/

Fortunes con javascript y perl

¿Quien no conoce las miticas frases que suelen salir cuando se hace login en un sistema? (al menos en Slackware), tambien conocidas como Galletas de la suerte, fortunes, o algo asi...

¿Seria curioso poder usarlas tambien en una pagina web y que cada vez que carge la pagina salga una diferente, no?, pues no es demasiado dificil. Si las instalaste " sudo apt-get install fortune " puedes encontrar varias en /usr/share/games/fortunes/ , el formato que siguen es bastante sencillo, es texto plano, separando una "galleta" de otra con una linea con solo un %, seria algo asi:

Frase nº 1
%
Frase nº 2
%
Frase nº 3
...

Siendo tan sencillo el formato, se pueden aprovechar facilmente los archivos para cualquier cosa, por ejemplo (o para descargar [fort2js.pl] ):

---

#!/usr/bin/env perl

if ($#ARGV != 1){ # Se comprueba que se especificaron los dos archivos
    print "./fort2js.pl <fortune> <javascript>\n";
    exit(0);
}

$fname = $ARGV[0];
$foutname = $ARGV[1];

print "fort2js: ".$fname." -> ".$foutname."\r\n";

$fname = "<".$fname; # Archivo que se lee
$foutname = ">".$foutname; # Archivo que se escribe
$i = 0; # nº de fortunes
open (F, $fname);
open (O, $foutname);
print O "function get_cookie(v){var cookie = new Array(\""; # Cabecera de la funcion

while ($line = <F>){
    if (substr($line,0,1) eq "%"){ # Si es el fin de una fortune
        print O "\",\""; # Nueva posicion en el array
        $i++; # Una fortune mas
    }
    else{
        $line =~ s/\ \ /\ /g; # Se eliminan los dobles espacion
        $line =~ s/"/\\"/g; # Se escapan las comillas
        $line =~ s/\n/<br\/>/g; # Se cambian los saltos de linea por <br/>
        $line =~ s/\r//g; # Se eliminan los retornos de carro
        print O $line;
    }
}
print O "\");return cookie[v]}"; # Fin de la funcion
print O "function max_cookie(){return ".$i.";}"; # Funcion max_cookie()
close F, O;

---

Esto sirve para convertir un archivo de fortune's en uno de Javascript que permita usar las "galletas" con dos funciones, get_cookie(i) para recuperar la frase numero i y max_cookie() que servira para saber de cuantas "galletas" podemos hacer uso.
El archivo que resulta de hacer ./fort2js.pl <archivo de galletas> < archivo de salida> se puede usar muy facilmente, solo habria que subirlo a algun lugar, y añadir algo como esto al codigo HTML donde queramos que se muestre:

---

<div id="cookie">[Cargando...]</div>
<script type="text/javascript" src="http://sitio.donde.esta/archivo/donde/esta"></script>
<script type="text/javascript"><!--//

var rand=Math.floor(Math.random()*max_cookie());
document.getElementById('cookie').innerHTML=get_cookie(rand); //--></script>

---

Y ya estan listas las galletas de la fortuna :D

Hasta ahora!
[Referencias]
http://www.w3schools.com/js/default.asp
http://en.wikipedia.org/wiki/Fortune_(Unix)

Probando shellcodes

Pues hoy vengo con poca cosa, andaba escribiendo algo para pasar el rato... un programilla para probar shellcodes ¿porque no?

Y este es el resultado [ shellcode_tester.c ] o al final coloreado con Pygments

La compilacion es simple, solo hay que hacer
gcc shellcode_tester.c -o shellcode_tester

Las opciones al lanzarlo son:
./shellcode_tester [-nv] [-nw] [-nr] [-f <archivo>]
-nv: No verbose (no se imprimira nada por pantalla)[--no-verbose]
-nw: No write (no se permitira escribir en la memoria del shellcode)[--no-write]
-nr: No read (no se permitira leer la memoria del shellcode)[--no-read]
-f: Introduce el shellcode a traves de un archivo

Mas o menos, usarlo seria algo asi:
kenkeiras@viaxante:~/%%%%%$ ./shellcode_tester
    Shellcode Tester

Introduce el shellcode: \x31\xdb\x8d\x43\x17\xcd\x80\x31\xd2\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\x8d\x42\x0b\xcd\x80\x31\xc0\x40\xcd\x80

Ejecutando Shellcode... [36]
$ echo "Esto es otra shell :D}"
Esto es otra shell :D}
$
kenkeiras@viaxante:~/%%%%%$

---

/*
*  Shellcode Tester (Yet Another Shellcode Tester)
*  Copyright (c) 2010 Kenkeiras
*
*          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
*                  Version 2, December 2004

*
* Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
*
* Everyone is permitted to copy and distribute verbatim or modified
* copies of this license document, and changing it is allowed as long
* as the name is changed.

*
*            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
*   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
*
*  0. You just DO WHAT THE FUCK YOU WANT TO.
*

*
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/mman.h>

#define max_size 1024 //Caracteres maximos para el shellcode

// Como (sh en Gnu/Linux de 32 bits)
// \x31\xdb\x8d\x43\x17\xcd\x80\x31\xd2\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\x8d\x42\x0b\xcd\x80\x31\xc0\x40\xcd\x80


char *scs = NULL;

char *sc = NULL;

char a2h(char c){

    char r;
    if (c>'9'){
        if (c>'Z')

            r=c-0x57;
        else
            r=c-0x37;

    }
    else
        r=c-0x30;
    return r;

}

// Formas de leer los shellcode

// \x99\xAA\xaa (\x<numero en hexa>)
int bar_hexa(char *in,char *out){

    char curr;
    int i,r=-1,len=0;

    for (i=0; (i < max_size) && in[i] != '\0'; i++){

        if((r == 2) || ((in[i] == '\\') && (r > 0))){

            r =- 1;
            out[len] = curr;

            len++;

        }
        if(in[i] == '\n'){

            break;
        }
        else if (in[i] == '\r'){

            continue;
        }
        else if (in[i] == 'x'){

            r = 0;
        }
        else if(r >- 1){

            if (r == 0){
                curr = a2h(in[i])*16;

            }
            else{
                curr = a2h(in[i]) + curr;

            }
            r++;
        }
    }
    return len;

}

// Escrito directamente
int raw_bin(char *in,char *out){

    int i,len=strlen(in);
    for (i = 0;i < len;i++){

        out[i] = in[i];
    }
    return len;

}


int main(int argc,char **argv){

    FILE *f = stdin;
    char verbose = 1;

    char stack_write = 1;
    char stack_read = 1;

    int i,len,r;

    sc=malloc(max_size+1);

    if (argc>1){
        for (i=1;i<argc;i++){

            if ((strcmp(argv[i],"-nv") == 0) && (strcmp(argv[i],"--no-verbose") == 0)){

                verbose = 0;
            }
            else if ((strcmp(argv[i],"-f") == 0) && ((i+1)<argc) ){

                f = fopen(argv[i+1],"r");
                i++;

            }
            else if ((strcmp(argv[i],"-nw") == 0) && (strcmp(argv[i],"--no-write") == 0)){

                stack_write = 0;
            }
            else if ((strcmp(argv[i],"-nr") == 0) && (strcmp(argv[i],"--no-read") == 0)){

                stack_read = 0;
            }
            else{
                printf("Uso: ./shellcode_tester [-nv] [-nw] [-nr] [-f <archivo>]\n");

                printf("-nv: No verbose (no se imprimira nada por pantalla)[--no-verbose]\n");
                printf("-nw: No write (no se permitira escribir en la memoria del shellcode)[--no-write]\n");
                printf("-nr: No read (no se permitira leer la memoria del shellcode)[--no-read]\n");

                printf("-f: Introduce el shellcode a traves de un archivo\n");
            }
        }
    }

    int PROT_MODE = PROT_EXEC|PROT_NONE ;
    if (stack_write){

        PROT_MODE |= PROT_WRITE;
    }
    if (stack_read){

        PROT_MODE |= PROT_READ;
    }

    if (verbose){

        printf("\tShellcode Tester\n\n");
        printf("Introduce el shellcode: ");
    }

    char *s = malloc((max_size*4)+1);

       fgets(s,max_size*4,f);
    r=-1;

    len = bar_hexa(s,sc);

    if (len < (strlen(s)/4)){

        len = raw_bin(s,sc);
    }

    free(s);

    scs=mmap(0,len+1,PROT_MODE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);

    for (i=0;i<len;i++){
        scs[i]=sc[i];

    }

    free(sc);

    if (verbose){

        printf("\nEjecutando Shellcode... [%i]\n",len);
    }
    (*(void(*)()) scs)();

    if (verbose){
         printf("Fin del Shellcode\n");
    }

    return 0;
}

---

Hasta otra

Logo y colorines ( y II )

Volvemos con la segunda parte sobre Logo, con unas cuantas figuras...

La primera, para empezar es bastante facil:
to figura1 :veces :tamanho
     repeat :veces[right 360/:veces
                   repeat 360[ forward :tamanho right 1 ]
                   ]
end

Y " figura1 72 2  " resulta en ...

Fractales
Pasamos a algo mas dificil :)}

¿Que es un fractal? (segun Wikipedia)

Un fractal es un objeto semigeométrico cuya estructura básica, fragmentada o irregular, se repite a diferentes escalas.^[1] Una mejor manera para comprender el comportamiento fractal de nuestro universo es considerar la siguiente definición: "Patrones que se repiten a distintas escalas".
A un objeto geométrico fractal se le atribuyen las siguientes características:^[2]

• Es demasiado irregular para ser descrito en términos geométricos tradicionales.
• Posee detalle a cualquier escala de observación.
• Es autosimilar (exacta, aproximada o estadística).
• Su dimensión de Hausdorff-Besicovitch es estrictamente mayor que su dimensión topológica.
• Se define mediante un simple algoritmo recursivo.

Dejemos aparte todo lo de "autosimilar", "dimensiones topologicas" y demas... lo mas comprensible es que "se repite a distintas escalas" y "se define mediante un simple algoritmo recursivo", vamos a probar...

to fractal_cuadrado :long :prof
    if prof <= 0 [stop]
    repeat 4[ forward :long
                     right 90
                     fractal_cuadrado :long/(2.5) :prof-1
                   ]
end

Llamando a "fractal_cuadrado 300 5", conseguimos esto:

Veamos como funciona, y de paso como hacer que el codigo sea aplicable a cualquier figura, la idea es esta:

to fractal_cuadrado :long :prof
No necesita explicacion, declaramos la funcion fractal_cuadrado, con los argumentos long (longitud) y prof (profundidad)

if prof <= 0 [stop]

El caso base, si ya se llego al ultimo nivel de profundidad, ya se acabo

    repeat 4[ forward :long
                     right 90
                     fractal_cuadrado :long/(2.5) :prof-1
                   ]

Como se puede ver, es practicamente el mismo codigo que para dibujar un cuadrado, solo se le añade   fractal_cuadrado :long/(2.5) :prof-1  al final, lo que hace que en cada esquina repita el proceso completo, pero haciendolo mas pequeño y con menos profundidad (sino acabaria siendo infinita)

Es decir, que en cada esquina del cuadrado, se dibuja un cuadrado mas pequeño, y en cada esquina de ese cuadrado, otro aun mas pequeño, asi hasta que se alcance la profundidad maxima (a este proceso se le llama recursion)

end
Fin de la funcion

Ahora veamos como modificar el codigo para que funcione con otras figuras, el caso base no cambia...
to fractal2 :lados :long :prof
    if prof <= 0 [stop]

... asi que solo nos queda el
    repeat 4[ forward :long
                     right 90
                     fractal_cuadrado :long/(2.5) :prof-1
                   ]

De nuevo,es bastante reconocible la parte que dibuja el cuadrado (esto se explica en el otro post sobre logo), asi que...
    repeat :lados[ forward :long
                     right 360/:lados
                     fractal2 :lados :long/(2.5) :prof-1
                   ]
Solo falta el    fractal2 :lados :long/(2.5) :prof-1 ,  la unica parte que hay que cambiar es la de :long/(2.5),  el problema es que este numero (el 2.5 ) es algo arbitrario, debe ser lo suficientemente alto como para separar las figuras "que salen de las esquinas", distancia que es mayor a medida que aumenta :log, pero sin pasarse, por ejemplo :long/(2+((:lados/100)*(:lados*:lados))) servira, asi , el codigo queda

to fractal2 :lados :long :prof
    if prof <= 0 [stop]
     repeat :lados[ forward :long
                     right 360/:lados
                     fractal2 :lados :long/(2+((:lados/100)*(:lados*:lados))) :prof-1
                   ]
end

Y llamando a "fractal2  3 200 4"...

(¿A nadie le suena de algo?)

Y para ir acabando... arboles binarios!

Un arbol binario es uno que del que salen dos arboles (tambien binarios), de los que vuelven a salir dos, y ... bueno, ya cojeis la idea

to arbol_binario :long :prof :grados
    if prof <= 0 [ stop ]
    forward :long
    left :grados
    arbol_binario :long/2 :prof-1 :grados
    right :grados*2
    arbol_binario :long/2 :prof-1 :grados
    left :grados
    back :long
end

Veamos como va, se que habra a quien le aburra y lo vea claro, pero, si ese es el caso, siempre os podeis saltar la explicacion... (Esta vez voy a prescindir del codigo)

La idea basicamente es hacer que cada vez que el arbol avance, se divida en dos y repetir en cada uno de los dos el mismo proceso, para que esto se pueda hacer, ademas hay que volver a la posicion original cada vez (si, simple y rapido)

Llamando a arbol_binario 200 10 30  tenemos:

Y eso es todo con Logo!

Pero espera... esto es "Logo y colorines" !! , hace falta algo de color, volvamos a la primera imagen:

La abrimos con GIMP y usamos en los filtros Artistico>GIMPresionista, el Crosshatch, obtenemos esto:

Seleccionamos todo lo que no es el fondo, y se aplica una mezcla de Quemado, con forma Radial, con centro en el centro del circulo, el resultado:

No es gran cosa, pero tendra que valer :P
Ahora si, hasta otra!

[Referencias]
http://et.bgcbellevue.org/logo/fractals.html

Logo y colorines

Hace un par de dias que estoy trasteando con Logo [ en la wikipedia ] , un lenguaje de programacion diseñado con fines didacticos y que en este caso me parece interesante por que hace muy facil dibujar cosas en la pantalla, como lo que llaman "graficos de tortuga", lo de "tortuga" es por que el cursor era representado como una tortuga y se utiliza para referirse a el (a pesar de que en programas como ucblogo no sea una tortuga, sino simplemente una flecha )

[Nota:] probablemente haya una funcion para extraer la imagen, sino siempre os queda el Imprimir pantalla (como hice yo)

[Nota:] al final dejo unos cuantos interpretes, de todas formas, si usais un sistema Unix, casi seguro que podeis conseguir el ucblogo, ya sea por synaptic, port's o su pagina web ( http://www.eecs.berkeley.edu/~bh/logo.html )

No se necesitan muchas instrucciones para utilizarlo y pasar el rato, las instrucciones "basicas" son:

Para avanzar: forward <numero de pasos> (o fd <numero de pasos> )
Para retroceder: back <numero de pasos> (o bk <numero de pasos> )
Para girar a la derecha: right <grados que se gira> (o rt <grados que se gira> )
Para girar a la izquierda: left <grados que se gira> (o lt <grados que se gira>)
Para volver a la posicion inicial: home
Para limpiar la pantalla: clean
Para repetir instrucciones: repeat <veces que se repite> '[' <Instrucciones que se repiten> ']'
Para definir una nueva funcion: to <nueva instruccion a definir> [:<argumento1>] ... [:<argumentoN>]
[instruccion] ... [instruccion] END
Finalizar una funcion antes del stop : stop
Ocultar la tortuga: hideturtle ( o ht )
Mostrar la tortuga: showturtle ( o st )
Condiciones: if <condicion> '[' <acciones> ']'


Asi que, por ejemplo, para hacer una funcion que muestre un cuadrado, escribiriamos:

   to cuadrado
      forward 50
      right 90
      forward 50
      right 90
      forward 50
      right 90
      forward 50
      right 90

   end

o lo que es lo mismo:
 

   to cuadrado
      repeat 4[forward 50 right 90]
   end

Esto dibujaria un cuadrado cada vez que se hace cuadrado con unos lados de 50 pasos

...pero como hariamos para poder elegir la longitud de los lados ?
Veamos, las variables se usan con un ':', asi que...

   to cuadrado :lado
     repeat 4[ forward :lado right 90]
   end


[Nota:]  en los dos casos se podria usar left en vez de right, como sabeis, lo importante es girar 90 grados, no importa la direccion

 Y dibuja un cuadrado cuando se llama a cuadrado <tamaño> , por ejemplo, con  cuadrado 200, dibuja un cuadrado con 200 pasos de lado

Ahora vamos a añadir algo mas, como hariamos una funcion que dibujara una figura con el numero de lados que queramos?
Seguramente ya se te haya ocurrido (no tiene demasiada dificultad precisamente :P), pero para quien no, ahi va la explicacion:

Si te fijas en la "formula del cuadrado", va asi (en pseudocodigo):
  repite 4 veces [ avanza :longitud gira 90 ]
Conclusiones:
  - Se repite el mismo numero de veces que lados hay (4)
  - Los grados que se giran son los mismos que 360 (los de una vuelta completa) entre el numero de lados (hay que empezar y acabar en el mismo punto y con el mismo angulo)

Esta seria una posibilidad
to figura :num_lados :distancia
  repeat :num_lados [ forward :distancia right 360/:num_lados]
end

Entonces, para hacer un triangulo de 100 de lado, solo habria que escribir
figura 3 100

Y para un cuadrado
figura 4 100

Y para un pentagono
figura 5 100

... creo que ya pillais la idea  :)

Vale, sigamos... si lo que queremos dibujar es un circulo, habria que hacer que de una vuelta de 360 grados, girando sin parar (por decirlo de alguna forma), verdad?
to circulo
  repeat 360[forward 1 right 1]
end

Y ahora... espirales :)
Para esto vamos a utilizar funciones recursivas, para quien no sepa lo que son, las funciones recursivas son las que se llaman a si mismas, por ejemplo el factorial:
si x es 0-> factorial(x)=1
sino-> factorial(x)=x*factorial(x-1)

Por supuesto, hay mas formas de hacerlo, pero esta forma de trabajar nos permitira hacer fractales mas adelante *-*

A lo que hiba, para dibujar una espiral se necesitan varios datos, en este caso vamos a usar la distancia del paso, el angulo de giro y un limite de tamaño, el pseudocodigo seria este:

para espiral :distancia :angulo :limite
   si :distancia>:limite [para]
   avanza :distancia
   gira :angulo
   espiral :distancia+1 :angulo :limite



Veamos detalladamente lo que hace:
 
si :distancia>:limite [para]
Si ya pasamos el limite, ya acabamos
...
Sino
avanza :distancia
girar :angulo
Estos dos no necesitan explicacion, no?
espiral :distancia+1 :angulo :limite
Y hacemos que la espiral siga avanzando, pero ahora, que la distancia sea mayor (para que se vaya "abriendo")

Si pasamos el codigo a Logo...
to espiral :distancia :angulo :limite
  if :distancia>:limite [stop]
  forward :distancia
  right :angulo
  espiral :distancia+1 :angulo :limite
end
Asi, haciendo espiral 0 90 200 (un angulo de 90 para que sea cuadrado) conseguimos:

Pero si cambiamos el angulo un poco... espiral 0 91 200

Ademas, le podemos añadir alguna variable mas para controlarlo mejor

to espiral :distancia :angulo :limite :incremento_distancia
  if :distancia>:limite [stop]
  forward :distancia
  right :angulo
  espiral :distancia+:incremento_distancia :angulo :limite :incremento_distancia
end

Esto añade la opcion de separar mas las lineas, por ejemplo, si a la primera figura se le pone 2 de separacion (1 es el que se usaba antes)... espiral 0 90 200 2

o con el angulo cambiado... espiral 0 91 200 2

Ahora a lo divertido... :D

Con esta funcion, y jugando con filtros de imagenes se  pueden conseguir cosas bastante curiosas... por ejemplo:
Usando espiral 0 121 200 1 obtenemos esta imagen:

 

 Y usando un filtro "Olify" de la categoria "Artistic" (o "Pintura al oleo" de "Artistico") del GIMP:

 

Supongo que en estos casos (cuando se pierde informacion al aplicar el filtro) es mejor ampliar la imagen antes de usar el filtro, asi se notara menos ;)

Y si despues añadimos algo de color...

Ya esta :D!

PS: Tenia pensado hacer un script que cambiase el color de una imagen segun cuanta "luz" hay alrededor ( cuantas mas lineas blancas , mas "luz" ), para hacer efectos directamente con las imagenes de Logo, sin necesidad de un programa de manipulacion de imagen, pero se de imagenes lo que un gato de fisica cuantica, asi que no prometo nada :P

Hasta otra!

[Interpretes]
UCBLogo  ( http://www.eecs.berkeley.edu/~bh/logo.html ) (multiplataforma) [GPLv2]
XLogo ( http://xlogo.tuxfamily.org/sp ) (en Java) [GPL]

FMSLogo ( http://www.fmslogo.org ) ( para Windows ) [GPL]

[Referencias]
Wikipedia
http://neoparaiso.com/logo/
http://et.bgcbellevue.org/logo/

Pasando el rato con /dev/dsp

/dev/dsp es el dispositivo que controla el audio en gnu/linux, esto permite hacer cosas bastante curiosas

(Si no encuentras el archivo dsp en la carpeta /dev, quiza este en dsp0, audio o audio0...)

Escribiendo cosas en este archivo conseguiremos que salgan como audio (lo mejor sera bajar el volumen del audio, ya vereis por que... ;)

Otra cosa... es posible que sea necesario cerrar las aplicaciones que esten utilizando el audio para que funcione todo bien, ademas esto es mejor lanzarlo en una consola de comandos (no con un "ejecutar programa") y despues pararlo con Control-C, sino es posible que siga hasta que se reinicie el pc.

Por ejemplo, haciendo  sudo cat /dev/mouse >> /dev/dsp , los altavoces produciran un sonido cada vez que el mouse se mueve.

Con sudo cat /dev/urandom >> /dev/dsp se producira un sonido aleatorio... decepcionados?, yo tambien, lo de que fuera aleatorio tenia buena pinta, pero al final es lo que se escucha cuando la radio no esta sintonizada

El resto es cuestion de imaginacion, hacer sudo cat /dev/hda >> /dev/dsp (o con sda en vez de hda si el disco es scsi)"reproducira" el disco duro, tambien se puede hacer con un archivo cualquiera, o con /dev/stdin (el teclado), /dev/mem (que es la memoria del pc)...

Tambien se puede hacer al reves, sudo cat /dev/dsp >> archivo.wav para guardar una grabacion (si el pc tiene microfono) en un archivo wav

Suerte y hasta otra

Diversion con los intrusos

Vuelta de navidades... hay gente que para pasar el tiempo libre se dedica a entrar en redes Wifi, veamos como sacar algo de diversion nosotros tambien :)}

Supongamos que la situacion es la siguiente: eres propietari@ de una red Wifi, red que ha sido vulnerada (maldito WEP >:(  ) y que el intruso utiliza para navegar por internet... asi que vamos a gastarle una pequeña broma

Nota: No soy abogado ni nada parecido, asi que no se si esto que se describe es totalmente legal aqui o en otro pais, las pruebas las he realizado en mi red privada, sin afectar a usuarios externos, si de verdad le vas a gastar una broma (que la cosa no pasa de eso) a alguien de tu red local, hazlo bajo tu responsabilidad.

Bien, pasemos a lo que hace falta:

- Un servidor web, para mostrarles la pagina web a los "visitantes", un Ubuntu con apache y php servira perfectamente

- La suite dsniff (concretamente la herramienta dnsspoof), en un entorno Ubuntu/Debian se puede instalar con sudo apt-get install dsniff

Lo primero es preparar la pagina que va a ver el "visitante", una o dos cosas apovechando la variable $_SERVER  haran la pagina mas interesante, esta es bastante simple, todo es cuestion de hecharle imaginacion:

El codigo que muestra informacion sobre el "visitante" es casi igual que el de la imagen que muestra ip, navegador...

Por ultimo redireccionar a los visitantes de otro servidor, el comando que se utiliza es el siguiente: sudo dnsspoof -i <interfaz> -f <archivo de hosts>

Siendo el interfaz el dispositivo utilizado para conectarse a la red (como eth0 ,en Gnu/Linux, *BSD,etc se puede averiguar con ifconfig )

Y el archivo de hosts uno como el de /usr/share/dsniff/dnsspoof.hosts, siguiendo el formato clasico hay un dominio en cada linea, lo primero es la IP a la que se asigna el dominio, que va despues de la IP separado por una tabulacion (las lineas que empiezan por # son comentarios).

Lo que se consigue con esto es (por decirlo de una forma) que cuando el navegador pregunte en que IP esta alguno de los dominios de la lista, el dnsspoof se adelante al servidor DNS (aprovechando que la red local suele ser mas rapida) y le diga la IP que aparece en el archivo de hosts

 Para que el dnsspoof funcione tiene que poder snifar las peticiones DNS, asi que dependiendo de la red quiza sea necesario poner en marcha un man-in-the-middle, para esto se utilizara otra herramienta de la suite dsniff, arpspoof, el comando es este: sudo arpspoof -i <interfaz> -t <ip de pasarela> <"visitante" >

Suerte y hasta otra