Hoy, andando por SeriesYonkis acabe mosqueado por tener que dar muchas vueltas para conseguir los links (a megaupload en este caso), la verdad es que la web es bastante eficiente, todo muy claro, pero una vez que encuentras lo que necesitas, hay que pasar por la pagina medio vacia que solo tiene el link para enviarte a donde hay esta la descarga :(

Conclusion: un script y andado...

El script en cuestion esta aqui: http://userscripts.org/scripts/source/ 76470.user.js

De todas formas, los de userscripts se lo curraron, asi que hay mas informacion del script (poca cosa, codigo fuente en bonito y tal...) aqui: http:// userscripts.org/scripts/show/76470

Por si a alguien le pica la curiosidad por saber como hacen los de SeriesYonkis para "ocultar" los links, el metodo es bastante sencillo:

• Obtienen el valor ASCII de cada letra que cambia (con megaupload, que es para donde funciona este script, es lo que va despues del ?d= )
• Le hacen XOR con 0xFE
• Y le hacen un UrlEncoding()

Para recuperar el link, solo hay que hacer unescape(), volver a hacer XOR con 0xFE y añadir lo que se obtiene al final del enlace :)

Hasta otra !

ps: La 4ª parte de Introduccion a la criptografia esta al caer

Hoy presento un código en la línea del BGame, es decir, algo completamente inútil, hecho solo para quitarse el mono de ensamblador en ring 0.

Simplemente muestra un reloj binario (puro o en BCD, según le venga en gana al RealTimeClock =S ), con: S: Segundos m: minuto H: Hora D: Día M: Mes Y: Año

Todo con colorines y tal (para los años cuenta los últimos 2 digitos, al mas puro estilo Y2K) :

Zip con el código, Makefile (usa nasm) y la imagen ensamblada [bclock.zip]

Y con esto y un bizcocho, hasta mañana a las 0o10

[Referencia] http://wiki.osdev.org/

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.

La primera prueba fue preparar un bot IRC, con los siguientes parámetros: - Puerto: 6667 (el asignado al protocolo) - Canal: "#irc_bots" - Nombre: "samp_bot"

De 43 antivirus, lo detectan 7. 5 de ellos lo identifican como bot IRC o backdoor IRC, uno más lo idetifica como "Troyano" y otro como "Backdoor", los resultados aquí Lanzarle un strip, cambiar_el_puerto_al_que_se_conecta, o cambiar su nombre no afecta a la detección, asi que nadie se fia de que ponga IRC por ahí o del puerto en cuestión, buena señal :) .

Siguiente, un proxy SOCKS4, los parámetros son: - Puerto: 1080 (también el predeterminado) - Usuario: * (Cualquiera)

Resultado, de 43 antivirus, 0 lo detectan [resultados]... cada quién que lo interprete como quiera.

De tercero, una shell inversa: ( popen FTW ) - Dirección: 127.0.0.1 - Puerto: 1024 - Prompt: >>> (¿?)

