Hack-It 2010: Nivel 5

Retomando un poquito los hackits de hace algunos años me he topado a la tarde con uno que tenía a medias desde hacía bastante tiempo … este hackit de 2010:

Captura de pantalla 2017-11-13 a las 19.32.44

El señor marcan nos da una imagen en .png en el enlace:

amberpixels.png

Estos suelen ser los hackits/solveits que más me gustan. Este sin embargo me trajo un poco de cabeza durante bastante tiempo …. Y como siempre no era excesivamente dificil …. (sabiendo la clave para resolverlo, cualquiera es facil realmente…)

Empezamos por fijarnos en que en la imagen a simple vista hay pixels de 2 tonos de amarillo/ámbar; sin embargo, si miramos más detenidamente algunas zonas, podremos distinguir un tono de ámbar más pálido:

Captura de pantalla 2017-11-13 a las 19.38.44.png

Partiendo de ese dato, vamos a diferenciar los píxeles de ese color del resto de ellos con este código hecho en Matlab/Octave:

Captura de pantalla 2017-11-13 a las 19.43.40.png

Captura de pantalla 2017-11-13 a las 19.43.01.png

Parandonos a pensar un poco en la imagen, podemos ver que hay algo que destaca claramente en el centro mientras que hay algo de código que aparentemente parece seguir un patrón, por los alrededores del centro …

El siguiente paso que se me ocurrió fue desplazar las líneas horizontales para ver si se podía leer algo de esta forma…

Matlab y Octave tienen una funcion molona que rota arrays el número de rotaciones que se le indiquen: ‘circshift’.

La siguiente pregunta era…. vale… ¿y cuánto rotamos las lineas? Para responder a eso se me ocurrió fijarme en los puntos de la zona central que “parecía” que se repetían:

Captura de pantalla 2017-11-13 a las 19.49.24

Captura de pantalla 2017-11-13 a las 19.49.12

Como vemos, la diferencia es 213-110 = 103. Lo que haremos es, no solo hacer un offset de 103 en esa linea, ya que no dejaría nada claro. Tiene toda la pinta de tener el offset de linea en linea así que a cada linea le añadiremos un offset de 103; es decir, la primera 0, la segunda 103, la tercera 206, la cuarta 309, etc, etc…. Si hacemos eso con todos los pixels (del canal R (o sea, color rojo de la imagen RGB) unicamente en este caso) obtendríamos la siguiente imagen :

Captura de pantalla 2017-11-13 a las 21.22.05.png

El código con el comando ‘circshift’ que he comentado y que produce la imagen anterior es el siguiente:

Captura de pantalla 2017-11-13 a las 21.24.45.png

Qué curioso …. podemos leer casi claramente algo aqui:

Captura de pantalla 2017-11-13 a las 21.26.38.png

Si; dice “Buen trabajo ;)” no obstante…. parece como que la parte superior e inferior del texto no es correcta del todo… ¿por qué? ¿qué es lo que podría estar fallando para que se vea todavía algo mal?

Si nos fijamos un poco, vemos que en la ‘B’ de “Buen” falta la “capota” de arriba (la parte de arriba de la B y que la cierra) y vemos que ésta está más a la derecha en esa misma línea¿?¿?

Captura de pantalla 2017-11-13 a las 21.31.07.png

Además podemos ver cómo los pixels la parte de arriba de la ‘t’ y la ‘b’ (de la palabra “trabajo”) también están más a la derecha en esa misma línea…. ¿Y cómo es esto posible? ……. Pues la respuesta es bien simple: esto significa sencillamente que en una misma linea de la imagen orignal que nos da marcan hay más de una línea de la solución que tenemos que encontrar.

Hay que fijarse que en la imagen original (sin offsetear las líneas con el código de matlab de ‘circshift’ de antes), que podemos ver más arriba (en la imagen en blanco y negro), podemos apreciar que la “capota” de la ‘B’ originalmente está antes que el comienzo de los dos “palitos” que continúan formando la ‘B’ hacia abajo.

De estas observaciones podemos sacar una conclusión: hay que partir las línas cada x para ir formando la imagen final…. Es decir, hay que ir leyendo la imagen linea a linea de izquierda a derecha como si fuera texto y haciendo “intro” cada cierto tiempo

Y ahora la gran pregunta…. ¿cada cuánto hay que hacer “intro”? Imagino que pensando un poco podría sacarse alguna conclusión con los datos que ya tenemos pero… eh, que tenemos un ordenador para sacar todas las posiblidades!!!

Vamos a ello:

Escribiendo el siguiente código:

Captura de pantalla 2017-11-13 a las 22.03.03.png

Conseguimos ejecutar lo siguiente y podemos más o menos, estimar qué valor es el que nos deja una solución legible:

Como podemos ver…. la búsqueda la podemos acotar entre 400 y 450 así que yendo esta vez más despacio descubrimos que el valor “mágico” es … 408:

Captura de pantalla 2017-11-13 a las 22.06.13

Listo! tenemos el texto bien puesto en su sitio!! Vamos a resaltar lo que está en color pálido (como hemos hecho al principio) y…

Captura de pantalla 2017-11-13 a las 22.07.39.png

Aquí podemos ver el código finalmente! ….

1337r0mh4x

EE24 is coming – Parte II

Pues la euskal llega a su fin un día como hoy. Toca llegar a casa y descansar, y sobre todo dormir. DORMIRRR!!!

Los hack-its/solve-its nos han tenido entretenidos el 90% del tiempo pero bueno, el esfuerzo ha merecido la pena: 1er puesto en Solve-It (2º después de los intocables w0pr, que han ganado la competición completa). 5os en Hack-It y 3os en el computo global de Hack/Solve:

Captura de pantalla 2016-07-25 a las 15.43.08.png

Un buen año teniendo en cuenta que pensabamos quedar mejor que el año pasado (>13º) jejj.

He ido recopilando toda la información necesaria para ir resolviendo los solve-its por aqui asi que los iré posteando segun vaya encontrando tiempo.

De momento …. voy a terminar de recoger este percal que aún me queda un cacho y salgo en breves para casa ….

 

Hack-It 2011: Nivel 2

Pues la cosa es que hoy durante mi vuelo a Alemania me he puesto con un hackit que dejé a medias el otro día. Se trata de una “continuación” del Nivel 1 del mismo año:

Captura de pantalla 2016-04-18 a las 18.46.38.png

Si hacemos click derecho en la pagina, como en la vez anterior, y le damos a “ver codigo fuente” obtenemos lo siguiente:

Captura de pantalla 2016-04-18 a las 18.48.00.png

Como podemos ver hay un javascript de nuevo igual que antes; pero como dice marcan, con “vuelta de tuerca”. Veamos con beautifier a ver de qué se trata:

Captura de pantalla 2016-04-18 a las 18.50.37.png

Bueno, como vemos en el for hay un potorro ‘elegante’, que sería muy dificil de describir con palabras, pero lo intento:

Lo que se hace es, de la cadena de texto d (que es “Y ahora el plato fuerte: más de lo mismo, pero con una vuelta de tuerca. ¡Suerte!”) se cogen el valor en ascii del carácter i%d.lenght; se hace la operación XOR con valores cogidos del array ‘r’ y el resultado es la letra de la cadena que queremos ir formando (variable ‘s’).

La operación “i%d.lenght” lo que hace es obtener el modulo ó resto de la operación de dividir ‘i’ entre d.lenght (d.lenght es constante y vale 81 en este caso). Hacemos esto nosotros en Octave, primero declarando las variables:

>> r = [63, 85, 15, 11, 27, 27, 14, 78, 69, 15, 72, 21, 15, 10, 92, 70, 91, 16, 20, 23, 82, 4, 88, 30, 8, 74, 194, 3, 65, 23, 22, 87, 3, 29, 68, 74, 64, 93, 27, 14, 64, 8, 89, 94, 4, 14, 82, 67, 11, 83, 4, 93, 73, 79, 65, 4, 1, 12, 15, 24, 4, 0, 20, 66, 9, 90, 29, 17, 31, 15, 73, 7, 27, 215, 50, 7, 69, 29, 73, 62, 22, 109, 12, 65, 93, 86, 94, 65, 19, 83, 64, 0, 69, 84, 77, 84, 92, 18, 74, 85, 87, 70, 88, 69, 2, 12, 77, 212, 64, 12, 68, 86, 23, 64, 79, 16, 65, 73, 70, 89, 67, 12, 18, 67, 73, 82, 91, 18, 62, 84, 7, 70, 93, 30, 79, 76, 19, 27, 2, 24, 28, 64, 29, 11, 75, 76, 17, 27, 2, 6, 11, 72, 85, 82, 196, 39, 0, 23, 28, 84, 3, 64, 53, 83, 4, 83, 18, 20, 14, 82, 77, 5, 29, 64, 87, 8, 72, 0, 14, 10, 16, 11, 21, 0, 13, 1, 73, 70, 202, 90, 91, 13, 3, 8, 28, 52, 73, 48, 72, 78, 9, 52, 67, 123, 25, 56, 47, 70, 91, 17, 10, 26, 85, 7, 0, 65, 70, 23, 25, 22, 9, 79, 28, 93, 22, 0, 84, 1, 7, 11, 82, 23, 19, 91, 69, 154, 46, 81, 77, 85, 87, 22, 78, 53, 86, 4, 14, 0, 0, 12, 7, 76, 66, 83, 5, 14, 12, 29, 27, 8, 5, 29, 0, 17, 31, 76, 1];
>> d = ‘Y ahora el plato fuerte: más de lo mismo, pero con una vuelta de tuerca. ¡Suerte!’;
>> charD = double(d);

