search

c1b3rwall / module_3

Files from module_3
13 stars 14 forks source link

Ejercicio 1 #8

Open RickDeckcard opened 3 years ago

RickDeckcard commented 3 years ago

Hola a todos, he decido subir un resumen de todo lo hecho para ver si terminamos por sacar la flag del File_1.bmp.

Con stegsecret (herramienta de estego-análisis) obtenemos como resultado que contiene información por el método EoF. Al ver la imágen se intuye que así es por el color morado predominante en la foto de las canicas.

He probado herramientas online que al subir el fichero te dan un texto, pero sin resultados. Otras como Stego Suite y similar no han dado sus frutos al igual que scripts de LSB creados en python.

Analizando con Stego-toolkit no hay nada relevante en los metadatos. Tampoco veo nada importante en el código hexadecimal ni en los strings, eso sí, mucho campo vacio y mucho ruido, algo característico de un fichero con esteganografía.

Aunque el tema artístico lo descarté, hice un barrido y aplique algún filtro en Photoshop pero no ví nada importante.

Llegado a este punto, me centré en buscar algún tipo de xploit introducido dentro de la imagen. Virustotal no detecta nada, como era de esperar. Lo cambié a formato html y lo ejecuté por si llevaba algún javascript pero nada, tampoco lo he visto en el hexadecimal ni con cat haciendo filtros.

Ya me quedan pocas opciones. He visto un tutorial interesante, les dejo aquí el enlace http://www.eiron.net/thesis es sobre como meter una imagen dentro de otra que creo que es lo que tenemos aquí, pero al final del texto hay un código que no sé con que software se implementa y si funcionará, parece que se trata de MathWorks, que ahora me estoy instalando y a ver si hay suerte.

Por último decir que hay un software en IOS que se llama Spy Pix que sería la repera si se pudiera descodificar el mensaje oculto.

Bueno, saludos y que consigais vuestras ovejas eléctricas.

P.D.: Se me olvidaba, steghide da muchos mensajes de error que pueden ser una pista de la parte del fichero que se ha modificado, sinceramente no lo sé.

yerartdev commented 3 years ago

Hola, aviso: newbie total aquí. Cualquier chorrada que diga es totalmente mía :)

Por contribuir. My 2 cents. Yo totalmente perdido igual que el resto o más. Las pistas de @RickDeckcard impresionantes, las miraré

Lo primero que hice fue file [fichero]

kali@yerart-kali:~/ctf-c1b3rwall/module-3$ file File_1.bmp File_1.bmp: Apple DiskCopy 4.2 image M|\021A, 16842753 bytes, 0x1010100 tag size, GCR CLV dsdd (800k), 0x1 format

(GMG: me teniais que haber visto la cara)

kali@yerart-kali:~/module-3$ 7z l File_1.dmg

7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21 p7zip Version 16.02 (locale=C,Utf16=off,HugeFiles=on,64 bits,4 CPUs Intel(R) Core(TM) i7-4500U CPU @ 1.80GHz (40651),ASM,AES-NI)

Scanning the drive for archives: 1 file, 4264318 bytes (4165 KiB)

Listing archive: File_1.dmg

ERROR: File_1.dmg : File_1.dmg Open ERROR: Can not open the file as [Dmg] archive

Errors: 1

7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21 p7zip Version 16.02 (locale=C,Utf16=off,HugeFiles=on,64 bits,4 CPUs Intel(R) Core(TM) i7-4500U CPU @ 1.80GHz (40651),ASM,AES-NI)

Scanning the drive for archives: 1 file, 4264318 bytes (4165 KiB)

Listing archive: File_1.dlmg

ERROR: File_1.dlmg : Can not open the file as archive

Errors: 1

(GMG: No es archivo dmg o dlmg ... CHASCO)

kali@yerart-kali:~/module-3$ sudo mount -o loop -t hfs File_1.dmg ./mnt [sudo] password for kali: mount: /home/kali/module-3/mnt: wrong fs type, bad option, bad superblock on /dev/loop21, missing codepage or helper program, or other error.

