HackerOne 212 CTF Writeup

Ya se que había prometido otros writeups antes que este pero es que si no me paran de poner ctf’s así no hay quien pueda, aprovecho que para este no hubo manera más que escribir un writeup para compartirlo con vosotros a ver que os parece.

Enunciado:
An engineer of acme.org launched a new server for a new admin panel at
http://104.236.20.43/. He is completely confident that the server can’t be hacked. He added a
tripwire that notifies him when the flag file is read. He also noticed that the default Apache
page is still there, but according to him that’s intentional and doesn’t hurt anyone. Your goal?
Read the flag!

Writeup:

En la url que nos dan podemos ver la página por defecto de Apache (versión de Ubuntu) que nos mencionan en el enunciado, después de buscar un poco me encontré con algo interesante en la uri /flag con el siguiente resultado:

El hecho de que nos den el dominio y la referencia a un panel de administrador me llevo a probar poniendo distintos dominios en mi archivo de hosts apuntando a esa ip resultando en un 200 y una cookie:

 Probamos a poner la cookie a yes:

GET no está permitido, así que la siguiente opción a probar es POST:

Parece que falta algo. Mientras tanto dirbuster encontró un par de uris interesantes, /read.php y /reset.php, el segundo solo me devolvía ok pero el primero parecía mucho más prometedor:

Después de varios intentos pasando el parámetro row como json (por el tipo de respuesta que recibí), url e incluso en una cookie me decidí por volver al index y probar el post allí:

Ok, espera un dominio, vamos a añadirlo:

Tiene que ser un .com:

Extraño, probamos añadiendo otro .com:

Parece que el dominio tiene que seguir el formato 212.domain.com:

Volvemos a read.php a ver que hay esta vez ahí:

Decodificando el base64 nos muestra el contenido del website, así que parece que estamos ante una vulnerabilidad SSRF así que apuntamos nuestro dominio a 127.0.0.1 y repetimos la llamada:

Esta vez obtenemos la página de default de Apache nuevamente, pero ahora podemos intentar encontrar otros servicios añadiendo un puerto a la llamada, luego de un rato encontré algo interesante en el puerto 1337:

Esta vez obtenemos el mensaje “Hmm, where would it be?”  La página de flag parece el sitio obvio pero el problema es que las llamadas terminan siendo del estilo /flag.com así que necesitaba escapar el .com pero los caracteres habituales no estaban permitidos. Así que vamos a intentar mover el .com a otro header:

Pero la respuesta esta vacía, espera, no subían los ID de uno en uno? Acabamos de saltar del ID 10 al 12, vamos a ver que hay en el ID 11:

Bingo! Decodificamos el base64 y encontramos la flag:

La verdad es que la prueba ha sido muy interesante así como un gran quebradero de cabeza, aquí queda todo muy bonito pero la verdad es que fueron varios días de pegarse contra un muro en cada nuevo avance, pero ha sido una gran experiencia.

Espero os haya gustado y, como siempre, gracias por vuestra visita!

Publicado en ctf, hackerone, web, writeups | 3 comentarios

Cybercamp 2017 Online – 09. Cryptic messages [400]

Por un momento dejamos forense a un lado para volver con cripto, nos dan el siguiente enunciado y links:

Encrypted messages have been shared in a multi-user network. The goal is to get the sent message in plain text. Examine the contents of the file associated with this challenge to get the sent message.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective9_a.txt

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective9_b.txt

Ambos ficheros son idénticos salvo que uno aparecen los datos en español y en el otro en inglés, por pereza me quede con el de inglés y al abrirlo me encontré con esto:

Ahí podemos ver los siguientes datos:

  • Un número primo
  • Un generator
  • Mensajes cifrados
  • Intercambio de claves

El enunciado no nos da ninguna pista sobre el tipo de cifrado pero los datos anteriormente mencionados nos dan  una base para empezar a buscar.

Para empezar parece ser una clave de cifrado asimétrica del estilo de RSA, aunque esta utiliza dos números primos en lugar de un primo y un generator, así que centrémonos en esas características para nuestra búsqueda.

Después de andar rebuscando, viendo listados de cifrados, etc, etc finalmente volví a terminar en la wikipedia donde leí esto:

the ElGamal encryption system is an asymmetric key encryption algorithm for public-key cryptography which is based on the Diffie–Hellman key exchange.

Parece que cumple con el primer criterio y revisando el algoritmo efectivamente utilizan un número primo y un generator, parece que tenemos vencedor. No os penséis que esto fue tan fácil, realmente me tiré un buen rato buscando, leyendo, y probando jeje Diffie-Hellman precisamente me tuvo entretenido un rato pero fue la pista final para llegar a ElGamal.

Buscando sobre como poder atacar elGamal me encontré el siguiente artículo, muy interesante, donde explica todo el proceso: http://jceipek.com/Cracking-ElGamal/

Así que tenemos la siguiente información:

K = g^{a} (mod p)

p = 668086880889731962133523431807175727
g = 5
a = (desconocido)

Siendo K las claves públicas podemos intentar crackear “a” de forma relativamente sencilla:

p = 668086880889731962133523431807175727L
g = 5

ks = [
	13676350792300656720415722840537517L,
	203945637215597518230545505171659679L,
	580366026388626537671567427495532104L,
	44183384276523077372058753373688245L,
	285030156272853013220480705095447260L,
	357012145447722165249748761535461006L,
	390029735669441452196274751955684179L,
	601989706928792605813992011832479199L,
	360961284583613898695965394387421236L,
	139941716626953418230482445280581903L,
	105881177968778568798759564195833907L,
	390526685498939106176110574061595602L,
	563639529202234758731368531968832147L,
	324245072881445330437040962443118945L,
	405610708257034412823729058735169540L,
	650262519644970696024389370642695650L,
	213432877935741336033450896689174194L,
	353552678930580044120885303672148957L,
	243663467386438261103795683502533121L,
	60054856901287017831260389123964788L,
	47619151582173839369440869144212671L
]

for k in ks:
	print "Testing key: %s" % k
	for i in xrange(0, 10000):
		if k == pow(g,i,p):
			print "FOUND:	%s " % i
			break
		elif i==9999:
			print "Password not found"

Como vemos en el script se itera por todas las claves públicas y por cada una se prueban 10000 posibles valores de “a”, ejecutamos el script y obtenemos lo siguiente:

Hemos tenido suerte y hemos conseguido encontrar un valor valido: 5713

Ahora tenemos:

  • Los mensajes cifrados utilizando las claves públicas y privadas.
  • Las 21 claves públicas utilizadas.
  • Una clave privada, 5713, utilizada para cifrar alguno de los mensajes.

El siguiente paso sera iterar por todos los mensajes utilizando la información que conocemos para encontrar aquellos cifrados con nuestra clave privada y ver que contienen:

import binascii, string

ks = [
	13676350792300656720415722840537517L,
	203945637215597518230545505171659679L,
	580366026388626537671567427495532104L,
	44183384276523077372058753373688245L,
	285030156272853013220480705095447260L,
	357012145447722165249748761535461006L,
	390029735669441452196274751955684179L,
	601989706928792605813992011832479199L,
	360961284583613898695965394387421236L,
	139941716626953418230482445280581903L,
	105881177968778568798759564195833907L,
	390526685498939106176110574061595602L,
	563639529202234758731368531968832147L,
	324245072881445330437040962443118945L,
	405610708257034412823729058735169540L,
	650262519644970696024389370642695650L,
	213432877935741336033450896689174194L,
	353552678930580044120885303672148957L,
	243663467386438261103795683502533121L,
	60054856901287017831260389123964788L,
	47619151582173839369440869144212671L
]

