Saltar ó contido principal

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:

[http://3.bp.blogspot.com/_26RJWnubh-w/S0ygn7TFAuI/AAAAAAAAAAM/jWBYG6Y54nE/ s640/Captura-de-pantalla.png]

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 -f 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 -t <"visitante" >

Suerte y hasta otra

Pitufeando con Scapy y python

Empezando por el principio, HackXCrack acaba de liberar otra_tanda_de tutoriales entre los que se encuentra uno_sobre_Scapy escrito por Larry sobre la manipulación de paquetes (muy recomendable, por cierto).

Resulta que Scapy es una librería para python (aunque puede usarse aparte de forma interactiva ) que permite trastear con los paquetes creandolos, snifandolos, decodificandolos, una burrada de cosas (al parecer hasta puede usarse para decodificada VOIP sobre un canal WEP cifrado), por último decir que funciona sin gran dificultad sobre cualquier OS mayoritario.

Lo que venía a presentar hoy es un script de prueba que lanza ataques_smurf usando Scapy, se puede encontrar aquí [smurf.py]

Los parámetros que hay que pasarle por línea de comandos son:

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

smurf.py -s -d [-t ] [- p ] [-b ] [-r ] o

smurf.py -h : muestra esto

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

Obviamente se necesitan permisos de root/admin para poder ejecutarlo ya que permite spoofear la IP de origen (algo requerido para el ataque).

Y eso es todo.

Manifiesto por una Red neutral

Los ciudadanos y las empresas usuarias de Internet adheridas a este texto manifestamos:
1.  Que Internet es una Red Neutral por diseño, desde su creación hasta
su actual implementación, en la que la información fluye de manera
libre, sin discriminación alguna en función de origen, destino,
protocolo o contenido.
2.  Que las empresas, emprendedores y usuarios de Internet han podido
crear servicios y productos en esa Red Neutral sin necesidad de
autorizaciones ni acuerdos previos, dando lugar a una barrera de entrada
prácticamente inexistente que ha permitido la explosión creativa, de
innovación y de servicios que define el estado de la red actual.
3.  Que todos los usuarios, emprendedores y empresas de Internet han
podido definir y ofrecer sus servicios en condiciones de igualdad
llevando el concepto de la libre competencia hasta extremos nunca antes
conocidos.
4.  Que Internet es el vehículo de libre expresión, libre información
y desarrollo social más importante con el que cuentan ciudadanos y
empresas. Su naturaleza no debe ser puesta en riesgo bajo ningún
concepto.
5.  Que para posibilitar esa Red Neutral las operadoras deben transportar
paquetes de datos de manera neutral sin erigirse en "aduaneros" del
tráfico y sin favorecer o perjudicar a unos contenidos por encima de
otros.
6.  Que la gestión del tráfico en situaciones puntuales y excepcionales
de saturación de las redes debe acometerse de forma transparente, de
acuerdo a criterios homogéneos de interés público y no
discriminatorios ni comerciales.
7.  Que dicha restricción excepcional del tráfico por parte de las
operadoras no puede convertirse en una alternativa sostenida a la
inversión en redes.
8.  Que dicha Red Neutral se ve amenazada por operadoras interesadas en
llegar a acuerdos comerciales por los que se privilegie o degrade el
contenido según su relación comercial con la operadora.
9.  Que algunos operadores del mercado quieren “redefinir” la
Red Neutral para manejarla de acuerdo con sus intereses, y esa
pretensión debe ser evitada; la definición de las reglas fundamentales
del funcionamiento de Internet debe basarse en el interés de quienes la
usan, no de quienes la proveen.
10.  Que la respuesta ante esta amenaza para la red no puede ser la
inacción: no hacer nada equivale a permitir que intereses privados
puedan de facto llevar a cabo prácticas que afectan a las libertades
fundamentales de los ciudadanos y la capacidad de las empresas para
competir en igualdad de condiciones.
11.  Que es preciso y urgente instar al Gobierno a proteger de manera
clara e inequívoca la Red Neutral, con el fin de proteger el valor de
Internet de cara al desarrollo de una economía más productiva, moderna,
eficiente y libre de injerencias e intromisiones indebidas. Para ello es
preciso que cualquier moción que se apruebe vincule de manera
indisoluble la definición de Red Neutral en el contenido de la futura
ley que se promueve, y no condicione su aplicación a cuestiones que poco
tienen que ver con ésta.
23.

La Red Neutral es un concepto claro y definido en el ámbito académico, donde no suscita debate: los ciudadanos y las empresas tienen derecho a que el tráfico de datos recibido o generado no sea manipulado, tergiversado, impedido, desviado, priorizado o retrasado en función del tipo de contenido, del protocolo o aplicación utilizado, del origen o destino de la comunicación ni de cualquier otra consideración ajena a la de su propia voluntad. Ese tráfico se tratará como una comunicación privada y exclusivamente bajo mandato judicial podrá ser espiado, trazado, archivado o analizado en su contenido, como correspondencia privada que es en realidad.

Europa, y España en particular, se encuentran en medio de una crisis económica tan importante que obligará al cambio radical de su modelo productivo, y a un mejor aprovechamiento de la creatividad de sus ciudadanos. La Red Neutral es crucial a la hora de preservar un ecosistema que favorezca la competencia e innovación para la creación de los innumerables productos y servicios que quedan por inventar y descubrir. La capacidad de trabajar en red, de manera colaborativa, y en mercados conectados, afectará a todos los sectores y todas las empresas de nuestro país, lo que convierte a Internet en un factor clave actual y futuro en nuestro desarrollo económico y social, determinando en gran medida el nivel de competitividad del país. De ahí nuestra profunda preocupación por la preservación de la Red Neutral. Por eso instamos con urgencia al Gobierno español a ser proactivo en el contexto europeo y a legislar de manera clara e inequívoca en ese sentido.

Un bot para probarlos a todos (trampeando en RTB)

Andaba yo con la idea de hacer un tuto sobre Real_Time_Battle, un juego de programación muy original en el que uno ha de programar un tanque que se maneja usando la entrada y salida estándar, permitiendo usar casi cualquier lenguaje. Escarmentado por lo que pasó con la Introducción_a_la_criptografía, que lleva 5 meses esperando el penúltimo post (que vaya si se dice rapido) y el de NetKit (en cuanto pueda lo acabo, en serio), quería tener todo preparado antes de empezar, mientras tanto presento un bot que a mí me sirve para hacer las pruebas y puede que a alguien le resulte útil.

El bot tiene dos partes, la que funciona con RTB (el "servidor"), no hace gran cosa, simplemente lee el archivo "/tmp/controller" y hace que el tanque lo haga, la segunda parte es con la que se comunica el usuario (el "cliente"), que le permite controlar al robot... sí, trampa gordísima, va en contra del objetivo propio del juego, pero sirve para probar el comportamiento de otros robots sin tener que escribir uno que los active.

El código la versión sin sockets solo funciona en sistemas *nix, ya que utiliza fifos para la comunicación entre las dos partes (espero añadir en breve una version modificada que use sockets, con cambios mínimos en el código) ya programada.

Por cierto, el servidor utiliza el API que se puede encontrar aquí [ http:// rtb.belay.es/?page_id=16 ],aunque esta incluido en el zip (está bajo la GPL)

[servidor.zip] [cliente.py]

Añade el servidor.robot y el Robot_api.py a la carpeta de robots, y ejecutar el cliente antes (es el que crea el fifo). Para manejar el cliente solo hay que mantener el foco en el terminal en donde se ejecutó, el robot se controla con WASD (no me preguntes cuál es para que ¬¬)  y espacio ' ' para disparar, para salir del cliente, X.

Esta es la versión con sockets (50505y solo disponible desde localhost), el API del servidor es el mismo del zip.

[socket_server.robot][socket_client.py]

Al final el socket_cliente.py era el que espera por las conexiones... de lo contrario, activar el cliente para conectarse cuando se crea el bot podría provocar aún más problemas con RTB =P

Perdón por la carencia de comentarios... cosas de las prisas.

Eso es todo, saludos

La guía del "grey hat" de la EFF [traduccion]

Encontre un_documento_de_la_EFF hasta el que llegue a través de el de "derechos_del_programador" (muy recomendable, por cierto) que puede resultar interesante para quién sin querer se pudo meter en problemas o simplemente tiene dudas sobre como avisar sobre vulnerabilidades y supuse que a alguien le puede parecer interesante, así que aquí va la traducción. Por cierto, esto gira en torno a las leyes en los EEUU, pero al fin y al cabo hoy en día en este mundillo son las que se acaban imponiendo, sin más...
Un/a investigador/a de seguridad informática que ha violado la ley
durante su investigación se enfrenta a un dilema al pensar si debe
notificar a la compañía del problema que descubrió en uno de los
productos de esa compañía. Al reportar el fallo de seguridad, el/la
investigador/a revela que puede haberr cometido una actividad ilegal,
lo que puede invitar a la denuncia o investigación criminal. Por
otro lado, ocultar la informacion significa que un fallo de seguridad
potencial puede que no se arregle.

No hay respuestas fáciles para el/la hacker ético que se alejo  
demasiado hacia el arbusto legal (legal thicket) de las leyes de  
delitos informaticos. Entre las opciones poco deseables, el/la hacker  
ético puede escojer reconstruir su investigación usando software,  
dispositivos y redes a las que tiene acceso autorizado y avisar una  
vez teniendo las manos lavadas con la reconstrucción del  
descubrimiento. Además puede escojer avisar del fallo en términos  
generales que identifican el problema, sin revelar el camino  
comprometido de la investigación que usó para descubrirlo. Ninguna  
opción protege perfectamente al/a la investigador a la vez que  
asegura que el problema se arreglará. Sin embargo uno u otro pueden  
ser mejores que malas elecciones.

A pesar del valor que los/las profesionales de seguridad informática  
proveen probando software y redes en busca de vulnerabilidades, las  
actividades de investigación pueden violar cierto número de  
complicadas u obscuras regulaciones y estatutos. Esas leyes incluyen:

* Computer Fraud and Abuse Act  
* Anti-Circumvention Provisions of the DMCA  
* Copyright law  
* Otras leyes estatales e internacionales

El Acta de fraudes y abuso de computadores (Computer Fraud and Abuse  
Act) prohibe el acceso sin autorización a ordenadores. Los/las  
investigadores/as que realizan pruebas en sistemas que no les  
pertenecen están reñidos con esta ley. Por otra parte, la ley se ha  
utilizado mal al perseguir el uso de servicios de ordenadores con la  
violación de los términos de servicio1 e incluso el acto del aviso  
de vulnerabilidades en si.2

Las previsiones contra la circumvención del Digital Millennium  
Copyright Act crean un potencial obstáctulo legal para un/  
a investigador que estudie los mecanismos que controlan la forma en  
el que se puede acceder a software o otros materiales con copyright o  
usarlos, o software protegido con eso mecanismo. Litigantes  
potenciales han invocado las previsiones contra la circunvención no  
solo donde concierne a los tradicionales “digital rights  
management” (DRM), si no tambien en casos que involucran la  
ingeniería inversa de un protocolo sin documentar.

La ley de copyright de los U.S. regula las copias hechas durante la  
ingeniería inversa. Algunos estados y otros países tienen sus  
propias leyes de crimen con ordenadores, y los/las investigadores/as  
dificilmente pueden esperar conocerlas todas. Por ejemplo, los  
Estados Unidos persiguieron a Dmitry Sklyarov y a la compañía rusa  
Elcomsoft bajo el DMCA por crear un lector para los eBooks de Adobe.  
El producto no viola ninguna ley rusa.

Como el régimen regulatorio es complicado y no-intuitivo, los/las  
investigadores/as de seguridad pueden tener más razones para  
preocuparse por retos legales que otros cientificos/as.  
Potencialmente, un/a investigador/a puede violar desintencionadamente  
la ley a través de la ignorancia o el entusiasmo mal enfocado, o una  
parte afectada puede estirar o malusar la ley para desafiar a la  
investigación que presentan sus productos o servicios bajo un  
enfoque negativo.

Por eso recomendamos que los/as investigadores/as de seguridad  
consulten a un avogado antes de una investigación potencialmente  
arriesgada. Un buen avogado puede ayudarle a evitar las trampas  
legales comunes y si identifica los riesgos legales por adelantado,  
puede que sea capaz de ajustar su plan de investigación para mitigar  
o evitar completamente los problemas.

El/la investigador/a se encuentra en un dilema cuando ha roto  
potencialmente la ley, pero nunca pensado robar información o  
invadir la privacidad y quiere ver el problema arreglado. Reportar la  
información levanta sospechas que pueden resultar en una  
investigación y demandas civiles o incluso cargos criminales.  
Mantenerse callado significa que el error quedará sin arreglar y  
será potencialmente explotado por alguien con intenciones  
criminales. ¿Que debe hacer el hacker de sobrero gris?

Algunas compañías han aclarado que generalmente no toman acciones  
legales si una persona no maliciosa les llama la atención sobre  
vulnerabilidades, sin tener en cuenta como se encontro el fallo.  
Compañías que tratan frecuentemenete con vulenerabilidades suelen  
ser las más abiertas y se toman mejor los tropiezos de los/as  
investigadores/as. Ya lo han visto antes, quieren mejorar sus  
productos, y no quieren la mala prensa que viene al demandar a  
hackers con buenas intenciones. Compañías que ganan su dinero de  
otras formas que no son la distribución de software suelen ser  
nuevos en el juego del aviso de vulnerabilidades. Son estas  
compañías las que entran en pánico con más facilidad,  
sobrereaccionar y sacar al avogado cuando se entfrentan con  
información sobre vulnerabilidades en el producto. Para el/la  
investigador/a, esto suele significar suponer sobre la reacción de  
la parte a la que va dirigida el aviso.

Para moderar el riesgo legal, los/as investigadores/as pueden  
considerar el usar un intermediario que se ponga en medio. En casos  
anteriores, un/a investigador/a le dió la información sobre la  
vulnerabilidad a un avogado o periodista y le pidió que le diese la  
información al vendedor. Otros/as investigadores/as que han  
considerado dar una charla en una conferencia de seguridad y pedir al  
comité de selección una aproximación al vendedor, o incluso vender  
la información de la vulnerabilidad a una compañía agente  
(brokering company) que desvelará la vulnerabilidad al vendedor, y  
entonces a sus clientes, y finalmente al público. Sin embargo,  
ninguna de estas posibilidades es una solución perfecta. Cada  
aproximación presenta el riesgo de que un vendedor enfadado intente  
descubrir la identidad del/la investigador/a a través del  
intermediario. Ni la conferencia, ni los agentes de vulnerabilidades  
tienen ningún privilegio legal para negarse a desvelar la identidad  
del/la investigador si un tribunal cree que es requerido para un  
proceso legal. Los/as periodistas no tienen ese privilegio bajo  
precedente en la Corte Suprema de los Estados Unidos aunque pueden  
tenerlas bajo las reglas de algunas cortes bajas o la lay estatal.  
Los avogados tienen el derecho más fuerte a negarse a proveer  
identificación de información bajo el privilegio avogado-cliente,  
pero no está claro si la identidad del cliente es información  
protegida para todos los propósitos.

El/la investigador/a puede considerar recurrir al cifrado para  
ocultar su identidad al avisar de detalles importantes a las partes  
afectadas. El anonimato puede exacerbar algunos de los problemas  
comunes para los/as que avisan de vulnerabilidades, como ser tomados/  
as en serio, pero el problema particular para el hacker de sombrero  
gris es dar demasiada información sobre la investigación sin  
señalar ningun rastro de evidencias que de información suficiente  
que revele el delito y la identidad real del/la investigador/a. Por  
esto los/as investigadores/as quizá quieran recrear el  
descubrimiento del fallo usando solo software, dispositivos y redes  
que le pertenezcan o que tenga permiso para usar, y reportar el  
"descubrimiento". Alternativamente, el/la investigador/a puede tener  
que dejarse detalles que podrían en efecto servir como un rastro de  
migas de pan que llevan a su puerta, y esperar que la información es  
suficiente para notificar, informar y asistir a las partes afectadas  
a arreglar el problema.

Cualquiera que sea el curso que tome el/la investigador/a, se expone  
en el interes de mejorar la seguridad para el público. Una solución  
más completa sería hacer más claras y más limitadas las leyes de  
crimen por ordenador. El objetivo es dejar margen para la  
investigación de seguridad legítima y darle a los/as investigadores  
que ayudan a proteger nuestra propiedad y privacidad digital unas  
guías claras para sus actividades científicas y innovadoras. Esto  
es mucho mejor permitir que la investigación de seguridad florezca  
en una atmósfera de regulación ligera, que intentar castigar  
ataques criminales después de que ocurran con leyes draconianas y  
confusas. Mientrastanto, sin embargo, las mejoras de seguridad  
dependerán a veces en la disposición de los/as investigadores/as a  
aceptar el riesgo a ser demandados/as.

Fuente: https://www.eff.org/issues/coders/grey-hat-guide

La traducción, como el documento original está bajo licencia CC-by_3.0, siendo el autor original la Electronic_Frontier_Foundation.

Pywc 0.4

Hoy estrenamos nueva versión de Pywc:

* Corregido un bug que incluía lo que sigue a "?" y "#" como parte de una
URL relativa, vamos que con una URL como "blablabla.com/
yoquese.php?asd=jejeje/123" , la ruta base antes quedaría en
"blablabla.com/yoquese.php?asd=jejeje/" y ahora en "blablabla.com/" (como
tiene que ser).

* Además se añadió un método para descargar datos que no se tienen que
parsear (para imágenes o archivos binarios, por ejemplo).
*

El código es este: pywc04.zip

Entonces la referencia quedaría así:

crawler( proxies ) Crea un objeto crawler, si se especifica una lista de proxies como_se_hace_con urllib .

crawler.download( url, archivo de salida, tamaño del buffer ) Descarga una url en el archivo de salida, opcionalmente se puede especificar el tamaño del buffer (por defecto 4096 bytes).

website crawler.crawlsite( url, guardar raw ) Parsea una url y devuelve un archivo de tipo website, si opcionalmente se le añade guardar raw como true guarda el archivo original en el atributo website.raw .

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

website( contenido, url ) Crea un objeto website con contenido como fuente y una dirección url (esta se usa para los atributos de los enlaces), crawler.crawlsite devuelve un objeto de este tipo ya inicializado.

string website.title Título de la página web.

web_element[] website.element_list Lista de etiquetas y texto de la página web, objetos web_element .

web_element website.getElementById( id ) Devuelve un soloobjeto web_element con el id especificado .

web_element[] website.getElementsByName( nombre ) Devuelve una lista de objetos web_elementcon el atributo name especificado .

web_element[] website.getElementsByTagName( tag ) Devuelve una lista de objetos web_elementque corresponden con el tag especificado (como "a" para los enlaces) .

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

web_element( contenido, guardar raw ) Crea un objeto web_element a partir del contenido, si se especifica guardar_raw (opcional) como true guarda el contenido en web_element.raw .

boolean web_element.tag True si el elemento es una etiqueta o False si es texto .

string web_element.tag_type Tipo de tag del objeto .

boolean  web_element.closed Si la etiqueta esta contenida en si misma (como un img o un input )

boolean web_element.closing Si es una etiqueta de cerrado .

{} web_element.property Atributos de la etiqueta, por ejemplo {"href":"http://example.org", "id":"ejemplo"} .

Si es solo texto, este se especifica en el atributo web_element.text .

Si es una etiqueta de enlace ( "a" ) y se obtiene a partir de un objeto website , además tiene estos atributos .

string web_element.range "Rango" del enlace local para local, foreign para externos, javascript para triggers y invalid si no es un enlace válido.

string web_element.absolute Dirección absoluta a la que apunta el enlace.

A ver si para la próxima versión consigo un soporte HTML DOM completo...

Más animaciones

Hoy solo colorinchos y código de Structure Synth. Vídeo en: http://videobin.org/+2ks/2vh.html

Este tardó 3 horas y media en ser trazado, lo que le hace a uno cuestionarse si será válido para cosas grandes (el video muestra el bucle dos veces)

Ah, sí, antes de nada decir que al parecer se puede establecer que al alacanzar el límite de recursividad de una regla se aplique otra con:

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

rule maxdepth >

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

El código javascript es bastante genérico:

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

javascript

// Basado en la referencia // http://blog.hvidtfeldts.net/index.php/2010/11/scripting-in-structure-synth/

function pad(number) { number = number.toString(); while (number.length < 4) { number = "0" + number; } return number; }

Builder.load("otrotoro.es"); max = 180; for (i = 0; i < max; i++) { Builder.reset(); Builder.setSize(0,0); Builder.define("color", (i * 2).toString()); Builder.build(); Builder.raytraceToFile("Image" + pad(i) + ".png",true); }

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

Y la figura es más simple aún, otrotoro.es :

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

{ y -8.5 z -70 hue color  rx 40}torus rule torus{ 90 * { ry 4 x 1 hue 4 } 72 * { rx 5 rz 5 y 1 } basefig }

rule basefig{ { s 1 1 0.1  }  box }

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

Ale, con root

Introducción a Structure Synth (y van 4), animaciones con la nueva versión

Pues sí, se supone que la serie se quedaría en el 2, pero resulta que acaban de_lanzar_la_versión_1.5_de_Structure_Synth, que añade:

* Un raytracer integrado, ya no hay que usar programas externos como
Sunflow

* Scripting con Javascript para hacer animaciones (a estas alturas más de
uno, entre los que me incluyo, ya debe estar salivando =D )

* Exportación de archivos OBJ (confieso que esto aún no se que es)

* Cambios varios... en la GUI, se añadio un generador de números
aleatorios para el preprocesador, etc
*

Y uno no se puede quedar sin hablar de ella =P La nueva versión se puede descargar aquí: http:// structuresynth.sourceforge.net/download.php

Empezamos...

Raytracer

No tiene sentido explicar como utilizar el raytracer por lo sencillo que es, en el menú desplegable de render se puede elegir entre Raytrace (final) y Raytrace (in window), el último sirve para hacer una previsualización y tiene un botón más a mano al lado del de "Reset View". Sea como fuere, los resultados son bastante buenos para el tiempo que tarda.

La imágen que genera el código de ejemplo

Javascript

Desde que descubrí_que_se_añadiría_un_lenguaje_de_scripting (Javascript) tuve ganas de probar la nueva versión, siempre es fuente de inspiración meter un lenguaje turing completo en cualquier programa (que se lo digan a los de PDF xD ), y evita tener que ensamblar todo frame a frame, que aunque se pueda automatizar, para resoluciones considerables es impracticable.

La verdad sea dicha, las animaciones aún se hacen ensamblando frame a frame (juntar todo queda de tu mano), pero dado que el raytracer interno es relativamente rapido puede llegar a ser usable (dejarlo funcionando mientras vas a tomar algo hace que sea más soportable ;)  )

Pero me estoy yendo por las ramas, al parecer el programa utiliza QT’s QScriptEngine como motor, así que tienes a tu disposición todo el poder de javascript, y obviamente se añadió una clase que permite interactuar con el programa, Builder.

Nota: El código javascript debe estar en un archivo separado y debe comenzar por #javascript  sin nada antes (similar a como hace *nix con #! ).

Métodos que proporciona Builder (copy-traduce-paste de la_referencia):

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

Builder.load(string fileName) Carga un archivo EisenScript en el buffer.

Builder.define(string input, string value) Realiza substutuciones de texto en el buffer (¡pero ignora las líneas de preprocesador!) .

Builder.prepend(string prescript); Añade 'prescript' al principio del buffer.

Builder.append(string postscript); Añade 'postscript' al final del buffer.

Builder.build(); Construye el sistema. La salida es visible a través de la ventana OpenGL de trabajo.

Builder.renderToFile(string fileName, bool overwrite); Guarda lo que se ve en el OpenGL a un archivo. 'overwrite' indica si esta bien sobreescribir archivos existentes sin avisar.

Builder.raytraceToFile(string fileName, bool overwrite); Trazar los rayos de la imágen con el trazador interno y guardarlo en un archivo. 'overwrite' indica si esta bien sobreescribir archivos existentes sin avisar.

Builder.templateRenderToFile(string templateName, string fileName, bool overwrite);Traza los rayos con las mismas dimensiones que la vista, a un archivo. 'overwrite' indica si esta bien sobreescribir archivos existentes sin avisar.

Builder.execute(string fileName, string args, bool waitForFinish); Ejecuta un proceso externo. Pensado para ser usado después de llamar a 'templateRenderToFile'. Si 'waitForFinish' es true, el intérprete de JavaScript se bloqueará hasta que el proceso se complete.

Builder.reset(); Restaura el contenido original del buffer (útil para cuando se hicieron substituciones.)

Builder.setSize(int width, int height); Ajusta las dimensiones de la salida (raytracer interno y plantillas). Si el ancho y el alto son cero, se usan las dimensiones de la pantalla (por defecto). Si el ancho o el alto son cero, la otra dimensión se calcula usando las proporciones del visor.

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

Como mezclarlo todo es cuestión de cada un@.

Esta es una animación de ejemplo (es algo simple, que ya no son horas para andar tecleando): http://videobin.org/+2kk/2v9.html

El código javascript (en el video se repite 4 veces):

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

javascript

// Basado en la referencia // http://blog.hvidtfeldts.net/index.php/2010/11/scripting-in-structure-synth/

function pad(number) { // Añade 0's a un número para que el comando number = number.toString(); // que genere el video no se lie while (number.length < 4) { number = "0" + number; } return number; }

Builder.load("sierpinski_carpet.es"); // Carga la base max = 45; for (i = 0; i <= max; i++) { Builder.reset(); // Se reinicia todo Builder.setSize(0,0); // Inutil, usa tamaño por defecto Builder.define("rotation", (i * 2).toString()); // Se rota 2 grados Builder.build(); // Genera la figura Builder.raytraceToFile("Image" + pad(i) + ".png",true); // La traza en un archivo }

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

El código de la figura sierpinski_carpet.es :

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

// Sierpinksi carpet 3D Fractal set background white set maxdepth 5

define space 3

define ratio 0.33

define color_change 50

define size 4

{s size ry rotation}sierpinski

rule sierpinski{

{ hue color_change s ratio x space } sierpinski { hue color_change s ratio x -space } sierpinski

{ hue color_change s ratio y space } sierpinski { hue color_change s ratio y -space } sierpinski

{ hue color_change s ratio z space } sierpinski { hue color_change s ratio z -space } sierpinski

{ hue color_change s ratio x space y space } sierpinski { hue color_change s ratio x space y space z space } sierpinski { hue color_change s ratio x space y space z -space } sierpinski { hue color_change s ratio x space y -space } sierpinski { hue color_change s ratio x space y -space z space } sierpinski { hue color_change s ratio x space y -space z -space } sierpinski

{ hue color_change s ratio x -space y space } sierpinski { hue color_change s ratio x -space y space z space } sierpinski { hue color_change s ratio x -space y space z -space } sierpinski { hue color_change s ratio x -space y -space } sierpinski { hue color_change s ratio x -space y -space z space } sierpinski { hue color_change s ratio x -space y -space z -space } sierpinski

{ hue color_change s ratio y space z space } sierpinski { hue color_change s ratio y space z -space } sierpinski { hue color_change s ratio y -space z space } sierpinski { hue color_change s ratio y -space z -space } sierpinski

{ hue color_change s ratio z space x space } sierpinski { hue color_change s ratio z space x -space } sierpinski { hue color_change s ratio z -space x space } sierpinski { hue color_change s ratio z -space x -space } sierpinski box }

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

ps: Por desgracia parece que no es del todo estable al ejecutar el raytracer.

Saludos

PoC de login seguro sobre HTTP

A raíz de este_hilo_en_HackXCrack decidí programar un sistema de login que permitiese cierta seguridad ante atacantes pasivos aún funcionando sobre HTTP en plano, todo de forma transparente al usuario.

La idea es simple, cuando el usuario se intenta loguear, se le asigna un token que se utilizará como salt de una función_hash que se aplicará a la contraseña (yo he utilizado MD5 porque tenía el código_en_python a mano), el resultado de la función será el que se envíe. El utilizar un token es importante porque evita ataques_de_replay, es decir, que el atacante pase a través de la función hash, enviando el resultado directamente, no tendría que conocer la contraseña original si el resultado es siempre el mismo. Además es importante que el token lo establezca el servidor y nuncaquién se loguee, ya que lo podría modificar para que fuera el mismo que el del usuario original, con lo que se vuelve al ataque de replay.

Pero tiene bastantes problemas:

* Si el atacante es activo (puede interceptar la conexión y modificar
datos al vuelo), puede cambiar el código fuente de la página,
invalidando esto.

* Las contraseñas han de guardarse en texto plano, para poder realizar el
hash a posteriori.
*
* Como consecuencia de lo anterior se produce un aumento muy considerable
de la carga del servidor, ya que en vez de hacer el hash una sola vez (ya
que se supone que las contraseñas se guardan ya hasheadas), en el peor
caso, ha de comprobarse el hash de todas las contraseñas cada intento de
login.
*

La prueba (todo muy mínimo) está alojada en md5poc.webcindario.com, el código fuente se puede descargar aquí [md5poc.zip]

Btw... 1 año!!

De algoritmos genéticos y entropía

Hoy presento una idea chorra como cualquier otra, pero que a mi personalmente me emocionó ver que funcionaba, es simplemente un conjunto de un intérprete y un programa que modifica un trozo de bytecode al azar, obviamente pensados para trabajar juntos.

La idea es usarlos para generar un algoritmo usando algo análogo a la evolución natural, aplicando un script (solo por comodidad) para que elija que rama del algoritmo debe ser la que prevalezca, el código con un ejemplo: instructolang.zip (el script usa un trozo de código que se puede encontrar aquí entropy.c, aunque va incluido en el .zip).

Por ahora está muy limitado, solo realiza las operaciones de suma, resta, intercambio de variables y asignación, de todos modos no creo que pueda llegar a ser turing completo por cosas como el problema de parada, que sería necesario resolver para evitar bucles infinitos.

Me olvide de añadir la licencia al código =P , tratadlo como si fuera WTFPL.

La compilación no tiene ninguna dificultad, se entra en la carpeta y se hace "make", sino se puede compilar directamente instructo.c y en la carpeta de ejemplos, entropy.c (este requiere el flag -lm en el compilador).

El ejemplo se apoya en el entropy.c para leer la entropía de un archivo, el objetivo es un algoritmo que obtenga un 8 (lo máximo, creo) de entropía. para crear un archivo para el intérprete se llama al binario, instructo, con los siguientes parámetros

-n -f <archivo a crear> -v <número de variables> -l <número de bucles> -rf
<número de bytes de entrada> -wl <número de bytes de salida>

Para llamarlo desde la carpeta de ejemplos se haría (los datos pueden ser cualquiera, mientras el número de variables sea mayor que en número de bytes de entrada)

1
../instructo -n -f entropy.evo -l 512 -v 16 -rf 8 -wl 8

Se puede obtener información acerca de un archivo creado (y una especie de desensamblado si tiene código dentro) con el flag -i

../instructo -i -f entropy.evo


12 -v 16 -rf 8 -wl 8
Número de bucles: 512
Bytes leídos al principio: 8
Bytes escritos al final: 8
Número de variables: 16
Número de bloques: 1
El bloque número 1 tiene 0 bytes de longitud

Lo de los bloques es una función sin terminar, la idea era que se pueda añadir código bloque a bloque, lo que permite seguir trabajando sobre el mismo archivo sin modificar lo anterior, pero aun no está programada la función para crear nuevos.

Para ejecutar un archivo se hace

../instructo -e -f entropy.evo

Aunque por ahora sólo repetirán lo que pongas (despues de pulsar enter) hasta haber completado los 512 bucles de 8 caracteres.

El flag para modificar los archivos es -c, como siempre -f para los archivos, -s para indicar una semilla para los cambios (tiene que ser un número). Los cambios pueden ser para añadir o eliminar código, si solo se quiere añadir, hay que usar -a , o -r para eliminar.

Para el ejemplo lo que se hizo fue utilizar un script bash (a continuación más comentado que en el zip)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/env bash
# Evolve a file pointing to maximum entropy

#Float cond taken from
# http://www.linuxjournal.com/content/floating-point-math-bash
function float_cond(){
    local cond=0
    if [[ $# -gt 0 ]]; then
        cond=$(echo "$*" | bc -q 2>/dev/null)
        if [[ -z "$cond" ]]; then cond=0; fi
        if [[ "$cond" != 0  &&  "$cond" != 1 ]]; then cond=0; fi
        fi
    local stat=$((cond == 0))
    return $stat
}

base="entropy.evo" # Archivo base
mod="entropy.evo.mod" # Archivo modificado
entropy=0   # Entropía más alta conseguida
file=$base  # Código a medir
out="out"   # archivo de salida
show=show   # archivo donde se guarda una muestra de la mayor entropía

function read_entropy(){ # Lee la cantidad de entropía
    ../instructo -e -f $file < sample > $out
    entropy=`./entropy $out`
}

read_entropy # Lee la entropí­a
base_entropy=$entropy # Y la establece como base
echo $entropy

file=$mod # A partir de ahora se medira el código modificado
i=0        # Contador de generaciones
limit=8.00 # Valor objetivo
while float_cond "$entropy < $limit ";do # Mientras no se llegue al nivel objetivo
    ../instructo -c -a -f "$base" -o "$mod" # Añadir código
    if [ $? -ne 0 ];then # Si algo falla, detener el script
        exit 1
    fi
    read_entropy # Se lee la nueva entropí­a
    if float_cond "$entropy >= $base_entropy";then # Si no es menor
        echo $entropy          # se muestra
        base_entropy=$entropy  # y se establece como base
        mv $mod $base          # así como el código
        mv $out $show          # por último se guarda una copia del archivo
    fi
    i=$(($i+1))   # Y se añade 1 al contador de generaciones
done
echo "Generaciones: $i"

Lo único que hace es añadir todas las modificaciones que pueda y que al menos no hagan disminuir la entropía mientras esta sea menor que 8. No se acepta solo cuando aumenta la entropía porque esto permitiria cambios mucho menores, sobre todo al principio, donde se está muy limitado. Nota: para el ejemplo el archivo sample son 4096 'A', para evitar que la base añada entropía.

Lanzando el script, se consigue una entropía de 8 en 27 segundos con alrededor de 700 generaciones y 634 bytes de código, aunque esto cambia mucho, al fin y al cabo es aleatorio ;)

La entropía obtenida (en base64), por poner una muestra

Resultados

Cabe recordar que 4096 bytes sacados de /dev/urandom tienen más o menos una entropía de 7.95 :D

Por último, el script entropy_minimizer.sh, (abajo más comentado) sirve para reducir el código al mínimo sin hacer que caiga la entropía

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/env bash
# Reduces a file to minimun without decreasing entropy

#Float cond taken from
# http://www.linuxjournal.com/content/floating-point-math-bash
function float_cond(){
    local cond=0
    if [[ $# -gt 0 ]]; then
        cond=$(echo "$*" | bc -q 2>/dev/null)
        if [[ -z "$cond" ]]; then cond=0; fi
        if [[ "$cond" != 0  &&  "$cond" != 1 ]]; then cond=0; fi
        fi
    local stat=$((cond == 0))
    return $stat
}


base="entropy.evo" # Archivo base
mod="entropy.evo.mod" # Archivo modificado
entropy=0   # Entropía más alta conseguida
file=$base  # Código a medir
out="out"   # archivo de salida

function read_entropy(){ # Lee la cantidad de entropí­a
    ../instructo -e -f $file < sample > $out
    entropy=`./entropy $out`
}

read_entropy # Lee la entropía
base_entropy=$entropy # Y la establece como base
echo $entropy

file=$mod # A partir de ahora se medira el código modificado
i=0        # Contador de generaciones
limit=10000 # Número máximo de intentos
while [ $i -le $limit ];do
    ../instructo -c -s $i -r -f "$base" -o "$mod" # Recortar código
    if [ $? -ne 0 ];then
        exit 0
    fi
    read_entropy

    # Si no se pierde entropía
    if float_cond "$entropy >= $base_entropy "; then
        echo $entropy
        base_entropy=$entropy
        mv $mod $base # Será el nuevo código
    fi
    i=$(($i + 1)) # Incrementa el contador de generaciones
done

En este caso, puede reducir el código a 58 bytes (42 de código, 14 instrucciones), con lo que el algoritmo quedaría en ( ../instructo -i -f entropy.evo )

SWAP 12 4
SWAP 11 4
ADD 1 4
SWAP 12 1
ADD 3 12
SUB 7 12
SUB 5 4
ADD 1 11
SWAP 10 8
SUB 8 11
SUB 0 5
ADD 2 4
SWAP 10 6
ADD 7 const 175

La notación es similar al ensamblador de Intel (operación destino fuente), cada número es una variable, a menos que ponga const antes (esto es lo que permite a SWAP hacer asignaciones desactivado a menos que se defina ALLOW_ASSIGN en instructo.h) .

La verdad, no creí que un intérprete tan simple, con 3 operaciones pudiera conseguir eso :D, espero ir añadiéndole cosas poco a poco.

Stay tuned [Referencias] http://es.wikipedia.org/wiki/Algoritmo_genético