(GMG: otro CHASCO, tampoco con hfsplus)

kali@yerart-kali:~/module-3$ steghide info File_1.bmp 2> padding.txt "File_1.bmp": format: Windows 3.x bitmap capacity: 173.4 KB

kali@yerart-kali:~/module-3$cat padding.txt|wc -l 1735

kali@yerart-kali:~/module-3$ cat padding.txt|less

steghide: warning: maybe corrupted bmp data (padding byte at 0x10d8 set to non-zero). steghide: warning: maybe corrupted bmp data (padding byte at 0x10d9 set to non-zero). steghide: warning: maybe corrupted bmp data (padding byte at 0x217c set to non-zero). steghide: warning: maybe corrupted bmp data (padding byte at 0x217d set to non-zero). steghide: warning: maybe corrupted bmp data (padding byte at 0x3220 set to non-zero). [...]

kali@yerart-kali:~/module-3$ xxd -e -g2 -seek 0x10d8 -l4 File_1.bmp 000010d8: 090b 0007

kali@yerart-kali:~/module-3$ xxd -e -g2 -seek 0x217c -l4 File_1.bmp 0000217c: 1116 0067

(GMG: mi hipótesis ... lo han metido en el padding del bitmap)

(GMG: pregunto a Google [inocente, lo sé])

https://www.google.com/search?q=steganography+on+BMP+images+padding+bytes&oq=steganography+on+BMP+images+padding+bytes&aqs=chrome..69i57.950j0j9&sourceid=chrome&ie=UTF-8

--> https://www.exploit-db.com/docs/english/14975-hiding-your-data-inside-the-padding-area-of-files-and-packets-(steganography).pdf (GMG: muy interesante pero a mi no me aporta nada ... a ti @RickDeckcard?)

Estoy pensando en hacer un programa que saque los bytes que reporta steghide y los ponga en una cadena y ver si puedo hacer algo con eso. Hay que tener en cuenta que los bytes del bmp se almacenan little endian y no sé muy bien si coger solo los bytes o todos los de padding ... no entiendo muy bien el formato ... en fin, ahí queda eso :)

frohe commented 3 years ago

En realidad el padding es de 3 bytes, 1419 de ancho módulo 4 son 3. Puede que solo haya utilizado los dos últimos bytes del padding. Aquí la cadena, que se repite, cogiendo los 3 bytes:

000b09001611006e6e009e9e00010000d4c7008e6a009e9e00651b008e8b009e9e009e9e007d7b004200000000

nnžžÔÇŽjžžeŽ‹žžžž}{B

yerartdev commented 3 years ago

Sigo haciendo brainstorming :)

¿Y si lo ponemos en binario?

kali@yerart-kali:~/module-3$ echo "000b09001611006e6e009e9e00010000d4c7008e6a009e9e00651b008e8b009e9e009e9e007d7b004200000000" |xxd -b 00000000: 00110000 00110000 00110000 01100010 00110000 00111001 000b09 00000006: 00110000 00110000 00110001 00110110 00110001 00110001 001611 0000000c: 00110000 00110000 00110110 01100101 00110110 01100101 006e6e 00000012: 00110000 00110000 00111001 01100101 00111001 01100101 009e9e 00000018: 00110000 00110000 00110000 00110001 00110000 00110000 000100 0000001e: 00110000 00110000 01100100 00110100 01100011 00110111 00d4c7 00000024: 00110000 00110000 00111000 01100101 00110110 01100001 008e6a 0000002a: 00110000 00110000 00111001 01100101 00111001 01100101 009e9e 00000030: 00110000 00110000 00110110 00110101 00110001 01100010 00651b 00000036: 00110000 00110000 00111000 01100101 00111000 01100010 008e8b 0000003c: 00110000 00110000 00111001 01100101 00111001 01100101 009e9e 00000042: 00110000 00110000 00111001 01100101 00111001 01100101 009e9e 00000048: 00110000 00110000 00110111 01100100 00110111 01100010 007d7b 0000004e: 00110000 00110000 00110100 00110010 00110000 00110000 004200 00000054: 00110000 00110000 00110000 00110000 00110000 00110000 000000 0000005a: 00001010