ms = [
	275023513241996465145375277081798608L,
	447218054680404751018822774460718704L,
	51995582795200573676963225532291674L,
	193223721789665268065712251555969216L,
	220335814464633181853626310867800188L,
	656425673616840602129167597679995093L,
	281892485332165528077148251112629012L,
	620557294483014348860918835366093395L,
	156345492853024516725256648981773406L,
	132200864409682167694544306450049620L,
	382432406296505241913643555684753752L,
	172521731908572948160105617230206656L,
	658413611309329150536039577629832733L,
	470009248009045054893716168409231672L,
	23596506422783336435053882014037130L,
	383558469957245595047304146183172589L,
	347874231426543687257153625634545539L,
	67459688204264591154317629916556269L,
	191215507340327093723036088461066387L,
	115117630595934113621417863594045891L,
	664015760731773907898900144736007853L,
	595217394235485536046669899798176478L,
	112023097890488836143086615204661790L,
	608874679440735925600052610265281796L,
	627004193985581843968567471204709309L,
	400371059170563645226682976240507021L,
	275561561380430753130008463891051319L,
	200330734437451947551782935576820286L,
	4050142404262389618647986897000959L,
	23146488724874171376119071203201823L,
	301084425566731188968143030280327612L,
	661999379372886369576256038659921506L,
	538840376896108158028033793328837055L,
	628613307485444872721287063540568485L,
	268637255868335003688434687411074993L,
	381198387780204467302612163348706704L,
	400162560639994092221980422692908055L,
	399884623550765435890595082239306353L,
	95290873877305597733967646180307586L,
	641264950193834896903186128424472068L,
	43114514832635661215282858829006066L,
	68848632281350060105250861040771224L,
	139026874478930635813093749231601370L,
	655054596740951208790111828671407650L,
	651375195158994899657890599658048856L,
	285442090376771814189050634199458623L,
	982626333322476170131864630408090L,
	469354413955364991082951491284192153L,
	103793433289712076190450408975699625L,
	4766500844846659360508423238089711L,
	377669527108872822305052284949357020L,
	95920750238990748132617870809588151L,
	127278808060571896803384740938668807L,
	189601784199791219483320087267882549L,
	344196550998639525901987791134561537L,
	263650727383674608586010904392328918L,
	459739916775104719487159379591490295L,
	439037356963229048061191227105627374L,
	186379926031613967999671113768565225L,
	84951650617004032168830381676866149L,
	656944761086661565220056094921318296L,
	502980701175656560313734064531551071L,
	107271094854895401072269844571403805L,
	516400490889683786305851199913815487L,
	606808728818715487827728440626551855L,
	27411826797353775333603907921745463L,
	524397563941504625880910396018932380L,
	24021136517611978297227685711419170L,
	219047882901615601296318017152053796L,
	42988869817116390289497212345458978L,
	356011675196335642115022112592576960L,
	223494308152020204522016556367321846L,
	346356309073576552673987939313043383L,
	599172108441353432011552211209759120L,
	286703909778039270880661258004633674L,
	660051626702153873713990679214106770L,
	141402079720691873145676175151050276L,
	242429047870131231642110013163376117L,
	193213311272454674555953883981535401L,
	350431438249475996960516854823204070L,
	406755029946632926255211620049600144L,
	298956115564633149551111642911769177L,
	624983588666681197516867067080227343L,
	322865886478608435617642618336886528L,
	484310864483152708576021119100590468L,
	323317770963134415387616019546124150L,
	664611512535013863159898484781401394L,
	564091952146454446893647704186484295L,
	612037128288224063949207003244931903L,
	143546506514694697702580740506451057L,
	474806893256685165420572727361313727L,
	239612759211713177457242520864545373L,
	74787785262221388851642570545110090L,
	274719943084337263336901857643803025L,
	502725889933552791883959493172359564L,
	575862093313626652925425410032589465L,
	505698177665487415454788766346780242L,
	581461780713181428956776682676939535L,
	530397494115930081791582949104886302L,
	285801387076390876754579887639733109L,
	510921457560136739170187973639958611L,
	663500891194754312048932854322793679L,
	463343466711415614750405955546091366L,
	221203346954627052668479687662911260L,
	189469132893167348761976530592996989L,
	188603058226806753069769225787858738L,
	616194194941484971188276658095704275L,
	113202092462663629728701607894834865L,
	309886466150813197844325706680318621L,
	639471373224136177331540772282298710L,
	192932334651310913857988456012323837L,
	114816913019746305825440313210515565L,
	74828199087438656125488068396634735L,
	522732653872542903229762834179641882L,
	191584423265039561925713828567071717L,
	227787869970564063041296346104679887L,
	306891653972344582241361176850584407L,
	392274172021885022443850587414407011L,
	125559738428408720475644102324838556L,
	615364216773625903334625795559421169L,
	500057421841703584877403678260138799L,
	260070084421235847074282002455457252L,
	187600596342100486089171096561896931L,
	339635057512093364991610116021953342L,
	339110300499989182998368511866157833L,
	660779395639316212241686437332003362L,
	329095027993074595919695551410540583L,
	140605789490440930875187497544296460L,
	257176879402866603529816355782375986L,
	324120980584346851162216090452979977L,
	194387168439381116078942591916009397L,
	175995255161919702861081374240179288L,
	259572006909692576380172420589925452L,
	509638935328899883642651178414675943L,
	298090377811497995789786927516761223L,
	55053603143546713705199061614172199L,
	211194736508204713045164972691471559L,
	322643858284619135628948880605163328L,
	439668266247815895970171643710455379L,
	587820837884352136815268545013060251L,
	95753039954214631842487951960885318L,
	491620200566522347901236852867785307L,
	301780054420658208572651245649627539L,
	351451218715182319868764656094037520L,
	89539648924955438094086602983260782L,
	166704048535849478418519555410161074L,
	389820252475886726351349233054499366L,
	85845598060256819271577218812087780L,
	118024352385516021924162367848038300L,
	134454254807443906815016665983042484L,
	635605035001932628742852236741891992L,
	285472755901244094520983263238312924L,
	242112294852247232052558862110026552L,
	555253203134618755614672537833547733L,
	255188187487970487505231795251002256L,
	362408360464855976002489117110507504L,
	497798205064839028989840950145093903L,
	664598263130956335111813563348353854L,
	176248945524152414626381741808780582L,
	459320289109161198395771953215785644L,
	352241435713696262643915518276547395L,
	299109270475944905422148853708209824L,
	605389275264832802088211224918956056L,
	270428096336061713906253329149472894L,
	118236816750358362845164515718656153L,
	413485833771564678539647748788319049L,
	523462356290280371241112889147181889L,
	70447181971292666325002616079110879L,
	94208126463978995542294456139862677L,
	175200039423318692241081357349657280L,
	33148743030138295425863598894494680L,
	21237242841043549932136698852470846L,
	71957619258305017989437299179723715L,
	563661543710991717276574237793420753L,
	639429223748100829821152259664648759L,
	111682601189739995895306397620637428L,
	86069271466041748677971387575107561L,
	32781001024753003354920591047220459L,
	304680222370252324708846074103480953L,
	412468073256502561255069087528766427L,
	281036079681016522949370175392467269L,
	52602357085365575792478273909939590L,
	521705544428555254953998581032264483L,
	523357143576414494615671730610365650L,
	49383328153585943265768459507402214L,
	325319666760700489505055717374892372L,
	571546298787029679777929059902713655L,
	487909322255400265409025779925892990L,
	393785198212849758008912370728252216L,
	566956552334637565880432440938357002L,
	34318900912105668553839995901038535L
]

p = 668086880889731962133523431807175727L
g = 5
a = 5713

def is_printable(input_str):
	return all(ord(c) < 127 and c in string.printable for c in input_str)

def decrypt(r, c, a, p):
    return (pow(r,p-1-a,p)*c) % p

for m in ms:
  for k in ks:
    dec = decrypt(k , m , a , p)
    hexnum = hex(dec)

    if len(hexnum)%2 == 0:
      hexnum = "0x0" + hexnum[2:]

    message = binascii.unhexlify(hexnum[2:-1])

    if is_printable(message):
      print "c1: %s \nc2: %s \nmessage: %s"  % (k, m , message)