Y los números son... 0_de_42 (WTF ?!?), la verdad es que el código es bastante esqueletico, si paras todos los procesos que se conectan a algun host y hacen popen, mal asunto :(

Cuarto, un downloader (que solo usa sockets TCP, ninguna función especial), los parámetros: - Dirección: http://yoquese.com/malomalo.exe (no creo que exista, la verdad) - Archivo temporal: temp.exe - Marcar como oculto: 1 (Si) - User-Agent: "Mozilla/5.0 (Windows; Windows NT 5.1; es-ES) Gecko/20100115 Firefox/3.6"

0_de_28 .... no, en serio, parece que escapan 0.o . Y, ¿un PE de unos pocos Kb's con el User-Agent del firefox?

Quinto... perdón si se hace cansino, "Distribución por emule": - Nombre del archivo: test.exe - Ocultar: 1 (sep) - Evitar que aparezca en las búsquedas: 1 (tooodo) - Sobreescribir: 1 (por que no?)

Y... 0_de_43 (volvieron !), lo de siempre, todo lo que hace es crear un archivo, que me diga alguien como saber a priori si es algo peligroso, aunque eso de que acabe en .exe ....

Sexto, "Nuevo_usuario": - Usuario: joe - Password: password - Ocultar: 1 (si, todo lo que ayude a la detección) - Poner como admin: 1 (avante toda)

Para uno que trastea con el registro y hace llamadas a system, 0_de_43 sin comentarios...

Y por último, el que creo que puede tener más chicha, la "Instalación_Basica", supongo que trastear con los strings de registro típicos del malware es una papeleta para ganarse la detección. Los parametros comunes son: - Carpeta: C:\ - Intentar ADS: 1 (si) - Nombre del ADS: ads.exe - Nombre del archivo "raiz": test.txt - Ocultar: 1 (si) - Evitar que lo indexe: 1 (True) - Nombre del registro: CannedSoft 0.1

En fin, que solo cambia el método de ejecución. 0: CurrentVersion/Run ("un clásico, un Stairway to Heaven casi", que dirian los HDC) 0_de_43, mal comienzo.

1: CurrentVersion/RunServices (variante menos usada) 1_de_43, como Dropper, algo es algo...

2: Explorer\Run (al iniciar el explorer) 1_de_43, como Dropper también

3: CurrentVersion/RunOnce (hay que volver a añadirlo cada booteo) 0_de_43, era de esperar del RunOnce, es complicarse sin motivo

Eso es todo, esto no pretendio ser cientifico ni riguroso, ni nada por el estilo, pero creo que si se puede sacar algo en claro es que fiarse de el antivirus es bastante iluso. (Y sin usar cripters y cosas de esas) Un poco de sentido común, por favor.

ps: el monstruo es este [cannedsoft.zip] (GUI hecha con freepascal y Lazarus, y los módulos con C), el codigo que genera 'tmpSrc.c' ha de compilarse. (Un pequeño seguro que sirve para que los crios que buscan una forma de hacerse sus virus, por lo menos aprendan a compilar algo). Está probado con Gnu/Linux y Dev-Cpp.

ps2: El Makefile solo hace clean

Venga, a portarse bien y cuidado al programar algo (legítimo) que use el IRC.

Introducción_a_NetKit(II):creando_redes
Introducción_a_NetKit(_III):switches_y_enrutado
Introducción_a_NetKit(IV):_Un_puente_a_Internet

Al final si que habrá tuto de Netkit (lo estás leyendo ahora), más que nada orientado a esa gente que quiere trastear con las redes, y que no tiene espacio/tiempo/ganas de montar una fisica o con las máquinas virtuales habituales (tipo VirtualBox) y a aclarar algo mis propias ideas :P.

I: Instalación

Se crea un directorio para almacenar el programa, yo utilizaré "/usr/netkit/", pero se puede utilizar cualquiera. Una vez dentro del directorio se descargan ahí los últimos archivos (los 3) de aquí [http://wiki.netkit.org/index.php/Download_Official]

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

wget http://wiki.netkit.org/download/netkit/netkit-2.7.tar.bz2 sum=md5sum netkit-2.*|cut -d\ -f1 if [ "$sum" != "ab1e685730a4cce58c80cc46f85eb57f" ];then echo "Descarga fallida"; exit 1;fi

wget http://wiki.netkit.org/download/netkit-filesystem/netkit-filesystem-i386- F5.1.tar.bz2 sum=md5sum netkit-filesystem*|cut -d\ -f1 if [ "$sum" != "d140f80a684b092b352db93512cc14ef" ];then echo "Descarga fallida"; exit 1;fi

wget http://wiki.netkit.org/download/netkit-kernel/netkit-kernel-i386- K2.8.tar.bz2 sum=md5sum netkit-kernel*|cut -d\ -f1 if [ "$sum" != "1b4297abd1c29e6c4563be70f7480562" ];then echo "Descarga fallida"; exit 1;fi

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

Después lógicamente, hay que descomprimirlo, si se hace con "tar", hay que acordarse de usar el flag "S", ya que hay archivos sparse, la descompresión entonces se haría con:

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

tar -xjSf

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

• x: Para indicar el desempaquetado
• j: Para indicar que además esta comprimido con bz2
• S: Porque contiene ficheros sparse
• f: Para indicar que archivo se va a usar

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

tar -xjSf netkit-2.tar.bz2 tar -xjSf netkit-filesystem.tar.bz2 tar -xjSf netkit-kernel*.tar.bz2

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

Después se pueden borrar los paquetes comprimidos (aunque no es necesario, a gusto de cada quién)

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

rm -f netkit-2tar.bz2 rm -f netkit-filesystemtar.bz2 rm -f netkit-kernel*tar.bz2

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

A estas alturas, el directorio sería algo como "/usr/netkit", y de ahi colgaría el que acabamos de desempaquetar "netkit", por comodidad se puede mover (y en este ejemplo se hará, en el caso contrario el directorio quedaría como "/directorio/antiguo / netkit" )

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

mv netkit/* .

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

Ok, ya casi está, solo queda preparar un par de variables de entorno y listo.

La primera es NETKIT_HOME, que indica a NetKit "donde está", que en este caso sería /usr/netkit, donde se encuentran "bin", "fs", "kernel", "man", "netkit.conf", "netkit-version"... Para añadirlas todas al shell actual (el resto cuelgan de NETKIT_HOME ), se puede hacer con

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

export NETKIT_HOME="/usr/netkit" # Directorio "raiz" de netkit export PATH="$PATH:$NETKIT_HOME/bin" # Directorio de binarios de netkit export MANPATH="$MANPATH:$NETKIT_HOME/man" # Manuales de netkit

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

Esas mismas líneas se puede añadir al archivo ~/.bashrc, para que se ejecute al iniciar la shell, .bashrc es un conjunto de ordenes que la consola ejecuta antes de esperar las órdenes del usuario (por si no lo sabes, el ~ se interpreta como la dirección al $HOME de tu usuario). También se puede añadir a /etc/profile para que se ejecute cada vez que se inicia el sistema.

Nota: NetKit provee un script para comprobar la configuración, solo hay que ejecutarlo con ./check_configuration.sh en su directorio

Ahora NetKit ya se puede usar sin problema, si quieres probarlo, haz vstart Para cerrarla puedes hacer halt en la máquina virtual o vhalt donde la lanzaste. Y recuerda borrar el archivo .disk cuando no la vayas a usar más  ;)

Para la próxima, como hacer laboratorios completos con conexiones hacia dentro y hacia fuera (internet). [Referencias] http://netkit.org http://wiki.netkit.org/download/netkit/INSTALL http://danteslab.blogspot.com/2008/09/creacin-de-laboratorios-virtuales- con.html Introducción_a_NetKit_(IV):_Un_puente_a_Internet

Comenzando por el principio... NetKit, conocido como "El sistema del hombre pobre para experimentar con redes de ordenadores" es un proyecto que pretende usar UML (User Mode Linux, un kernel que como su nombre indica, corre en espacio de usuario, en ring 3) para simular redes de ordenadores completos pero ligeros (normalmente Gnu/Linux Debian en modo texto).

A día de hoy, NetKit es completamente usable, muy útil para aprender sobre redes y mucho más accesible que montar una red física, con los inconvenientes que tendría tener que andar moviendose entre los distintos host, cablear todo y demás.

No explicaré ahora como montar redes con NetKit (intentaré hacerlo más adelante), lo que si haré es presentar un script que genera laboratorios listos para utilizar, la idea es que genere un entorno para jugar un CTF, pero aún le queda mucho camino ( añadir vulnerabilidades a los hosts, redes más aleatorias... ).

Los laboratorios de NetKit son conjuntos de máquinas que están pensadas para interactuar entre ellas, por ejemplo entre los laboratorios_oficiales hay algunos que sirven para aprender desde formas de enrutado hasta como funciona ARP.

El script se puede descargar de aquí [http://pastebin.com/gMu3qkHJ], y lo único que hay que hacer es ponerlo en un directorio vacío, los parámetros son:

./script -

Para seleccionar los parámetros del laboratorio por menús

./script

Para que genere el laboratorio por defecto (10 máquinas, 2 switches, 20 Megas de Ram por máquina)

./script cl

Para que borre el laboratorio actual (necesario entre un laboratorio y otro)

Una vez que el laboratorio esté listo, solo hay que lanzar el comando "lstart" del directorio de binarios de NetKit  y se pondrá en marcha.

Si el proceso se realiza con privilegios de root, se creará una interfaz en el host físico que comunica con el núcleo de la red virtual, para poder acceder directamente a la red a través de este tunnel se puede hacer:

sudo route add -net 10.0.0.0 netmask 255.0.0.0 gw 192.168.254.2

Y eso es todo, este sería el resultado, con las máquinas de fondo y un terminal mandando un ping desde el host físico hacia dentro de la red:

[Referencias] Instalación_de_NetKit_y_NetGui http://netkit.org/ http://wiki.netkit.org/index.php/FAQ http://wiki.netkit.org/index.php/Labs_Official [Laboratorios oficiales]

Update: corregido un detalle que podría causar un error al dividir por 0

La idea (no me acuerdo de donde salio, la verdad) es diseñar un fractal y "mostrarlo" a través de un archivo de música. El fractal elegido es una conjunto_de_Cantor por que es simple, y porque se puede presentar en un formato de 1 dimensión, de tiempo en este caso y otra que aquí será la frecuencia. Este script genera un archivo wave (.wav) basandose en esa idea.

El código está aquí: http://pastebin.com/YdURGkqa http://pastebin.com/ Ecx1uR7f

Nota: como suele pasar con estas cosas, la primera vez mejor bajar el volumen... yo aviso ;)

La verdad, no se me ocurre nada que explicar =P el sonido que se obtiene es "mono" de 8 bits, y la sintaxis es:

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

./fracAudio.py [-d ] [-s ] [-b ] [-fs ] [-p ] [-l ] | -h Archivo de salida: archivo donde se guardará el audio Duración: duración en segundos del archivo de audio Paso: segundos mínimos que durará cada parte del fractal Frecuencia base: la frecuencia de la que se partirá Paso de frecuencia: lo que cambiará la frecuencia en cada paso (-*** para que descienda) Proporción: proporción del fractal (siempre ha de ser menor que 0.5) Nivel del fractal: Nivel máximo de recursividad que se aplicará al fractal -h: muestra esto

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

Y el resultado podría ser este, por ejemplo, con:

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

./fracAudio.py out.wav -d 60 -s 0.25

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

[Referencias] http://es.wikipedia.org/wiki/Conjunto_de_Cantor http://docs.python.org/library/wave.html http://docs.python.org/library/audioop.html

Actualización: por algun extraño motivo se vuelve paranoico con los paquetes cuando se suspende el ordenador y se vuelve a iniciar (¿?), estoy trabajando para resolver eso.

Hoy traigo la segunda versión del SniperlCat [SniperlCat_0.2], los cambios no son muchos, pero creo que pueden resultar interesantes:

• Detecta los paquetes SYN de sockets raw (típicos de un SYN scan), aunque para esto necesita permisos de root para levantar un sniffer, básicamente se aprovecha esta [http://danielmiessler.com/study/synpackets/] idea, aunque con scanners modernos se puede hacer que no exista diferencia, unicamente avisa de paquetes con un tamaño menor de 60 bytes (suelen ser de 58) y sin el flag DF de IP activado.

• Permite llevar un log aparte de las notificaciones... no es gran cosa pero puede ser útil.

• Las alertas se reunieron en una función llamada "show_alert" para poder modificar el sistema más facilmente.

Las dependencias quedarían en "libgtk2-notify-perl" para las notificaciones, y "libnet-pcap-perl" y "libnetpacket-perl" para buscar paquetes sospechosos.

Y la sintaxis del comando sería:

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

Sniperlcat 0.2

sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n ] [-f ] [-p|- np] [-dv ][-l ][-s ] -h  (--help): Muestra este mensaje -d  (--daemonize): Se ejecuta de fondo -nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla -c  (--cansino): Repite los avisos, aún los ya emitidos, en cada iteración -v  (--verbose): Muestra más información por pantalla -n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24 -dv (--device): Especifica la interfaz de red que se monitoreará -p  (--privileged): Se asumirán que es un usuario con privilegios -np (--no-privileged): Se asumirán que es un usuario sin privilegios -l  (--log): Se guardarán los avisos en un archivo -s  (--sleep): Especifica el tiempo en segundos de "descanso" entre iteraciones (por defecto 60)

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

Eso es todo, otro día... más.

[Referencias] http://seclists.org/pen-test/2007/Oct/44 http://www.perlmonks.org/index.pl?node_id=170648 http://search.cpan.org/~saper/Net-Pcap-0.16/Pcap.pm

No es gran cosa, pero aquí teneis una versión de los números_de_Fibonaccique no se demora mucho para obtener números grandes, por ejemplo, para el número de Fibonacci 10000, tarda 0.1 segundos

(Eliminé los números que hay por el medio para que no quede una imágen excesivamente grande)

El código es simplemente: global fibo

fibo={} # El diccionario, este es el quid de la question

def fibonacci(i):

global fibo

if (i in fibo): # Si esta en el diccionario

   return fibo[i] # No hay que buscarlo

else:

   if (i < 2): # Si es trivial, no hay que memorizarlo

       return 1

   else: # Sino, se busca

       res = fibonacci(i - 1)+ fibonacci(i - 2)

       fibo[i] = res # Se mete en el diccionario

       return res # Y se devuelve

El truco está en el diccionario, que evita que haya que recorrer todos los números muchas veces, a costa, claro, de un gasto de memoria.

Hay una cosa a tener en cuenta, llamar directamente a la función (sin haber llamado a otra, que construyese el diccionario antes) con un número mayor o igual a 1000, producirá una excepción:

=============================================================================== RuntimeError: maximum recursion depth exceeded ===============================================================================

Para evitar eso, se puede construir el diccionario paso a paso (que se hace con apenas pérdida de rendimiento)

import sys

limit = 1000

if (len(sys.argv) > 1):

limit = int(sys.argv[1])

for i in xrange(1, limit):

fibonacci(i)

print fibonacci(limit) # Para demostrarlo :)

O completo

!/usr/bin/env python

global fibo

fibo={} # El diccionario, este es el quid de la question

def fibonacci(i):

global fibo

if (i in fibo): # Si esta en el diccionario

   return fibo[i] # No hay que buscarlo

else:

   if (i < 2): # Si es trivial, no hay que memorizarlo

       return 1

   else: # Sino, se busca

       res = fibonacci(i - 1)+ fibonacci(i - 2)

       fibo[i] = res # Se mete en el diccionario

       return res # Y se devuelve

import sys

limit = 1000

if (len(sys.argv) > 1):

limit = int(sys.argv[1])

for i in xrange(1, limit):

fibonacci(i)

print fibonacci(limit) # Para demostrarlo :)

Este método permite buscar incluso el número_100000sin jubilarse por el camino, en poco más de 2 segundos =P

Hasta otra.

Gracias a Mungu ayer descubrí que bash puede abrir conexiones tcp/ip directamente, sin depender de netcat ni telnet, así que ahí va una pequeña prueba/experimento...

Dice "OK" y sale con 0 si el link a megaupload es correcto, o dice "Invalid link" y sale con 1 si es incorrecto.

Actualizado: ahora funciona también con links sin "www"

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

!/usr/bin/env bash

if [ "$1" = "" ]; then     echo "No has especificado una dirección"     exit 1 else     path="/?"echo $1|cut -d? -f2 fi

Request webpage

exec 3<>/dev/tcp/www.megaupload.com/80 echo -en "GET $path HTTP/1.1\r\n" >&3 echo -en "HOST: www.megaupload.com\r\n" >&3 echo -en "Connection: close\r\n\r\n" >&3 cat <&3|grep "Invalid link" >> /dev/null

result=$? if [ $result -ne 0 ];then     echo "OK"     result=0 else     echo "Invalid link"     result=1 fi exit $result ===============================================================================

[Referencias] Bash_socket_programming_with_/dev/tcp

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

ó fd

Para retroceder:
back

ó bk

Para girar a la derecha: right

ó rt

Para girar a la izquierda:
left

ó lt

Para volver a la posicion inicial: home

Para limpiar la pantalla: clean

Para repetir instrucciones: repeat '[' ']'

Para definir una nueva funcion: to [:] ... [:]

[instruccion] ... [instruccion] END

Finalizar una funcion antes de tiempo stop

Ocultar la tortuga: hideturtle

ó ht

Mostrar la tortuga: showturtle

ó st

Condiciones:
if '[' ']'

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

Por ejemplo, con cuadrado 200

dibuja un cuadrado con 200 pasos de lado

Ahora vamos a añadir algo mas, como haríamos 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 así (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, habría 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 iba, 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 sería 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!

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/