yerartdev commented 3 years ago

Llamadme paranioco ... pero ¿qué hay de esas manchas en esa canica? 8-D

Canica sospechosa

NOTA: he usado pixspy

Nklepsis commented 3 years ago

Buenas a todos, En principio es más sencillo de lo que parece. Observad el bloque de bytes correspondientes de 37 al EE, justo después de la cabecera del BMP (54 bytes). Se observa un grupo sospechoso de bytes cuya repres hex es 00 o 01. Si extreis los 4 bits menos bit menos significativos de cada uno, podreis componer en un nuevo munero binario que, pasándolo en última instancia a ASCII, os dará el resultado. Un saludo!

frohe commented 3 years ago

Sí, son sospechosos, pero hay que pensar que lo son!--> se trataba de ver el hex y darse cuenta que son valores sin sentido, pero siendo colores... En todo caso ni LSB normal ni padding ;) Ya está.

RickDeckcard commented 3 years ago

Bueno aquí newbie somos la mayoría . :)

He visto @Nklepsis ha dado el resultado, bravo por tu insistencia.

Yo en mi búsqueda por una forma más fácil os dejo lo último que he averiguado.

Si usamos ZSTEG que es una herramienta de Stego para PNG y BMP, obtenemos esto:

kali@f50861cb9414:/data# zsteg --lsb File_1.bmp

[?] 4 bytes of extra data after image end (IEND), offset = 0x41117a extradata:0 .. 

00000000: 00 00 00 ff                                       |....            |

scanline extradata .. 

00000000: 00 0b 09 00 16 11 00 6e  6e 00 9e 9e 00 01 00 00  |.......nn.......|
00000010: d4 c7 00 8e 6a 00 9e 9e  00 65 1b 00 8e 8b 00 9e  |....j....e......|
00000020: 9e 00 9e 9e 00 7d 7b 00  42 00 00 00 00 00 0b 09  |.....}{.B.......|
00000030: 00 16 11 00 6e 6e 00 9e  9e 00 01 00 00 d4 c7 00  |....nn..........|
00000040: 8e 6a 00 9e 9e 00 65 1b  00 8e 8b 00 9e 9e 00 9e  |.j....e.........|
00000050: 9e 00 7d 7b 00 42 00 00  00 00 00 0b 09 00 16 11  |..}{.B..........|
00000060: 00 6e 6e 00 9e 9e 00 01  00 00 d4 c7 00 8e 6a 00  |.nn...........j.|
00000070: 9e 9e 00 65 1b 00 8e 8b  00 9e 9e 00 9e 9e 00 7d  |...e...........}|
00000080: 7b 00 42 00 00 00 00 00  0b 09 00 16 11 00 6e 6e  |{.B...........nn|
00000090: 00 9e 9e 00 01 00 00 d4  c7 00 8e 6a 00 9e 9e 00  |...........j....|
000000a0: 65 1b 00 8e 8b 00 9e 9e  00 9e 9e 00 7d 7b 00 42  |e...........}{.B|
000000b0: 00 00 00 00 00 0b 09 00  16 11 00 6e 6e 00 9e 9e  |...........nn...|
000000c0: 00 01 00 00 d4 c7 00 8e  6a 00 9e 9e 00 65 1b 00  |........j....e..|
000000d0: 8e 8b 00 9e 9e 00 9e 9e  00 7d 7b 00 42 00 00 00  |.........}{.B...|
000000e0: 00 00 0b 09 00 16 11 00  6e 6e 00 9e 9e 00 01 00  |........nn......|
000000f0: 00 d4 c7 00 8e 6a 00 9e  9e 00 65 1b 00 8e 8b 00  |.....j....e.....|

imagedata .. text: "eps]hoPckAQY<IK2==" b2,rgb,lsb,xY .. text: "TPQD@TTP" b4,g,lsb,xY .. file: raw G3 (Group 3) FAX, byte-padded

Veo que hay un fichero raw y algo que parecen unas flags, base64 la primera que no consigo descifrar.

Con el comando zsteg -E "b4,g,lsb,xY" File_1.bmp > extracted2.raw extraemos el fichero que nos aparece, pero no sé si voy bien encaminado o no para conseguir la flag de una forma menos laboriosa.

Saludos replicantes :)