Ejecutamos el script y obtenemos el siguiente resultado:

Como solo hay un resultado está claro que nuestra flag es: crypt0_w0rld=)

Espero os haya gustado, un saludo!

Publicado en cripto, ctf, cybercamp, writeups | Deja un comentario

Cybercamp 2017 Online – 08. Elephant memory [200]

Y seguimos con forense, que me encanta, esta vez tenemos el siguiente enunciado y link:

During the investigation of a case of money laundering, it was possible to acquire the ram (.vmem) file of the virtual machine, but no the disk image. It is known that the organization that was doing money laundering was using a means of payment through a web service to receive the commissions. It is needed to get the password in order to access to the account that used the online payment and see the list of transactions received.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective8.raw

Esta vez parece que no tenemos una imágen de disco sino de memoria, tocará sacarle el polvo a volatility, primero veamos que tipo de imagen es:

volatility imageinfo -f objective8.raw

Nos da tres posibles perfiles, decidí quedarme con el primero, vamos a ver que procesos están corriendo:

Los procesos más interesantes son KeePass, Chrome, wordpad y notepad ya que son los que más probabilidades tienen de contener una contraseña.

Vamos a comenzar con Keepass, creamos un directorio para dumpear el proceso y lanzamos el siguiente comando:

mkdir o8
volatility memdump -p 1336 --profile Win7SP1x86_23418 -f objective8.raw --dump-dir=o8/

Como veis le he especificado el PID del proceso, en este caso 1336 y nos ha guardado el dump en la carpeta que hemos creado.

¿Que suele ser lo más facil para buscar cadenas de texto en un binario? Nuestro viejo amigo strings, le pasamos un less para poder hacer busquedas y ver poco a poco la información de la siguiente manera:

 strings o8/1336.dmp | less

Por si no lo sabéis en less podéis buscar texto utilizando la / y a continuación el texto a buscar, por ejemplo:

Precisamente esa es la primera búsqueda que se me ocurrió, pulsamos enter para que encuentre la primera coincidencia y para las siguientes simplemente escribimos / de nuevo y pulsamos enter para ver las siguientes coincidencias.

A la cuarta coincidencia parece que hemos tenido suerte:

Probamos y efectivamente la flag es: Birds_fly_cats_not

Gracias por vuestra visita, un saludo!

Publicado en ctf, cybercamp, forense, writeups | Deja un comentario

Cybercamp 2017 Online – 07. Holidays [200]

Esta prueba me pareció un tanto curiosa y la verdad es que tuve suerte de que sea un tema en el que he estado trabajando en los últimos meses ya que me permitió sacarla bastante rápido, pero vamos al lío, nos dan el siguiente enunciado y link:

A well-known sportsman has requested for a vacation from a travel agency. He asked for the required discretion in the destiny to avoid being persecuted by paparazzi. The president of the travel company devised a document to keep it secret.

Due to a leak of information through an agency employee, a magazine got the file called FLAG.zip. Could you review its content and thus determine if the filtered information is reliable?

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective7.zip

Lo primero que intente fue descomprimir el archivo zip, pero extrañamente me salto un error de descompresión, raro, le tiramos un file y vemos lo siguiente:

Mmm, parece que no se reconoce la cabecera, vamos a echarle un vistazo con hexdump:

Eso no es una cabecera de un ZIP o yo no he visto una en mi vida. Preguntemosle a San Google…. Más fácil dicho que hecho, después de mucho buscar termine en el articulo sobre archivos STL de la wikipedia donde decía lo siguiente:

The Materialise Magics software uses the 80-byte header at the top of the file to represent the overall color of the entire part. If color is used, then somewhere in the header should be the ASCII string “COLOR=” followed by four bytes representing red, green, blue and alpha channel (transparency) in the range 0–255. This is the color of the entire object, unless overridden at each facet. Magics also recognizes a material description; a more detailed surface characteristic. Just after “COLOR=RGBA” specification should be another ASCII string “,MATERIAL=” followed by three colors (3×4 bytes): first is a color of diffuse reflection, second is a color of specular highlight, and third is an ambient light. Material settings are preferred over color.

Parece que tenemos un ganador, vamos a probar a abrir el archivo con un software de impresión 3D, en mi caso utilizo Repetier-Host para mi impresora así que ya lo abrí en el, et voila:

Como bien podéis leer la flag final es Habana.

Espero os haya gustado, un saludo y gracias por vuestra visita!

Publicado en ctf, cybercamp, forense, writeups | 2 comentarios

Cybercamp 2017 Online – 06. Pretty flowers [300]

Superando el tercio de pruebas vamos a por la sexta que nos deja el siguiente enunciado y link:

This exercise consists of three files: an executable, an image and an encrypted 7z. Somehow the three files are related. Find out how and validate the flag.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective6.zip

