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

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

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

!/usr/bin/env bash

wide=1280

high=800

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

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

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

La historia viene de atrás, intentando programar el módulo de la siguiente parte de Introducción a la criptografía, me di de frente con una parte del algoritmo en cuestion  (DSA), que dice así
Toma un primo p de una longitud dada (muy grande, para entendernos),
y otro q, de 160 que sea divisor de p-1 Y ahí se armó el follon. Dejando a un script que buscase al tan ansiado q durante un tiempo no produjo resultados, ya es pesado de por si buscar primos de 160 bits cuanto más comprobar si son divisibles por, otro de como mínimo 512 bits... y no, 2 no vale, porque el otro divisor sería de 511 bits ;).

CFDG (Context Free Design Grammar) es un programa que genera arte en 2D a partir de código, de forma muy similar a como lo hace Structure Synth ( I y II ), de hecho, este se podría considerar una versión en 3D de CFDG.

Lo "malo" es que usarlo a través de la línea de comandos se puede hacer pesado, y las GUI...  me gustaría decir que las probé, pero ya fuera por un Error 404 o por que no compilaba, fue imposible, así que se improvisó una rápida con Lazarus.

Para usarlo hay que hacer es abrir el archivo de proyecto (.lpi) con lazarus, compilarlo, poner los binarios de la gui y de cfdg en el mismo directorio (a menos que el binario de cfdg esté en un $PATH), y ejecutar la gui... Si, un lío, si alguien conoce una forma mejor que avise

Un par de capturas: [http://3.bp.blogspot.com/_26RJWnubh-w/TFcWmyQBneI/AAAAAAAAAO8/y09LHNOFOCI/ s320/Pantallazo-14.png] [http://1.bp.blogspot.com/_26RJWnubh-w/TFcWryOiGvI/AAAAAAAAAPA/22EOW1JG7oM/ s320/Pantallazo-15.png]

Hoy...un script que lleva en el disco duro desde hace un año, simplemente genera los diccionarios de contraseñas por defecto para varios tipos de routers. No se si desde entonces se descubrieron los patrones de nuevos routers, si alguien sabe de alguno que avise.

Se puede descargar aquí [wdic.py], o coloreado al final. Lo dicho, ya tiene su tiempo y le hace falta una reescritura a C (en cuanto encuentre tiempo), pero funciona.

Hay dos formas de usarlo, lanzándolo directamente se maneja con menús

=============================================================================== ./wdic.py =============================================================================== [http://4.bp.blogspot.com/_26RJWnubh-w/TFaFuaEBqBI/AAAAAAAAAOs/QE5Or0kF8do/ s1600/Pantallazo-10.png]

Toda la salida que no sean las contraseñas se hace por stderr, así que se puede redirigir tranquilamente y los menús seguirán saliendo:

[La_primera_parte] (La división va porque se hace incómodo editar el HTML para meter los spoilers con posts largos... si, lo se, soy un vago)

Nota: por alguna razón no se muestran los spoilers si se ven desde la portada, entrad en el post y debería ir.

Los siguientes códigos usan /proc/acpi/ para mostrar la temperatura y Zenity o KDialog para mostrarlo por una GUI

El primero es la base, muestra simplemente las temperaturas por pantalla [temp.sh]:

=============================================================================== ./temp.sh [-c] =============================================================================== El -c para que también se muestre el símbolo de la medida (¿grados?) [Unknown INPUT type] ===============================================================================

!/bin/bash

Escrito por kenkeiras

back=$PWD cd /proc/acpi/thermal_zone/ if [ "$1" = "-c" ]; then     lonx=4 else     lonx=3 fi

Hoy... scripts varios en bash.

Empezando por lo más simple, un cracker de MD5, simplemente lee el diccionario y va comparando las lineas con el hash objetivo [md5crack.sh]

=============================================================================== ./md5crack.sh ===============================================================================

[Unknown INPUT type]

!/usr/bin/env bash

Escrito por kenkeiras

function showuse {     echo "$0 "     exit 1 }

if [ "$1" = "" ] then     showuse fi

if [ "$2" = "" ] then     showuse fi

i=0 for word in $(cat $1);do     test=echo -en "$word" |md5sum|cut -c1-32     if [ "$test" = "$2" ]         then             echo "-> $word"             i=$(($i + 1))         fi done echo "$i resultados" ===============================================================================

Siguiendo con pruebas_de_/dev/tcp, buscar las contraseñas por defecto usando la_web_del_cirt [get_pass_cirt.sh]:

Hoy traigo un script que programa en lenguajes esotéricos, concretamente en Brainfuck, Ook!, Whitespace y Zombie.

Lo único que hace es escribir un programa que muestre por pantalla lo que el usuario pida, su uso es:

./esoprint.py [-h]  [-l <lenguaje>] [-o <archivo de salida>] [<datos> [<datos>
| -n [...] ] | -n]
-h (--help): muestra esta "ayuda"
-l (--language): Selecciona el lenguaje
-o (--output) : Selecciona el archivo de salida (a stdout por defecto)
El resto se toma como información, el -n (--newline) es considerado un salto
de línea

El script se puede descargar [aquí] o al final coloreado

Dejando a parte de Brainfuck y Ook!, de_los_que_se_habló_antes, Whitespace es un lenguaje compuesto únicamente por espacios, tabuladores y saltos de línea, con un conjunto de instrucciones bastante completo [Whitespace_Tutorial] . Zombie está por estar, ni siquiera encontré un intérprete así que no puedo asegurar que funcione, simplemente parecía fácil de programar :).

Y eso es todo.

Resulta que ultimamente (¿ayer?) el blog estuvo redirigiendo a deviantshare.com por problemas con el "gadget", resulta que parece que la página ya no existe, de ahí todo el lío.

Y eso es todo, perdón por las molestias.

Bien, seguimos con Structure Synth...

Definición de nuevas reglas

Recordemos que la unidad básica de los scripts de Structure Synth son las reglas (y las reglas más básicas las primitivas), así que existe la posibilidad de definir nuestras propias reglas, esto se hace sencillamente haciendo:

=============================================================================== rule { componentes de la regla } ===============================================================================

Es decir, para hacer una figura similar a una casa (hay que echarle algo de imaginación),se podria hacer =============================================================================== Box { x 0.5 ry 45 s 0.75 } Box =============================================================================== [http://3.bp.blogspot.com/_26RJWnubh-w/TEla_vG4BII/AAAAAAAAANY/X6rXs2IPiqs/ s320/casa.png]

Si se utilizase esta forma varias veces, se podria definir una regla que la construyese directamente:

Hoy presento uno de los desavarios mas preocupantes que he escrito últimamente, unos programas en Brainfuck (muy sencillos, eso sí)... pero empezemos por el principio.

Actualizado: el traductor ahora también soporta interpretes de Ook! que no permitan comentarios.

Brainfuck

Como dice la Wikipedia:

Brainfuck (jodecerebros), es un lenguaje_de_programación_esotérico,  
diseñado por Urban_Müller en 1993, con el objetivo de hacer un  
lenguaje que fuera a la vez muy simple, Turing_completo y que  
requiriese un compilador pequeño. Müller basó Brainfuck en la  
máquina_de_Turing y le sirvió de inspiración el compilador de 1024  
bytes de tamaño del lenguaje FALSE.  
La distribución clásica es la versión 2 escrita por el propio  
Müller, conteniendo un compilador para el ordenador Amiga, un  
intérprete, programas de ejemplo y un documento "readme".