yerartdev commented 3 years ago

Man, cuando has puesto tu despedida te he reconocido ... y he echado a correr! (sé que voy a tener una muerte épica) 8-X

Yo me he puesto a usar xxd + cryptii + una red neuronal profunda que tengo muy entrenada desde hace años (mejor no digo cuantos) con la clave dada por @Nklepsis y creo que es lo menos laborioso low cost de andar por casa ...

... y he visto cosas que vosotros no creeríais. Naves de ataque en llamas más allá del hombro de Orión. He visto rayos-C brillar en la oscuridad cerca de la Puerta de Tannhäuser. Todos esos momentos se perderán en el tiempo, como lágrimas en la lluvia ....

ehm, saludos 8-P

Relwarc17 commented 3 years ago

Buenas a todos, En principio es más sencillo de lo que parece. Observad el bloque de bytes correspondientes de 37 al EE, justo después de la cabecera del BMP (54 bytes). Se observa un grupo sospechoso de bytes cuya repres hex es 00 o 01. Si extreis los 4 bits menos bit menos significativos de cada uno, podreis componer en un nuevo munero binario que, pasándolo en última instancia a ASCII, os dará el resultado. Un saludo!

Buenas, ¿Puedes explicar un poco mejor como extraer los 4 bits menos significativos de esos grupos? Veo los grupos sospechosos y he intentado varias combinaciones pero no doy con nada.

yerartdev commented 3 years ago

Buenas a todos, En principio es más sencillo de lo que parece. Observad el bloque de bytes correspondientes de 37 al EE, justo después de la cabecera del BMP (54 bytes). Se observa un grupo sospechoso de bytes cuya repres hex es 00 o 01. Si extreis los 4 bits menos bit menos significativos de cada uno, podreis componer en un nuevo munero binario que, pasándolo en última instancia a ASCII, os dará el resultado. Un saludo!

Buenas, ¿Puedes explicar un poco mejor como extraer los 4 bits menos significativos de esos grupos? Veo los grupos sospechosos y he intentado varias combinaciones pero no doy con nada.

kali@yerart-kali:~/module-3$ xxd File_1.bmp |less