En este caso nos dan una imagen, un archivo 7z y un binario, como animal de costumbres que soy lo primero que hice fue investigar la imagen a ver si encontraba algo pero después de darle mil vueltas y perder un tiempo valioso decidí irme a por el binario a ver si tenía más suerte, lo cargue en gdb con peda e hice un disas main:

   0x56555700 <+0>:     lea    ecx,[esp+0x4]
   0x56555704 <+4>:     and    esp,0xfffffff0
   0x56555707 <+7>:     push   DWORD PTR [ecx-0x4]
   0x5655570a <+10>:    push   ebp
   0x5655570b <+11>:    mov    ebp,esp
   0x5655570d <+13>:    push   edi
   0x5655570e <+14>:    push   esi
   0x5655570f <+15>:    push   ebx
   0x56555710 <+16>:    push   ecx
   0x56555711 <+17>:    sub    esp,0x878
   0x56555717 <+23>:    call   0x565555d0 <__x86.get_pc_thunk.bx>
   0x5655571c <+28>:    add    ebx,0x18e4
   0x56555722 <+34>:    mov    esi,ecx
   0x56555724 <+36>:    mov    BYTE PTR [ebp-0x6d],0x41
   0x56555728 <+40>:    mov    BYTE PTR [ebp-0x6c],0x42
   0x5655572c <+44>:    mov    BYTE PTR [ebp-0x6b],0x43
   0x56555730 <+48>:    mov    BYTE PTR [ebp-0x6a],0x44
   0x56555734 <+52>:    mov    BYTE PTR [ebp-0x69],0x45
   0x56555738 <+56>:    mov    BYTE PTR [ebp-0x68],0x46
   0x5655573c <+60>:    mov    BYTE PTR [ebp-0x67],0x47
   0x56555740 <+64>:    mov    BYTE PTR [ebp-0x66],0x48
   0x56555744 <+68>:    mov    BYTE PTR [ebp-0x65],0x49
   0x56555748 <+72>:    mov    BYTE PTR [ebp-0x64],0x4a
   0x5655574c <+76>:    mov    BYTE PTR [ebp-0x63],0x4b
   0x56555750 <+80>:    mov    BYTE PTR [ebp-0x62],0x4c
   0x56555754 <+84>:    mov    BYTE PTR [ebp-0x61],0x4d
   0x56555758 <+88>:    mov    BYTE PTR [ebp-0x60],0x4e
   0x5655575c <+92>:    mov    BYTE PTR [ebp-0x5f],0x4f
   0x56555760 <+96>:    mov    BYTE PTR [ebp-0x5e],0x50
   0x56555764 <+100>:   mov    BYTE PTR [ebp-0x5d],0x51
   0x56555768 <+104>:   mov    BYTE PTR [ebp-0x5c],0x52
   0x5655576c <+108>:   mov    BYTE PTR [ebp-0x5b],0x53
   0x56555770 <+112>:   mov    BYTE PTR [ebp-0x5a],0x54
   0x56555774 <+116>:   mov    BYTE PTR [ebp-0x59],0x55
   0x56555778 <+120>:   mov    BYTE PTR [ebp-0x58],0x56
   0x5655577c <+124>:   mov    BYTE PTR [ebp-0x57],0x57
   0x56555780 <+128>:   mov    BYTE PTR [ebp-0x56],0x58
   0x56555784 <+132>:   mov    BYTE PTR [ebp-0x55],0x59
   0x56555788 <+136>:   mov    BYTE PTR [ebp-0x54],0x5a
   0x5655578c <+140>:   mov    BYTE PTR [ebp-0x53],0x5f
   0x56555790 <+144>:   mov    BYTE PTR [ebp-0x52],0x61
   0x56555794 <+148>:   mov    BYTE PTR [ebp-0x51],0x62
   0x56555798 <+152>:   mov    BYTE PTR [ebp-0x50],0x63
   0x5655579c <+156>:   mov    BYTE PTR [ebp-0x4f],0x64
   0x565557a0 <+160>:   mov    BYTE PTR [ebp-0x4e],0x65
   0x565557a4 <+164>:   mov    BYTE PTR [ebp-0x4d],0x66
   0x565557a8 <+168>:   mov    BYTE PTR [ebp-0x4c],0x67
   0x565557ac <+172>:   mov    BYTE PTR [ebp-0x4b],0x68
   0x565557b0 <+176>:   mov    BYTE PTR [ebp-0x4a],0x69
   0x565557b4 <+180>:   mov    BYTE PTR [ebp-0x49],0x6a
   0x565557b8 <+184>:   mov    BYTE PTR [ebp-0x48],0x6b
   0x565557bc <+188>:   mov    BYTE PTR [ebp-0x47],0x6c
   0x565557c0 <+192>:   mov    BYTE PTR [ebp-0x46],0x6d
   0x565557c4 <+196>:   mov    BYTE PTR [ebp-0x45],0x6e
   0x565557c8 <+200>:   mov    BYTE PTR [ebp-0x44],0x6f
   0x565557cc <+204>:   mov    BYTE PTR [ebp-0x43],0x70
   0x565557d0 <+208>:   mov    BYTE PTR [ebp-0x42],0x71
   0x565557d4 <+212>:   mov    BYTE PTR [ebp-0x41],0x72
   0x565557d8 <+216>:   mov    BYTE PTR [ebp-0x40],0x73
   0x565557dc <+220>:   mov    BYTE PTR [ebp-0x3f],0x74
   0x565557e0 <+224>:   mov    BYTE PTR [ebp-0x3e],0x75
   0x565557e4 <+228>:   mov    BYTE PTR [ebp-0x3d],0x76
   0x565557e8 <+232>:   mov    BYTE PTR [ebp-0x3c],0x77
   0x565557ec <+236>:   mov    BYTE PTR [ebp-0x3b],0x78
   0x565557f0 <+240>:   mov    BYTE PTR [ebp-0x3a],0x79
   0x565557f4 <+244>:   mov    BYTE PTR [ebp-0x39],0x7a
   0x565557f8 <+248>:   cmp    DWORD PTR [esi],0x1
   0x565557fb <+251>:   je     0x56555807 <main+263>
   0x565557fd <+253>:   mov    eax,0x1
   0x56555802 <+258>:   jmp    0x56555c55 <main+1365>
   0x56555807 <+263>:   sub    esp,0xc
   0x5655580a <+266>:   lea    eax,[ebx-0x1310]
   0x56555810 <+272>:   push   eax
   0x56555811 <+273>:   call   0x56555570 <exif_data_new_from_file@plt>
   0x56555816 <+278>:   add    esp,0x10
   0x56555819 <+281>:   mov    DWORD PTR [ebp-0x2c],eax
   0x5655581c <+284>:   cmp    DWORD PTR [ebp-0x2c],0x0
   0x56555820 <+288>:   jne    0x56555847 <main+327>
   0x56555822 <+290>:   mov    eax,DWORD PTR [esi+0x4]
   0x56555825 <+293>:   add    eax,0x4
   0x56555828 <+296>:   mov    eax,DWORD PTR [eax]
   0x5655582a <+298>:   sub    esp,0x8
   0x5655582d <+301>:   push   eax
   0x5655582e <+302>:   lea    eax,[ebx-0x1304]
   0x56555834 <+308>:   push   eax
   0x56555835 <+309>:   call   0x56555500 <printf@plt>
   0x5655583a <+314>:   add    esp,0x10
   0x5655583d <+317>:   mov    eax,0x2
   0x56555842 <+322>:   jmp    0x56555c55 <main+1365>
   0x56555847 <+327>:   mov    DWORD PTR [ebp-0x28],0x0
   0x5655584e <+334>:   jmp    0x56555b04 <main+1028>
   0x56555853 <+339>:   cmp    DWORD PTR [ebp-0x28],0x0
   0x56555857 <+343>:   jne    0x5655590a <main+522>
   0x5655585d <+349>:   lea    eax,[ebp-0x881]
   0x56555863 <+355>:   mov    ecx,0x64
   0x56555868 <+360>:   mov    esi,0x0
   0x5655586d <+365>:   mov    DWORD PTR [eax],esi
   0x5655586f <+367>:   mov    DWORD PTR [eax+ecx*1-0x4],esi
   0x56555873 <+371>:   lea    edx,[eax+0x4]
   0x56555876 <+374>:   and    edx,0xfffffffc
   0x56555879 <+377>:   sub    eax,edx
   0x5655587b <+379>:   add    ecx,eax
   0x5655587d <+381>:   and    ecx,0xfffffffc
   0x56555880 <+384>:   shr    ecx,0x2
   0x56555883 <+387>:   mov    edi,edx
   0x56555885 <+389>:   mov    eax,esi
   0x56555887 <+391>:   rep stos DWORD PTR es:[edi],eax
   0x56555889 <+393>:   movzx  eax,BYTE PTR [ebp-0x5b]
   0x5655588d <+397>:   mov    BYTE PTR [ebp-0x881],al
   0x56555893 <+403>:   movzx  eax,BYTE PTR [ebp-0x44]
   0x56555897 <+407>:   mov    BYTE PTR [ebp-0x880],al
   0x5655589d <+413>:   movzx  eax,BYTE PTR [ebp-0x4d]
   0x565558a1 <+417>:   mov    BYTE PTR [ebp-0x87f],al
   0x565558a7 <+423>:   movzx  eax,BYTE PTR [ebp-0x3f]
   0x565558ab <+427>:   mov    BYTE PTR [ebp-0x87e],al
   0x565558b1 <+433>:   movzx  eax,BYTE PTR [ebp-0x3c]
   0x565558b5 <+437>:   mov    BYTE PTR [ebp-0x87d],al
   0x565558bb <+443>:   movzx  eax,BYTE PTR [ebp-0x52]
   0x565558bf <+447>:   mov    BYTE PTR [ebp-0x87c],al
   0x565558c5 <+453>:   movzx  eax,BYTE PTR [ebp-0x41]
   0x565558c9 <+457>:   mov    BYTE PTR [ebp-0x87b],al
   0x565558cf <+463>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x565558d3 <+467>:   mov    BYTE PTR [ebp-0x87a],al
   0x565558d9 <+473>:   sub    esp,0xc
   0x565558dc <+476>:   lea    eax,[ebp-0x881]
   0x565558e2 <+482>:   push   eax
   0x565558e3 <+483>:   call   0x56555560 <exif_tag_from_name@plt>
   0x565558e8 <+488>:   add    esp,0x10
   0x565558eb <+491>:   mov    DWORD PTR [ebp-0x30],eax
   0x565558ee <+494>:   mov    eax,DWORD PTR [ebp-0x2c]
   0x565558f1 <+497>:   mov    eax,DWORD PTR [eax]
   0x565558f3 <+499>:   sub    esp,0x8
   0x565558f6 <+502>:   push   DWORD PTR [ebp-0x30]
   0x565558f9 <+505>:   push   eax
   0x565558fa <+506>:   call   0x56555550 <exif_content_get_entry@plt>
   0x565558ff <+511>:   add    esp,0x10
   0x56555902 <+514>:   mov    DWORD PTR [ebp-0x24],eax
   0x56555905 <+517>:   jmp    0x56555b00 <main+1024>
   0x5655590a <+522>:   cmp    DWORD PTR [ebp-0x28],0x1
   0x5655590e <+526>:   jne    0x56555a11 <main+785>
   0x56555914 <+532>:   lea    eax,[ebp-0x881]
   0x5655591a <+538>:   mov    ecx,0x64
   0x5655591f <+543>:   mov    esi,0x0
   0x56555924 <+548>:   mov    DWORD PTR [eax],esi
   0x56555926 <+550>:   mov    DWORD PTR [eax+ecx*1-0x4],esi
   0x5655592a <+554>:   lea    edx,[eax+0x4]
   0x5655592d <+557>:   and    edx,0xfffffffc
   0x56555930 <+560>:   sub    eax,edx
   0x56555932 <+562>:   add    ecx,eax
   0x56555934 <+564>:   and    ecx,0xfffffffc
   0x56555937 <+567>:   shr    ecx,0x2
   0x5655593a <+570>:   mov    edi,edx
   0x5655593c <+572>:   mov    eax,esi
   0x5655593e <+574>:   rep stos DWORD PTR es:[edi],eax
   0x56555940 <+576>:   movzx  eax,BYTE PTR [ebp-0x65]
   0x56555944 <+580>:   mov    BYTE PTR [ebp-0x881],al
   0x5655594a <+586>:   movzx  eax,BYTE PTR [ebp-0x46]
   0x5655594e <+590>:   mov    BYTE PTR [ebp-0x880],al
   0x56555954 <+596>:   movzx  eax,BYTE PTR [ebp-0x52]
   0x56555958 <+600>:   mov    BYTE PTR [ebp-0x87f],al
   0x5655595e <+606>:   movzx  eax,BYTE PTR [ebp-0x4c]
   0x56555962 <+610>:   mov    BYTE PTR [ebp-0x87e],al
   0x56555968 <+616>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x5655596c <+620>:   mov    BYTE PTR [ebp-0x87d],al
   0x56555972 <+626>:   movzx  eax,BYTE PTR [ebp-0x6a]
   0x56555976 <+630>:   mov    BYTE PTR [ebp-0x87c],al
   0x5655597c <+636>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x56555980 <+640>:   mov    BYTE PTR [ebp-0x87b],al
   0x56555986 <+646>:   movzx  eax,BYTE PTR [ebp-0x40]
   0x5655598a <+650>:   mov    BYTE PTR [ebp-0x87a],al
   0x56555990 <+656>:   movzx  eax,BYTE PTR [ebp-0x50]
   0x56555994 <+660>:   mov    BYTE PTR [ebp-0x879],al
   0x5655599a <+666>:   movzx  eax,BYTE PTR [ebp-0x41]
   0x5655599e <+670>:   mov    BYTE PTR [ebp-0x878],al
   0x565559a4 <+676>:   movzx  eax,BYTE PTR [ebp-0x4a]
   0x565559a8 <+680>:   mov    BYTE PTR [ebp-0x877],al
   0x565559ae <+686>:   movzx  eax,BYTE PTR [ebp-0x43]
   0x565559b2 <+690>:   mov    BYTE PTR [ebp-0x876],al
   0x565559b8 <+696>:   movzx  eax,BYTE PTR [ebp-0x3f]
   0x565559bc <+700>:   mov    BYTE PTR [ebp-0x875],al
   0x565559c2 <+706>:   movzx  eax,BYTE PTR [ebp-0x4a]
   0x565559c6 <+710>:   mov    BYTE PTR [ebp-0x874],al
   0x565559cc <+716>:   movzx  eax,BYTE PTR [ebp-0x44]
   0x565559d0 <+720>:   mov    BYTE PTR [ebp-0x873],al
   0x565559d6 <+726>:   movzx  eax,BYTE PTR [ebp-0x45]
   0x565559da <+730>:   mov    BYTE PTR [ebp-0x872],al
   0x565559e0 <+736>:   sub    esp,0xc
   0x565559e3 <+739>:   lea    eax,[ebp-0x881]
   0x565559e9 <+745>:   push   eax
   0x565559ea <+746>:   call   0x56555560 <exif_tag_from_name@plt>
   0x565559ef <+751>:   add    esp,0x10
   0x565559f2 <+754>:   mov    DWORD PTR [ebp-0x34],eax
   0x565559f5 <+757>:   mov    eax,DWORD PTR [ebp-0x2c]
   0x565559f8 <+760>:   mov    eax,DWORD PTR [eax]
   0x565559fa <+762>:   sub    esp,0x8
   0x565559fd <+765>:   push   DWORD PTR [ebp-0x34]
   0x56555a00 <+768>:   push   eax
   0x56555a01 <+769>:   call   0x56555550 <exif_content_get_entry@plt>
   0x56555a06 <+774>:   add    esp,0x10
   0x56555a09 <+777>:   mov    DWORD PTR [ebp-0x20],eax
   0x56555a0c <+780>:   jmp    0x56555b00 <main+1024>
   0x56555a11 <+785>:   lea    eax,[ebp-0x881]
   0x56555a17 <+791>:   mov    ecx,0x64
   0x56555a1c <+796>:   mov    esi,0x0
   0x56555a21 <+801>:   mov    DWORD PTR [eax],esi
   0x56555a23 <+803>:   mov    DWORD PTR [eax+ecx*1-0x4],esi
   0x56555a27 <+807>:   lea    edx,[eax+0x4]
   0x56555a2a <+810>:   and    edx,0xfffffffc
   0x56555a2d <+813>:   sub    eax,edx
   0x56555a2f <+815>:   add    ecx,eax
   0x56555a31 <+817>:   and    ecx,0xfffffffc
   0x56555a34 <+820>:   shr    ecx,0x2
   0x56555a37 <+823>:   mov    edi,edx
   0x56555a39 <+825>:   mov    eax,esi
   0x56555a3b <+827>:   rep stos DWORD PTR es:[edi],eax
   0x56555a3d <+829>:   movzx  eax,BYTE PTR [ebp-0x65]
   0x56555a41 <+833>:   mov    BYTE PTR [ebp-0x881],al
   0x56555a47 <+839>:   movzx  eax,BYTE PTR [ebp-0x5b]
   0x56555a4b <+843>:   mov    BYTE PTR [ebp-0x880],al
   0x56555a51 <+849>:   movzx  eax,BYTE PTR [ebp-0x5f]
   0x56555a55 <+853>:   mov    BYTE PTR [ebp-0x87f],al
   0x56555a5b <+859>:   movzx  eax,BYTE PTR [ebp-0x5b]
   0x56555a5f <+863>:   mov    BYTE PTR [ebp-0x87e],al
   0x56555a65 <+869>:   movzx  eax,BYTE PTR [ebp-0x43]
   0x56555a69 <+873>:   mov    BYTE PTR [ebp-0x87d],al
   0x56555a6f <+879>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x56555a73 <+883>:   mov    BYTE PTR [ebp-0x87c],al
   0x56555a79 <+889>:   movzx  eax,BYTE PTR [ebp-0x4e]
   0x56555a7d <+893>:   mov    BYTE PTR [ebp-0x87b],al
   0x56555a83 <+899>:   movzx  eax,BYTE PTR [ebp-0x4f]
   0x56555a87 <+903>:   mov    BYTE PTR [ebp-0x87a],al
   0x56555a8d <+909>:   movzx  eax,BYTE PTR [ebp-0x5c]
   0x56555a91 <+913>:   mov    BYTE PTR [ebp-0x879],al
   0x56555a97 <+919>:   movzx  eax,BYTE PTR [ebp-0x52]
   0x56555a9b <+923>:   mov    BYTE PTR [ebp-0x878],al
   0x56555aa1 <+929>:   movzx  eax,BYTE PTR [ebp-0x3f]
   0x56555aa5 <+933>:   mov    BYTE PTR [ebp-0x877],al
   0x56555aab <+939>:   movzx  eax,BYTE PTR [ebp-0x4a]
   0x56555aaf <+943>:   mov    BYTE PTR [ebp-0x876],al
   0x56555ab5 <+949>:   movzx  eax,BYTE PTR [ebp-0x45]
   0x56555ab9 <+953>:   mov    BYTE PTR [ebp-0x875],al
   0x56555abf <+959>:   movzx  eax,BYTE PTR [ebp-0x4c]
   0x56555ac3 <+963>:   mov    BYTE PTR [ebp-0x874],al
   0x56555ac9 <+969>:   movzx  eax,BYTE PTR [ebp-0x40]
   0x56555acd <+973>:   mov    BYTE PTR [ebp-0x873],al
   0x56555ad3 <+979>:   sub    esp,0xc
   0x56555ad6 <+982>:   lea    eax,[ebp-0x881]
   0x56555adc <+988>:   push   eax
   0x56555add <+989>:   call   0x56555560 <exif_tag_from_name@plt>
   0x56555ae2 <+994>:   add    esp,0x10
   0x56555ae5 <+997>:   mov    DWORD PTR [ebp-0x38],eax
   0x56555ae8 <+1000>:  mov    eax,DWORD PTR [ebp-0x2c]
   0x56555aeb <+1003>:  mov    eax,DWORD PTR [eax+0x8]
   0x56555aee <+1006>:  sub    esp,0x8
   0x56555af1 <+1009>:  push   DWORD PTR [ebp-0x38]
   0x56555af4 <+1012>:  push   eax
   0x56555af5 <+1013>:  call   0x56555550 <exif_content_get_entry@plt>
   0x56555afa <+1018>:  add    esp,0x10
   0x56555afd <+1021>:  mov    DWORD PTR [ebp-0x1c],eax
   0x56555b00 <+1024>:  add    DWORD PTR [ebp-0x28],0x1
   0x56555b04 <+1028>:  cmp    DWORD PTR [ebp-0x28],0x2
   0x56555b08 <+1032>:  jle    0x56555853 <main+339>
   0x56555b0e <+1038>:  cmp    DWORD PTR [ebp-0x1c],0x0
   0x56555b12 <+1042>:  je     0x56555bd0 <main+1232>
   0x56555b18 <+1048>:  cmp    DWORD PTR [ebp-0x20],0x0
   0x56555b1c <+1052>:  je     0x56555bd0 <main+1232>
   0x56555b22 <+1058>:  cmp    DWORD PTR [ebp-0x24],0x0
   0x56555b26 <+1062>:  je     0x56555bd0 <main+1232>
   0x56555b2c <+1068>:  sub    esp,0x4
   0x56555b2f <+1071>:  push   0x400
   0x56555b34 <+1076>:  lea    eax,[ebp-0x881]
   0x56555b3a <+1082>:  push   eax
   0x56555b3b <+1083>:  push   DWORD PTR [ebp-0x20]
   0x56555b3e <+1086>:  call   0x56555510 <exif_entry_get_value@plt>
   0x56555b43 <+1091>:  add    esp,0x10
   0x56555b46 <+1094>:  movzx  eax,BYTE PTR [ebp-0x881]
   0x56555b4d <+1101>:  test   al,al
   0x56555b4f <+1103>:  je     0x56555bd0 <main+1232>
   0x56555b51 <+1105>:  sub    esp,0x8
   0x56555b54 <+1108>:  lea    eax,[ebp-0x881]
   0x56555b5a <+1114>:  push   eax
   0x56555b5b <+1115>:  lea    eax,[ebp-0x46d]
   0x56555b61 <+1121>:  push   eax
   0x56555b62 <+1122>:  call   0x56555530 <strcpy@plt>
   0x56555b67 <+1127>:  add    esp,0x10
   0x56555b6a <+1130>:  sub    esp,0x4
   0x56555b6d <+1133>:  push   0x400
   0x56555b72 <+1138>:  lea    eax,[ebp-0x881]
   0x56555b78 <+1144>:  push   eax
   0x56555b79 <+1145>:  push   DWORD PTR [ebp-0x24]
   0x56555b7c <+1148>:  call   0x56555510 <exif_entry_get_value@plt>
   0x56555b81 <+1153>:  add    esp,0x10
   0x56555b84 <+1156>:  sub    esp,0x8
   0x56555b87 <+1159>:  lea    eax,[ebp-0x881]
   0x56555b8d <+1165>:  push   eax
   0x56555b8e <+1166>:  lea    eax,[ebp-0x46d]
   0x56555b94 <+1172>:  push   eax
   0x56555b95 <+1173>:  call   0x56555520 <strcat@plt>
   0x56555b9a <+1178>:  add    esp,0x10
   0x56555b9d <+1181>:  sub    esp,0x4
   0x56555ba0 <+1184>:  push   0x400
   0x56555ba5 <+1189>:  lea    eax,[ebp-0x881]
   0x56555bab <+1195>:  push   eax
   0x56555bac <+1196>:  push   DWORD PTR [ebp-0x1c]
   0x56555baf <+1199>:  call   0x56555510 <exif_entry_get_value@plt>
   0x56555bb4 <+1204>:  add    esp,0x10
   0x56555bb7 <+1207>:  sub    esp,0x8
   0x56555bba <+1210>:  lea    eax,[ebp-0x881]
   0x56555bc0 <+1216>:  push   eax
   0x56555bc1 <+1217>:  lea    eax,[ebp-0x46d]
   0x56555bc7 <+1223>:  push   eax
   0x56555bc8 <+1224>:  call   0x56555520 <strcat@plt>
   0x56555bcd <+1229>:  add    esp,0x10
   0x56555bd0 <+1232>:  mov    DWORD PTR [ebp-0x481],0x0
   0x56555bda <+1242>:  mov    DWORD PTR [ebp-0x47d],0x0
   0x56555be4 <+1252>:  mov    DWORD PTR [ebp-0x479],0x0
   0x56555bee <+1262>:  mov    DWORD PTR [ebp-0x475],0x0
   0x56555bf8 <+1272>:  mov    DWORD PTR [ebp-0x471],0x0
   0x56555c02 <+1282>:  movzx  eax,BYTE PTR [ebp-0x468]
   0x56555c09 <+1289>:  mov    BYTE PTR [ebp-0x481],al
   0x56555c0f <+1295>:  movzx  eax,BYTE PTR [ebp-0x465]
   0x56555c16 <+1302>:  mov    BYTE PTR [ebp-0x480],al
   0x56555c1c <+1308>:  movzx  eax,BYTE PTR [ebp-0x467]
   0x56555c23 <+1315>:  mov    BYTE PTR [ebp-0x47f],al
   0x56555c29 <+1321>:  movzx  eax,BYTE PTR [ebp-0x46d]
   0x56555c30 <+1328>:  mov    BYTE PTR [ebp-0x47e],al
   0x56555c36 <+1334>:  movzx  eax,BYTE PTR [ebp-0x462]
   0x56555c3d <+1341>:  mov    BYTE PTR [ebp-0x47d],al
   0x56555c43 <+1347>:  movzx  eax,BYTE PTR [ebp-0x46c]
   0x56555c4a <+1354>:  mov    BYTE PTR [ebp-0x47c],al
   0x56555c50 <+1360>:  mov    eax,0x0
   0x56555c55 <+1365>:  lea    esp,[ebp-0x10]
   0x56555c58 <+1368>:  pop    ecx
   0x56555c59 <+1369>:  pop    ebx
   0x56555c5a <+1370>:  pop    esi
   0x56555c5b <+1371>:  pop    edi
   0x56555c5c <+1372>:  pop    ebp
   0x56555c5d <+1373>:  lea    esp,[ecx-0x4]
   0x56555c60 <+1376>:  ret

