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
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
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
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
===============================================================================
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 |
|
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 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 |
|
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
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 |
|
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 (
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