Otra de scripts greasemonkey [SY relinker]
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
BClock, un reloj binario en 510 bytes (autobootable)
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/
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.
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 (I): instalación
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 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
Generador de redes netkit
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]
Sonido fractal (experimento)
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
===============================================================================
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
SniperlCat 0.2, detección de SYN scan's
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
===============================================================================
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
Fibonacci rápido en python
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.
Comprobar links de megaupload desde bash
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
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
ó
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/