Y luego haciendo la operación en sí:

>> for i=0:266
charCodeAt(i+1) =  mod(i,81);
end

(266 es la longitud -1 del array ‘r’).

Hecho esto tenemos la primera parte, que es básicamente el índice que selecciona los elementos de la variable d (‘i % d.lenght’ en el programa original).

Ahora haremos lo siguiente:

>> for i=0:266
dcharCodeAt(i+1) = d(charCodeAt(i+1)+1);
end

Con esto estaremos seleccionando los valores del array de caracteres ‘d’, que nos interesan. Los +1, como he explicado en algún post anterior, son debidos a que Octave/Matlab no acepta valores en los índices de arrays/matrices iguales a 0.

Seguimos ahora con el siguiente código:

>> charDcharCodeAt = double(dcharCodeAt);
>> for i=1:267
dCharCodeAt_Bin(i,:) = de2bi(charDcharCodeAt(i),8);
end

En la linea de arriba pasamos esos valores que estaban en formato caracter, a valores tipo numérico ascii. En el for inferior lo que hacemos es transformar esos valores numéricos en valores binarios (preparándonos para la operación siguiente, que es un xor lógico bit a bit).

Antes de hacer la operación xor no obstante, hay que pasar los valores numéricos que hay en el array ‘r’ a binario, como hemos hecho con el array de “CharDcharCodeAt”:

>> for i=1:267
r_Bin(i,:) = de2bi(r(i),8);
end

Hecho esto solo queda hacer la operación xor (el operador ‘^’ en javascript, que se ve en el código original):

>> for i=1:267
xor_Bin(i,:) = xor(r_Bin(i,:),dCharCodeAt_Bin(i,:))’;
end

La operación en Octave ‘xor’ nos da como resultado un vector columna (si, aunque hayamos usado de parámetros un par de vectores fila) así que utilizamos el operando ‘ para hacer la traspuesta => convertir el vector columna, en vector fila. Hecha esta operación, solamente queda convertir a valor decimal y posteriormente a caracteres, los datos obtenidos:

> for i=1:267
xor_Bin(i,:) = xor(r_Bin(i,:),dCharCodeAt_Bin(i,:))’;
end

>> aux = bi2de(xor_Bin);

>> char(aux)’

Como resultado de esto obtenemos lo siguiente:

function check(){var p=$(‘#password’).val();var d=$(‘.article p’).html();var o=[74, 59, 36, 58, 32, 24, 8, 53, 37, 0, 54, 23, 42];if(p.length!=o.length){return false;}for(i=0;i<o.length;i++){if(p[i]!=d[o[i]]){return false;}}return true;}$(‘#solveform’).submit(check);

Valeeeee… tenemos una función dentro de otra función … beautifier al canto …:

function check() {
var p = $(‘#password’).val();
var d = $(‘.article p’).html();
var o = [74, 59, 36, 58, 32, 24, 8, 53, 37, 0, 54, 23, 42];
if (p.length != o.length) {
return false;
}
for (i = 0; i < o.length; i++) {
if (p[i] != d[o[i]]) {
return false;
}
}
return true;
}
$(‘#solveform’).submit(check);

Como podemos ver … se trata de un ejercicio igual ahora que el del Nivel 1. Hagamoslo pues y saquemos la respuesta:

>> for i=1:13
pass(i) = d(o(i)+1);
end

pass = Still easY :p

Voila!

Still easY :p

Y sí… luego me he puesto a Strugglear un rato hasta el aterrizaje … 😛

foto01.jpg

Hack-It 2011: Nivel 1

Vamos con un nivel Hackit sencillito para abrir boca por la mañana.

Captura de pantalla 2016-04-13 a las 23.30.35.png

Nos topamos con este hackit de marcan (miedo, y eso que es el nivel 1).

Como (casi) siempre editamos el codigo fuente para ver qué sorpresa nos encontramos:

Captura de pantalla 2016-04-14 a las 13.52.43.png

Encontramos un javascript insertado dentro de head. Le vamos a pasar beautifier para ponerlo un poco mas legible:

Captura de pantalla 2016-04-14 a las 13.53.56.png

mucho mejor, sin duda.

Podemos ver que lo que hace este script es comparar p (que es el password) con d indexado mediante o. Es decir, coge d, que algo del contenido de la pagina (article p) y selecciona sus caracteres mediante el array o. Como en otros hackits, echaremos manos de matl…. perdón, Octave (que estas pruebas engloban una sección en la euskal que se hace llamar “software libre” 😉

Captura de pantalla 2016-04-14 a las 13.58.21.png

Como podemos ver aqui, ‘artice p’ es la frase de “¡Bienvenido! Hoy bla bla bla…”. La pasamos a Octave igualmente como la variable p:

Captura de pantalla 2016-04-14 a las 14.00.22.png

El problema de Octave es que cuando se utilizan caracteres ‘Spanish’ (en este caso el signo de admiracion ‘¡’, no le sienta muy bien:

Captura de pantalla 2016-04-14 a las 14.07.28.png

Como vemos nos desplaza 1 posicion la B y la pone en la 3 cuando deberia ser la 2. Para solucionar esto he reemplazado el caracter ‘¡’ por ‘!’ y así nos quitamos problemas 😉 El siguiente paso es bien sencillo. Hacer lo que hace el script de javascript en octave:

Captura de pantalla 2016-04-14 a las 14.14.02.png

Y voilá, nuestra contraseña:

simply… simplistic 😮

Igual os estais preguntando el por qué del +1 que aparece en la creacion del array solucion. El tema es que Octave trabaja con arrays que comienzan en 1 y NO en 0, como podria ser Javascript o C. Si en octave intentamos indexar en la posición 0 algun valor; éste nos casca error por lo que digo:

Captura de pantalla 2016-04-14 a las 14.16.43.png

Hack-It 2015: Nivel 2

Venga, que hoy estoy bastante libre por lo visto … vamos con otro Hackit. Esta vez de la Euskal Encounter 23 (2015)

Nos topamos con este nivel:

A la hora de reversear un binario me surgieron un par de dudas… Realmente yo no soy programador. Tenia la duda de si se referia a invertir los bits de uno en uno del archivo binario que se nos daba, o bloque a bloque (de byte en byte, word en word, etc…).

En cualquier caso, empece por lo sencillo y lo que yo creia que era a lo que se referia. Abrimos el fichero en Matlab (una gran herramienta sin duda, aunque no sea de programación como tal):

Los datos los lee matlab como un array de 131579 filas por 1 columna de doubles. Si visualizamos algunos de los datos vemos que:

Ha cogido los valores de byte en byte y aunque ponga tipo de dato ‘double’ en el array, son chars (8 bytes ya que van de 0 a 255). Vamos a convertir este fichero a binario en Matlab; que nos saca de apuros con una sencilla funcion que tiene (si, Matlab tiene de todo):

>> datosEnBinario=de2bi(datosOriginales);

Esto nos crea un array de 131579×8; es decir, las mismas filas, solamente que ahora los numeros estan representados por 1’s y 0’s y como los valores van de 0 a 255 necesitan 8 columnas (=> 8 bits) cada uno. Cada bit representado es una variable tipo double (nos sobra memoria!! claro que si!!).

Como queremos transformar los 1’s en 0’s y viceversa vamos a hacer lo siguiente. Primero crear una mascara de 1’s para aplicar una operación XOR sobre toda la matriz. Al hacer esto estaremos convirtiendo los 1’s en 0’s (1 xor 1 = 0) y los 0’s en 1’s (0 xor 1 = 1).

Como podemos ver, esto funciona bastante bien asi que continuamos para empaquetar todo de nuevo y probar a ver que sale:

Hecho esto creamos el .bin y tenemos ya el archivo convertido (invertido bit a bit).

No obstante, no tenemos nada concluyente de qué tipo de archivo sea este nuevo creado:

Captura de pantalla 2016-04-11 a las 13.54.13

Habrá que cambiar de estrategia…

Consultando a algún compañero me comenta de cambiar los bits primero del archivo por el ultimo en lugar de lo que he hecho. Y de seguir sin salir nada, cambiar de byte en byte. Dicho esto me pongo manos a la obra:

>> ArrayDatosEnBinario=reshape(datosEnBinario.’,1052632,1);

Con esto hago que todos los bits que estaban en la matriz de 131579×8 pase a ser un unico array de 1052632×1 (matriz columna).

Como antes, hay una operación maravillosa de Matlab que hace el trabajo por ti e invierte los datos:

>> ArrayDatosEnBinarioUpdowned=flipud(ArrayDatosEnBinario);

Hecho hecho procedemos como antes para crear el archivo con los bits reordenados:

>> datosEnBinInv_V2=reshape(ArrayDatosEnBinarioUpdowned,8,131579)’;
>> datosTransformados_V2=bi2de(datosEnBinInv_V2);
>> pfileData=fopen(‘dataInv2.bin’,’wb’);
>> fwrite(pfileData,datosTransformados_V2);
>> fclose(pfileData);

En este caso resulta que el archivo:

Captura de pantalla 2016-04-11 a las 14.09.39

Parece que se trata de una imagen!! La abrimos y…:

Ahi tenemos la password para el siguiente nivel!

y0ur_l0g1c_1s_y0ur_best_t00l

Hack-It 2010: Nivel 3

Vamos con el primer post!

Llevo varios dias haciendo con la ayuda de amigos Hack-Its y Solve-Its; esos puzzles tipo CTF que ponen en las Encounters (Gipuzkoa, Araba y Euskal) para ir calentando motores para la Euskal Encounter de este año (que a ver si hay suerte y conseguimos plaza porque la cosa pinta mal por la cantidad de gente que cada vez mas se apunta).

El Hack-It de hoy en cuestion es el de 2010, el numero 3:

Nos descargamos el archivo y vemos que se trata de una foto .bmp en blanco y negro, como el propio titulo indica; concretamente es esta imagen:

A priori nada especial, pero si nos fijamos un poco en la parte de arriba a la izquierda de la misma hay unos pequeños puntos que no cuadran muy bien. Para ver que son esos puntos yo he optado por abrir el fichero de la fotografia en Matlab:

Para hacerlo escribimos lo siguiente en la ventana de comandos:

la resolucion de la fotografía  es de 397×522. En principio nada relevante… Sin embargo, ya que es una imagen en blanco y negro de 8 bits (lo que significa que cada pixel de la imagen tendrá un valor de 0 a 255) vamos a mostrar el valor en ascii de la escala de gris de los primeros pixels que vemos diferentes:

Choprechaaa !!! Un mensaje !

Vemos que el mensaje es una pista de lo que tenemos que seguir haciendo con la imagen.

Hagamos caso pues y representemos ahora el histograma de la imagen; en Matlab es tan sencillo como escribir lo siguiente:

Con esto vemos el histograma en el que si nos fijamos, hacia el centro hay unos cuantos valores que estan por debajo del resto… sospechoso…

Al final un histograma, para el que no sepa, es una grafica que nos dice la cantidad de valores de un tipo que hay en una lista de datos. Es decir, en el caso de la imagen, nos dice la cantidad de grises que hay en ella: cuantos pixels con el valor de 0 hay, cuantos con el valor 2, etc … hasta cuantos con el valor de 255. Como vemos en esta imagen, hay muchisimos grises oscuros (parte izquierda de la grafica) y pocos claros (parte derecha).

Sin embargo, hacia el centro como digo, hay unos cuantos valores que destacan de forma especial. Hagamos un poco de zoom:

Si nos nos paramos a pensar un poco en esto, nos daremos cuenta de que JUSTAMENTE los valores que estan ahí son valores IMPARES.

Lo que vamos a hacer es filtrar estos valores para generar únicamente con ellos una nueva imagen. Es decir, eliminaremos TODOS los valores que no sean impares de esa imagen y resaltaremos todos los valores IMPARES para ver que sale.

Lo haremos como se muestra en la captura siguiente y resulta que, al representar su imagen sale …

VAYA !!! Parece que tenemos la clave para el siguiente nivel!

Level_xghr3452

Explicando un poco lo que se hace en las 3 líneas de código de la captura anterior tenemos lo siguiente:

La primera operacion es hacer una tabla de valores logicos en la cual hacemos que si el valor que estamos leyendo es impar ( mod(x,2) da el resto de la operacion de dividir por 2; si ‘x‘ fuese par, mod(x,2) dara como resultado = 0, si ‘x‘ fuese impar dara como resultado algo ≠ 0).

En la segunda línea he multiplicado la matriz que nos ha salido con valores lógicos por 255 para resaltar más los 1’s con respecto a los 0’s y asi diferenciar mejor la imagen que posteriormente hemos generado en la última línea del código.