00000000: 424d 7c11 4100 0000 0000 3600 0000 2800 BM|.A.....6...(. 00000010: 0000 8b05 0000 e903 0000 0100 1800 0000 ................ 00000020: 0000 0000 0000 202e 0000 202e 0000 0000 ...... ... ..... [...]

A partir de la "dirección 30"

00000030: 0000 0000 0000 16 00 0101 0001 0100 0100 ................ 00000040: 0101 0001 0101 0100 0101 0000 0100 0000 ................

a partir del 37 coje de la pareja de dos dígitos hexadecimales, el segundo y agrúpalos de 8 en 8

37 --> 00 --> 0 38 --> 01 --> 1 39 --> 01 -->1 3A --> 00 --> 0 3B --> 01 --> 1 3C --> 01 --> 1 3D --> 00 --> 0 3E --> 01 --> 1

Asi que 01101101 --> ASCII converter (p.e cryptii) --> m

Si seguimos un poco:

01101111 --> o 01100100 --> d 01110101 --> u 01101100 --> l 01100101 --> e 00110011--> 3

and so on ...

Saludos

Relwarc17 commented 3 years ago

¡¡¡¡¡¡Gracias!!!!!

Me estaba comiendo el primer bit y por eso no me salía

asalazard commented 3 years ago

¡¡¡¡¡¡Gracias!!!!!

Me estaba comiendo el primer bit y por eso no me salía

Pues no logro que me pille la flag... Se saca solo hasta la siguiente llave, no? module3{......} , dejando las mayúsculas como están y las minúsculas? veo 1 y 0 por todas partes, hay alguna forma de automatizarlo?

yerartdev commented 3 years ago

¡¡¡¡¡¡Gracias!!!!! Me estaba comiendo el primer bit y por eso no me salía

Pues no logro que me pille la flag... Se saca solo hasta la siguiente llave, no? module3{......} , dejando las mayúsculas como están y las minúsculas? veo 1 y 0 por todas partes, hay alguna forma de automatizarlo?

Por supuesto. Necesitas conocimientos de bash y los comandos for,/do/done, xxd, echo, cat, bc. A mi me ha llevado una mañana pero un "basher" lo haría en dos patadas (y en una sola línea de comando, probablemente)

kali@yerart-kali:~/module-3$ for i in $(xxd -p -c 0x08 -s 0x37 -l 0xb8 File_1.bmp); do s=$i; for j in {1..16..2}; do echo -n ${s:$j:1}; done; echo; done > flag.txt

kali@yerart-kali:~/module-3$ for c in $(cat flag.txt); do echo "obase=16; ibase=2; $c"|bc|xxd -p -r; done; echo

Referencias utilizadas

-- https://www.cyberciti.biz/faq/bash-for-loop/ -- https://www.cyberciti.biz/faq/linux-unix-bash-for-loop-one-line-command/ -- https://unix.stackexchange.com/questions/303960/index-a-string-in-bash -- https://stackoverflow.com/questions/11193466/echo-without-newline-in-a-shell-script -- https://unix.stackexchange.com/questions/98948/ascii-to-binary-and-binary-to-ascii-conversion-tools -- https://unix.stackexchange.com/questions/199615/understand-ibase-and-obase-in-case-of-conversions-with-bc -- https://www.ascii-code.com/

Explicación

1) Visualizamos los primeros bytes del fichero

kali@yerart-kali:~/module-3$ xxd -g8 File_1.bmp |less

00000000: 424d7c1141000000 0000360000002800  BM|.A.....6...(.
00000010: 00008b050000e903 0000010018000000  ................
00000020: 000000000000202e 0000202e00000000  ...... ... .....
00000030: 0000000000001600 0101000101000100  ................
00000040: 0101000101010100 0101000001000000  ................
00000050: 0101010001000100 0101000101000000  ................
00000060: 0101000001000100 0001010000010100  ................
00000070: 0101010100010100 0100000101000000  ................
00000080: 0100010000010100 0100000000010000  ................
00000090: 0101010000010100 0101010001000000  ................
000000a0: 0001010000010100 0101000001010100  ................
000000b0: 0001010000000000 0101000001010000  ................
000000c0: 0001010000000100 0101000101000000  ................
000000d0: 0001010000010100 0101010101000100  ................
000000e0: 0000000100010001 0101010101010100  ................
000000f0: 0000000000000000 0000000000000000  ................
00000100: 0000000000000000 0000000000000000  ................

[...]

2) Localizamos el "stego" como los bytes que comienzan en 0x37 y terminan en 0xef

kali@yerart-kali:~/module-3$ xxd -s 0x37 -g8 File_1.bmp |less

00000037: 0001010001010001 0001010001010101  ................
00000047: 0001010000010000 0001010100010001  ................
00000057: 0001010001010000 0001010000010001  ................
00000067: 0000010100000101 0001010101000101  ................
00000077: 0001000001010000 0001000100000101  ................
00000087: 0001000000000100 0001010100000101  ................
00000097: 0001010100010000 0000010100000101  ................
000000a7: 0001010000010101 0000010100000000  ................
000000b7: 0001010000010100 0000010100000001  ................
000000c7: 0001010001010000 0000010100000101  ................
000000d7: 0001010101010001 0000000001000100  ................
000000e7: 0101010101010101 0000000000000000  ................
000000f7: 0000000000000000 0000000000000000  ................