WOW! Como sabéis lo mio no es reversing precisamente así que me impresiono bastante ver todas estas lineas, de buenas a primeras lo que más me llamo la atención fue la llamada a strcat en la dirección 0x56555bc8 así que puse un breakpoint ahí:

¡Bien he encontrado algo, seguro que es la contraseña del 7z!… Ah pues no… jo

Y es que en mis ansías no me fijé en que a continuación se seguían realizando operaciones, así que una docena de breakpoints después (insisto, reversing no es lo mio probablemente haya mil maneras más faciles de sacarlo jeje) para ir viendo la última parte de la ejecución fui viendo que iba pasando en cada paso. Luego de un par de ejecuciones me fije en que en el registro EAX iban apareciendo una serie de caracteres antes de finalizar la ejecución:

Después de anotarlos me quede con el string w2aC7y, esta vez si que hubo suerte y esta era la contraseña que buscabamos para el 7z, descomprimimos y obtenemos un txt con la flag:

FLAG: ReversingIsCool

Seguramente alguien más ducho en reversing os podría explicar con más detalle que se va haciendo en cada paso y probablemente lo hubiese visto en el primer vistazo, por desgracia reversing es un tema que tengo muy verde y contento me quedo con haberlo conseguido sacar jeje

Un saludo y gracias por vuestra visita!

Publicado en ctf, cybercamp, reversing, writeups | Deja un comentario

Cybercamp 2017 Online – 05. Without Collaboration [300]

Esta prueba en concreto me gusto bastante ya que yo mismo he estado trasteando con un método parecido, pero vamos al grano, tenemos este enunciado y el link:

Something unusual was happening on a coworker’s computer. We already identified the culprit but he does not collaborate and he does not explain how he got the information from the computer. However, a traffic capture was found that might be useful. Identify how the computer was compromised and whether he accessed some sensitive file.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective5.pcap

Esta vez nos encontramos con un pcap con una captura de tráfico bastante grande, por acotar me límite a las direcciones locales y descarté el trafico de internet para más tarde.

Las ip’s que se localizaron fueron la 192.168.47.191 y la 192. Filtrando primero por una y luego por otra vemos que la 192 básicamente solo se comunica con la 191:

Vemos que basicamente se utilizan dos protocolos, el UDP y el ICMP, después de revisar los paquetes por encima de UDP me decante por echarles un vistazo a los ICMP (como os digo, esto fue un poco de casualidad porque justo había estado trabajando con dichos paquetes) así que filtro y me encuentro con esto:

Mmm ¿Un ping sin response en la misma red local y donde hemos visto que el tráfico es bastante fluido? Algo no me cuadra, sigo mirando los otros paquetes y en uno me llevo una grata sorpresa:

Parece que están utilizando los paquetes ICMP para exfiltrar información, vamos a utilizar scapy en python para extraer la información de dichos paquetes con el siguiente scripts:

from scapy.all import *

packets = rdpcap('objective5.pcap')

for pkt in packets:
	if pkt.haslayer(ICMP):
		if hasattr(pkt[ICMP], 'load'):
			print pkt[ICMP].load

Como veis es muy sencillo y no me he complicado mucho la vida, recorro todo el pcap en busca de ICMP’s e imprimo por pantalla el contenido del load, el resultado es este:



Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

C:\>



C:\>













dir

dir
 Volume in drive C has no label.
 Volume Serial Number is EC3F-A500

 Directory of C:\

27/07/2017  10:40              
  15 Adpass.txt
17/05/2013  17:26            19.033 icmpsh.exe
14/07/2009  05:20    <DIR>          PerfLogs
06/07/2017  14:04
    <DIR>          Program Files
14/07/2009  06:57    <DIR>          Program Files (x86)
06/07/2017  14:02    <DIR>          U
sers
21/07/2017  12:13    <DIR>          Windows
               2 File(s)         19.048 bytes
               5 Dir(s)  53.22
7.302.912 bytes free

C:\>














more Adpass.txt

more Adpass.txt
GhostInThePings

C:\>




















Y ahí podemos ver la flag: GhostInThePings

Espero os haya gustado, saludos y gracias por la visita!

Publicado en ctf, cybercamp, forense, writeups | Deja un comentario

Cybercamp 2017 Online – 04. Transfer with terrible consequences [400]

Y vamos a por el cuarto, si, ya no se me ocurren mejores introducciones jajaja Vamos con el enunciado:

We are in a complicated situation. The control of a critical infrastructure was impossible due to the loss of the access password. During the transfer of a worker’s position, a mishap occurred and some of the information has disappeared.

The worker, who wants to remain anonymous, kept each character of a hash in some sheets arranged in a filing cabinet. One character per sheet. During the transfer of his workplace, the sheets have been disordered and some information has disappeared.

Not everything, but some information characters from the hash could be retrieved: ‘50afXXXXXX6351475e54bf6eb2c96f2b’. Characters identified by “X” are hexadecimal values that have been lost.

The password was not complicated but we have minimum information. The worker barely remembers that the password was composed of eight alphanumeric characters. “In q, it ends in q!“ – He excitedly exclaimed. Finally, he remembered that of the eight characters, the first was a “q” and the last two were “oq”. He was asked about the type of used hash, but he shook his head. After holding his breath for a few seconds, he recognised that he was unable to remember the type of hash.

We need help in order to obtain the password and get control of the infrastructure. The solution must have the following format: password-hash

Esta vez no tenemos archivo ya que el enunciado nos da toda la información que necesitamos, en este caso debemos encontrar un hash, del cual no sabemos que tipo es y del cual conocemos parte; de una palabra de 8 caracteres de longitud que comienza por oq y termina por q.

Primero probamos rellenando los caracteres que faltan en el hash con ceros y se lo pasamos a hashid para ver que nos dice:

50af0000006351475e54bf6eb2c96f2b
Analyzing '50af0000006351475e54bf6eb2c96f2b'
[+] MD2 
[+] MD5 
[+] MD4 
[+] Double MD5 
[+] LM 
[+] RIPEMD-128 
[+] Haval-128 
[+] Tiger-128 
[+] Skein-256(128) 
[+] Skein-512(128) 
[+] Lotus Notes/Domino 5 
[+] Skype 
[+] Snefru-128 
[+] NTLM 
[+] Domain Cached Credentials 
[+] Domain Cached Credentials 2 
[+] DNSSEC(NSEC3) 
[+] RAdmin v2.x 

Parece que no hemos tenido mucha suerte con esto, tendremos que ir probando distintos hashes, en lugar de escribir un script que permutara por todos debido al gran número de posibilidades me decante por utilizar john, pero primero necesitamos una lista de todos los posibles hashes y las posibles palabras, para ello utilizamos el siguiente script:

import itertools
import string

def gen_hash_dict():
    alphabet='0123456789abcdef'
    d=[]
    for x in itertools.product(alphabet, repeat=6):
        h='50af'+''.join(x)+'6351475e54bf6eb2c96f2b'
        d.append(h+'\n')
    with open('hash_dict.txt', 'w') as f:
        f.writelines(d)

def gen_passwd_dict():
    alphabet=string.ascii_lowercase + string.digits
    d=[]
    for x in itertools.product(alphabet, repeat=5):
        p='q'+''.join(x)+'oq'
        d.append(p+'\n')
    with open('passwd_dict.txt', 'w') as f:
        f.writelines(d)

print('generating hash dict...')
gen_hash_dict()
print('generating passwd dict...')
gen_passwd_dict()
print('done!')