[...]

3) Calculamos el número de bytes que tenemos que coger para conseguir nuestra flag (calculadora de google o aplicación de escritorio o neuronas entrenadas al efecto)

0xef - 0x37 = 0xb8 (184) bytes que hay que "recoger"

4) hacemos que xxd nos recoja los 0xb8 bytes de 8 en 8 (1 byte = 2 dígitos en hexa = 16 dígitos hexa)

::NOTA::la opción -c de xxd nos pone columnas de n bytes y la opción -p nos quita las direcciones y nos pone solamente los grupos de columnas

kali@yerart-kali:~/module-3$ xxd -p -c 0x08 -s 0x37 -l 0xb8 File_1.bmp

0001010001010001
0001010001010101
0001010000010000
0001010100010001
0001010001010000
0001010000010001
0000010100000101
0001010101000101
0001000001010000
0001000100000101
0001000000000100
0001010100000101
0001010100010000
0000010100000101
0001010000010101
0000010100000000
0001010000010100
0000010100000001
0001010001010000
0000010100000101
0001010101010001
0000000001000100
0101010101010101

5) Para cada trozo de 16 dígitos hexa nos quedamos con los 4 bits (un dígito hexa) menos significativo (el segundo dígito de la pareja, i.e el que tiene posición impar, puesto que la indexación de strings en bash comienza con 0 y no con 1)

::NOTA::para propósitos didácticos hago una variable con una cadena de los 0xb8 dígitos hexa todos juntitos :) y lo hago para el primer bloque de 16 dígitos hexa

kali@yerart-kali:~/module-3$ stego=$(xxd -p -c 0xb9 -s 0x37 -l 0xb8 File_1.bmp)
kali@yerart-kali:~/module-3$ echo ${stego:0:16}
0001010001010001
kali@yerart-kali:~/module-3$ echo ${stego:16:16}
0001010001010101
[...]

kali@yerart-kali:~/module-3$ s1=${stego:0:16}
kali@yerart-kali:~/module-3$ for i in {1..16..2}; do echo -n ${s1:$i:1}; done; echo
01101101

6) una vez que tenemos el carácter en binario lo convertimos en hexa con bc y lo ponemos en ascii con xxd

kali@yerart-kali:~/module-3$ echo "obase=16; ibase=2; 01101101" |bc|xxd -p -r
m

Espero que esté claro

Un Saludo

Phyambre commented 3 years ago

En base a la aportacion de yerartdev, he construído un script en bash que nos permitirá hacer experimentos de forma más generalizada. Supongamos que lo guardamos el el fichero lsb.sh

#!/bin/bash
if [[ $# -ne 3 ]] 
then
  echo "Usage: $0 <INPUT_FILE> <STARTING_BYTE> <NUMBER_OF_CHARS>"
  echo "Where <STARTING_BYTE> is expressed in hexadecimal format 0xZZ and <NUMBER_OF_CHARS> is expressed in decimal format"
  echo "Example: $0 File_1.bmp 0x37 22"
else
  nchars=$(printf '0x%x\n' $(($3*8)))
  # -c = octets per line
  # -s = scan starting position
  # -l = length of scan
  s=""
  for i in $(xxd -p -c 0x08 -s $2 -l $nchars "$1")
  do
    for j in {1..16..2} 
    do 
      s="${s}$(echo -n ${i:$j:1})"
    done
  done
  echo "obase=16; ibase=2; $s" | bc | xxd -p -r
fi

Le damos permisos de ejecución

$ chmod 0755 lsb.sh

Para ver la ayuda, no tenemos más que escribir:

$ ./lsb.sh

Y para el caso particular del File_1.bmp, para obtener la flag ejecutamos:

$ ./lsb.sh File_1.bmp 0x37 22

Y listo