Como veis en la primera función limitamos los carácteres a los utilizados en hexadecimal ya que en el enunciado nos indican que estos son los utilizados en el hash; para las contraseñas utilizamos todos los caracteres alfanuméricos.

Una vez tenemos los dos archivos, vamos probando cada uno de los hashes que hashid nos ha dado, finalmente en la tercera tenemos suerte:

Este es el comando de john que finalmente nos dio la solución:

john --fork=4 --format=raw-md4 --wordlist=passwd_dict.txt hash_dict.txt

Ahora que ya tenemos la palabra veamos cual es su hash correspondiente utilizando una de las multiples tools online y obtenemos 50affc9dcf6351475e54bf6eb2c96f2b.

La flag finalmente es:

q5ib44oq-50affc9dcf6351475e54bf6eb2c96f2b

Espero os haya gustado, un saludo y gracias por la visita!

 

Publicado en cripto, ctf, cybercamp, writeups | Deja un comentario

Cybercamp 2017 Online – 03. Messenger Service [300]

Vamos con la tercera prueba de la fase online de la Cybercamp con el siguiente enunciado y link:

The Spanish law enforcement agencies have made a seizure in an operation against the embezzlement of public funds. They acquired evidences from different computers and mobile devices. They have made a physical acquisition on one of the android mobile devices. They need to identify the communications of the device through one of the most used messenger programs of the moment. Allegedly, this information could help them to obtain information and a profile of the investigated.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective3.raw

Esta vez nos dan una imágen raw de un dispositivo android en ext4 lo cual nos permite montarla facilmente con un simple comando (vamos a realizarlo como root para así evitar problema también de permisos en la imágen que montamos):

mount objective3.raw mount/

La primera carpeta que vamos a revisar es la de data ya que ahí también podremos ver las distintas aplicaciones que han sido instaladas en el dispositivo:

Ahí podemos ver varias cosas, como por ejemplo que parece tener cyanogenmod instalado jeje y entre lo más interesante dos aplicaciones de facebook, katana y orca; katana corresponde a la aplicación oficial de facebook mientras que orca es la de su messenger ¿Recordais el enunciado? Una aplicación de mensajería de las más usadas así que orca tiene toda la pinta de ser lo que estabamos buscando, vamos a ver que hay dentro:

Primero pense que la carpeta flags podía ser algo relacionado pero no contenía ningún archivo así que me fuí a la segunda opción, la carpeta databases:

Vemos que tenemos una gran cantidad de bases de datos sqlite (muy utilizadas en android) con sus correspondientes journals y uids.

Después de un buen rato revisando las bases de datos no encontré nada realmente interesante, entonces se me vino a la cabeza, si hay archivos journal, ¿puede que aún no se haya escrito a la db y esté ahí esperandonos?

La db que parecía contener los mensajes se llamaba threads_db2 así que decidí empezar por su journal, estos son archivos en texto plano así que podemos verlos con un simple cat o si preferís evitar susto por culpa de alguna codificación podéis utilizar strings:

La última linea parece prometedora, sobre todo el ME_GUSTAN_LOS_GATITOS, probamos a meter la flag y ¡Bingo!

Como veis en este caso la solución ha consistido en ir tirando poco a poco del hilo hasta llegar a la información deseada, no siempre son todo scripts super complejos ni cosas por el estilo jeje

Espero que os haya gustado, saludos!

Publicado en ctf, cybercamp, forense, Sin categoría, writeups | Deja un comentario

Cybercamp 2017 Online – 02. Keywords [200]

Seguimos con los writeups de la Cybercamp, vamos con el segundo enunciado y link:

Law enforcement has seized a computer with a Windows 7 operating system. This seizure is related to the illegal sale of stolen smartphones and the sale of the same through online platforms. Within the organization there is a keyword to communicate among the members of this organization. It is known that the user of the evidence of Windows 7 was always looking for this word in Windows in order to keep the communication with the other members. Find out this keyword.

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective2.aff

Esta vez nos dan archivo de imágen de disco en formato aff, utilizaremos la utilidad affconvert (en debian parte del paquete afflib-tools) para convertirla a formato raw y poder trabajar más facilmente con ella:

affconvert -r objective2.aff -o objective2.raw

Después de googlear un poco me encontré con que la información de las busquedas se guarda en el archivo NTUSER.DAT. Mientras buscaba copié la imágen a Windows y la cargue en Autopsy (no me gusta la versión para Linux) ya que así podría ver o extraer tanto los archivos como lo que pudiera necesitar, con tal mala suerte que justo el plugin para ver el registro esta desactualizado y no vale para la última versión 🙁

Pero bueno, ya sabemos donde está la información, así que nos aprovechamos de autopsy para extraer el archivo NTUSER.DAT, podéis hacerlo de varias maneras, no necesitais autopsy ya que consume muchos recursos y no es siempre demasiado rápido (yo por suerte lo tengo en un pc para juegos bastante potente).

Una vez tengáis el archivo NTUSER.DAT (sea como fuere que lo hubieseis sacado de la imágen) abrirlo con  un editor de registro, en mi caso he tirado del regedit Windows, si, raro yo usando Windows, pero ya que estaba en el pues seguí.

La clave del registro que encontré en google donde se guardan las búsquedas es la siguiente:

HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Word\WordWheelQuery

Al cargar este nuevo NTUSER.DAT en el regedit en mi caso la ruta se convirtió en:

Equipo\HKEY_USERS\test\Software\Microsoft\Windows\CurrentVersion\Explorer\WordWheelQuery

Vemos que hay una sola entrada con información la abrímos y nos encontramos la flag:

La flag finalmente es: EL YEPA-YEPA

Como veis esta prueba no ha sido nada super complejo que no tengamos que hacer a menudo, extraer un archivo de una imágen de disco duro y abrirlo con un programa que lo soporte para poder examinar sus contenidos y poder llegar a la información que previamente hemos buscado en google. En este caso hay que aplicar la misma regla que en un exámen leer bien el enunciado, yo perdí un tiempo valioso tirando strings a lo loco hasta que me di cuenta que ponía que el usuario había buscado la palabra en Windows y poder encontrar donde se guarda esa información, y una vez supe eso ya veis lo sencillo que ha sido.

Espero os haya gustado, un saludo y gracias por vuestra visita!

 

Publicado en ctf, cybercamp, forense, writeups | Deja un comentario

Cybercamp 2017 Online – 01. It is not Caesar [100]

Buenas, como lo prometido es deuda aquí os traigo la serie de writeups sobre la fase online de la Cybercamp 2017 de las pruebas que conseguí resolver, iré por el propio orden de las pruebas así que tener paciencia si esperáis por una en concreto.

Esto lo estoy escribiendo en diferido a la espera de que se publique la clasificación final que es cuando me han dado permiso para publicar los writeups, si tenéis suerte a lo mejor hasta están todos el mismo día jeje

Comencemos con la primera prueba, nos dan el siguiente enunciado y link:

A time traveler saved the following message: ESNTOTGCESLDUMOHIESLF:QACAIEOS

Could you help us to find out what his message was?

https://s3.eu-central-1.amazonaws.com/cyberrange/cyb_2017_quals/objective1.jpg

Como bien nos dice el título no es una cesar, el 6×5 nos hace pensar en un cifrado de transposición por columnas y probablemente la contraseña sea BLANCO; la columna quizás también sea un indicador de que sea un cifrado clásico y nada más complejo.

Buscando por google me encuentro con esta web: http://rumkin.com/tools/cipher/coltrans.php que nos ayuda a resolver el reto facilmente, seleccionamos decrypt, keyword y rellenamos los datos que conocemos:

Siento que el primer writeup sea tan corto pero es que la verdad es que la prueba tampoco daba para mucho más jeje pero no os preocupéis eso significa que tengo tiempo para hacer más.

Un saludo y gracias por vuestra visita!

Publicado en cripto, ctf, cybercamp, writeups | Deja un comentario