El Maligno me lió para dar una charla en el III Curso de Verano de Seguridad en Valencia. El curso ha estado genial, tanto las ponencias como la gente que acudió, sin duda una gran oportunidad para pasar un buen rato con conocidos y nuevas caras.

Mi charla la quise enfocar como una recopilación de fallos comunes (algunos de ellos famosos) cuando nos toca tratar con criptografía. Es un tema un poco denso así que para darle un toque más curioso y divertido en la parte final incluí puntos decisivos a la hora de implementar criptografía en dispositivos embebidos en los que, debido a factores como el side channel, tenemos que tener en cuenta todo tipo de nuevas medidas.

Gracias a Eloi y Bea por echarme una mano

Aquí os dejo la presentación de Historias de la cripta

Si tenéis dudas o preguntas podéis dejar comentarios aquí o usar twitter con el tag #cripta.

Keep hacking!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Cuando no se tiene cuidado con la criptografía…
• Conferencia sobre criptografía y reto
• [Fprint] Procesado de la imagen – Huellas dactilares

Hey there! I usually write in spanish here but as the attendance at Campus Party Europe was pretty international I’ll do this one in english so anyone can understand it.

All the information to try the challenge is at Eloi’s blog since he released it as challenge a couple of days ago. Before continuing I guess you either have played in the hacking contest at Campus Party Europe or already have read that post, if not… you are being late!

So, we receive 3 files: an AES encrypted file, a  public key file and a readme with some instruction and data.

From the readme, this are some hints to understand what’s going on here:

• It uses a cryptographic device that contains a 1024 bit modular exponentiation accelerator
• A pair of RSA signatures over the same data, one of these signatures contains a fault injection

From those hints we get that it is actually using the RSA-CRT algorithm, which is a RSA variation to reduce computational costs using the Chinese Remainder Theorem. The point is that instead of using the 2048 bit modular exponentation it splits them into two modular operations, aproximately half the size, make the calculations and then recombine the results as needed to obtain the regular RSA result. But here’s the trick, if we inject a fault in one of these two exponentiations, via power glitching for example, there’s a way to recover the private RSA key. The use of RSA-CRT is common in embedded devices such as smart cards, mainly because of the hardware limitations. You can read a post about it at Eloi’s blog, it’s in spanish though: RSA-CRT Fault Injection.

RSA signs a message doing:

• s = m^d (mod n)

RSA-CRT does:

• s1 = m^dq (mod q)
• s2 = m^dp (mod p)
• s = a*s1 + b*s2  (mod n) = m^d (mod n)
• a being congruent to one modulo p and zero modulo q
• b being congruent to zero modulo p and one modulo q

Using the faulty signatures:

• s – s’ = a*s1 – a*s1′ will be congruent to zero modulo q
• s – s’ = b*s2 – b*s2′ will not be congruent to zero modulo p

Then if we calculate the greatest common divisor (using the Euclidean algorithm for example) between c-c’ and n ¡we will obtain the factor q! because c-c’ is multiple of q but not p. Then with p = n / q we will have both prime factors used in RSA

Now we have to implement the attack, we need to deal with really big integers so I first though of using Java and its BigInteger, Matlab or Sage. I do hate Java, Matlab would have been nice, usually it treats big integers as arrays and uses proper algorithms adapted to array calculations but Sage was going to be the easiest and quickest for me.

We have s1, s2 and the encrypted message. First we need to obtain the exponent and the modulus from the public.key file, let’s use openssl:

$ openssl rsa -pubin -text -in public.key
Modulus (2048 bit):
00:e8:52:42:77:0a:66:69:8c:64:49:61:5a:d4:8f:
70:e5:ff:7f:49:ca:45:33:43:7d:85:36:7e:1a:f3:
8f:31:aa:35:94:8e:b3:3f:97:88:f7:16:4a:1d:d5:
c3:87:5b:f8:6b:69:3b:d8:cc:82:e2:cb:cb:d0:1c:
f7:d1:b4:51:ef:67:cb:72:90:fa:79:0e:e1:02:24:
e3:72:5b:37:b6:bc:3d:53:56:da:9d:0f:ba:c1:e0:
6b:b2:6f:f2:43:03:d9:06:d3:c9:66:c8:1b:19:9a:
78:b9:ef:02:2b:0f:b9:28:e5:82:fc:0c:e0:29:57:
f6:b1:64:21:01:f9:2e:83:4a:ab:47:24:9e:e4:08:
c2:91:d3:fc:e8:72:c1:44:69:12:31:37:f4:da:49:
28:00:75:03:36:47:20:69:f4:e2:4b:4a:0e:3e:e5:
15:85:ae:78:68:43:a3:c0:39:61:c2:12:a1:e3:94:
d2:71:e8:26:14:c4:e7:aa:1d:5d:a4:16:01:1f:9b:
40:81:a8:e4:70:65:75:1a:de:de:51:d0:90:97:fb:
8a:41:ac:be:2e:54:5c:b6:d4:04:40:1d:59:16:c3:
f6:86:16:e9:66:79:b3:5f:77:74:a9:e4:42:b1:98:
74:14:b0:22:ee:06:f0:0f:ac:3d:dd:b6:14:19:43:
e5:53
Exponent: 65537 (0x10001)
writing RSA key
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6FJCdwpmaYxkSWFa1I9w
5f9/ScpFM0N9hTZ+GvOPMao1lI6zP5eI9xZKHdXDh1v4a2k72MyC4svL0Bz30bRR
72fLcpD6eQ7hAiTjcls3trw9U1banQ+6weBrsm/yQwPZBtPJZsgbGZp4ue8CKw+5
KOWC/AzgKVf2sWQhAfkug0qrRySe5AjCkdP86HLBRGkSMTf02kkoAHUDNkcgafTi
S0oOPuUVha54aEOjwDlhwhKh45TScegmFMTnqh1dpBYBH5tAgajkcGV1Gt7eUdCQ
l/uKQay+LlRcttQEQB1ZFsP2hhbpZnmzX3d0qeRCsZh0FLAi7gbwD6w93bYUGUPl
UwIDAQAB
-----END PUBLIC KEY-----

To copy the modulus it’s easier from here:

$ openssl rsa -pubin -modulus -in public.key
Modulus=E85242770A66698C6449615AD48F70E5FF7F49CA4533437D85367E1AF38F31AA35948EB33F9788F7164A1DD5C3875BF86B693BD8CC82E2CBCBD01CF7D1B451EF67CB7290FA790EE10224E3725B37B6BC3D5356DA9D0FBAC1E06BB26FF24303D906D3C966C81B199A78B9EF022B0FB928E582FC0CE02957F6B1642101F92E834AAB47249EE408C291D3FCE872C14469123137F4DA492800750336472069F4E24B4A0E3EE51585AE786843A3C03961C212A1E394D271E82614C4E7AA1D5DA416011F9B4081A8E47065751ADEDE51D09097FB8A41ACBE2E545CB6D404401D5916C3F68616E96679B35F7774A9E442B1987414B022EE06F00FAC3DDDB6141943E553
writing RSA key
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6FJCdwpmaYxkSWFa1I9w
5f9/ScpFM0N9hTZ+GvOPMao1lI6zP5eI9xZKHdXDh1v4a2k72MyC4svL0Bz30bRR
72fLcpD6eQ7hAiTjcls3trw9U1banQ+6weBrsm/yQwPZBtPJZsgbGZp4ue8CKw+5
KOWC/AzgKVf2sWQhAfkug0qrRySe5AjCkdP86HLBRGkSMTf02kkoAHUDNkcgafTi
S0oOPuUVha54aEOjwDlhwhKh45TScegmFMTnqh1dpBYBH5tAgajkcGV1Gt7eUdCQ
l/uKQay+LlRcttQEQB1ZFsP2hhbpZnmzX3d0qeRCsZh0FLAi7gbwD6w93bYUGUPl
UwIDAQAB
-----END PUBLIC KEY-----

Now we have the modulus and exponent. So let’s start Sage and apply what we’ve seen before

Load the values:

sage: s1 = 0x3ae81964c8ecf1524b47c42cb0ecd2a3b6768dccd55960d7ff0a998f839b8c312a2cd821c270ae961777dd4dd50aa631fe823a8afd914911adf69c1c6cfda3b3aed01dad372cfdd6e9f63a4cc39e1a455cbfd04dea72bf07c4790d5fec469198ce28113d6d38a7baced9d3c3695ab27cbc5ab434aa8d2b5f53f66a383e079ddaed485d4a2b446e410eafcadbba9f159494c28c4a19fd416dff90f8c141e96d8260f8e6e0901832e31899c48ce0cbdae6a24595a19a01e490c87e7b48860e09006920d8ef7384217358c6db90638d6e8cbc795a091240f24105d8f3b27fe4b98fe9a507e00590b4cded41777b1b8967b0f752231e0e856b8f0132bde30a6e082e
sage: s2 = 0x391e0340e5931a202012572ddacad877e5af3a1d846b70c1e64e3041f9ac0a3c7e8f82621df908eadca44fe777a6b1c799610be829e13ca233982fd268034addb5a79fa19f984631fdf3a61d32fc75ed77176c7a0b719504e804076dca66f10111aa124a7efe743ada75dda2ec53f3c28882a7724928685918261739f960a3648aa3eadc426181aa146a8ba0ff20f1c53de2113e0196af09595dc2ad1a0fe12096ff681f61363044615a7f72edf1f8c6531055e66c1e5f4498434c731d2308fecae46c779379ea3d7d7a5f1c2a0efeb5bc1b8a4af4fb21fce1dae943c27043e86642b3b1e6b889a31e7c4bc01bc2ebae4dc8432344532567d1d3df8b9bcafcbf
sage: encrypted = 0x19303a82cbc50a56dc22f9aafc554da2ea632e33bee1d33c35edb13269ba0fd2fa791744e86eda7fc1cb15433f1232f86a42afcd5470215ccf0d05096ce1b8f075e6dc45df74896345297fcc145a4765aeaea78babaa6441ead3a2e73b37931dc7c07d4e04b7115284c7c04c85a61c7e555194d0f4ee762d47a8aeec2efcd75ee45e3e6a65f876f9a67aa01016f3ce9552d8f0b50cc150c70333aa6ac3a4ac8860d2879cad8439566f0ffda32612cb75dd9c1b456a4e1828582f05932f495452f19d71f300f2f48b8c1f8cde1b1b8d8ada3f6ff506e10d5d18d91d61402bc36756a88196381ff795980eee932a179525264e3a968f0abe9edbe672560c41833a
sage: exponent = 0x10001
sage: modulus = 0xe85242770a66698c6449615ad48f70e5ff7f49ca4533437d85367e1af38f31aa35948eb33f9788f7164a1dd5c3875bf86b693bd8cc82e2cbcbd01cf7d1b451ef67cb7290fa790ee10224e3725b37b6bc3d5356da9d0fbac1e06bb26ff24303d906d3c966c81b199a78b9ef022b0fb928e582fc0ce02957f6b1642101f92e834aab47249ee408c291d3fce872c14469123137f4da492800750336472069f4e24b4a0e3ee51585ae786843a3c03961c212a1e394d271e82614c4e7aa1d5da416011f9b4081a8e47065751adede51d09097fb8a41acbe2e545cb6d404401d5916c3f68616e96679b35f7774a9e442b1987414b022ee06f00fac3dddb6141943e553

Calculate q and p:

sage: q = gcd(s1-s2,modulus)
sage: p = modulus / q

In Sage to work with modular arithmetics you need to declare a group and then use the variables in that group. First let’s calculate the private RSA key

sage: G1 = IntegerModRing(lcm(q-1,p-1))
sage: private_key = G1(exponent)^-1

And finally working in modulo ‘modulus’ make the decryption to get the message:

sage: G2 = IntegerModRing(modulus)
sage: message = G2(encrypted)^G2(private_key)
sage: message
333277202522695828352578908493424296965
sage: hex(333277202522695828352578908493424296965)
'fabadababecafedeadbeef0102030405'

It’s a fabada password! xD We now have the plaintext which is the AES key. Let’s use again openssl to decipher the file. The readme file says it’s AES in ECB mode with a 128 bit key. The key length it’s obvious but if we didn’t know the operation mode we could just try them all.

$ openssl enc -d -aes-128-ecb -in encrypted.aes -out unencrypted.file -K fabadababecafedeadbeef0102030405
$ file unencrypted.file
unencrypted.file: PNG image, 124 x 124, 8-bit/color RGB, non-interlaced

We can see that it worked like a charm: the file it’s a PNG image. The first thing you think when you see a PNG it’s uhmm… a bit of stego? thumbnails? LSB? Well, this one is just a QR Code.

Using any QR decoder (I used http://zxing.org/w/decode.jspx ) we get:

Key: DoubleCheckYourCryptoResults

Which is a funny final password since one of the common protections against fault injection attacks is to double-check all sensitive computations

Congratulations to Eloi for this challenge! I found it one of best I’ve ever done because it has to do with real world attacks and crypto related maths, so it’s not just another cryptic puzzle where mostly you only have to use tools or need a smart guess.

I hope you liked it!

Many thanks also to SecurityByDefault for an excelent wargame and congratulations to the winners:

1. knx
2. FluxReiners
3. aw3a

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Reto FBI Mayo 09
• Descifrando un reto del FBI
• Crackeador de hashes MD5 en C y OpenSSL

Más vale tarde que nunca, varias semanas después encuentro un rato para poder escribir este post. El cansancio acumulado hizo que gran parte de la semana siguiente fuera a medio gas y desde entonces he ido hasta arriba de cosas.

¿Qué puedo decir? Sin duda ha sido una gran experiencia, de una vez por todas, poder poner caras a tanta que gente que sólo puedes tratar por e-mail, IRC, foros, twitter o simplemente ni le tratabas y te conformabas con seguirle por internet. Coges a toda esa gente y durante 3 días compartes comidas, cenas y cervezas. Impresionante. Han sido unos días repletos de buen rollo y diversión.

Para la organización mis más sinceras felicitaciones,yo creo que han sacado nota alta y más siendo su primera vez, errores por supuesto que han habido pero como todos sabemos que habrá Rooted CON 2011… no pasa nada, al año que viene más y mejor

Cómo ya sabréis, Eloi y yo fuimos seleccionados con una ponencia sobre Seguridad y Explotación Nativa en Android que parece que gustó bastante, así que no me puedo sentir más orgulloso y realizado. Gracias a todos los estuvísteis ahí a primera hora el último día, como unos campeones. Si alguien se la perdió que no se preocupe porque la presentación os la enlazo ahora y, como ya prometimos en su momento, para descargar también todo el código y ejemplos:

• Seguridad y Explotación Nativa en Android

• Ejemplos y código

En el comprimido podréis encontrar los payloads y los scripts para cada tipo de exploit para metasploit, así como el código del micro-rootkit secuestrador del teclado virtual. De todas formas, en el blog de Eloi (eso sí, en inglés) podréis encontrar más información acerca de ello.

Por ahora casi sólo hemos tenido feedback positivo pero desde aquí os animo a hacernos llegar críticas constructivas, para poder mejorar.

Unas fotillos:

SecurityByDefault cubrió el evento así que podréis encontrar cosillas día a día en su web.

Creo que había ponentes muy muy buenos con charlas que no estaban a la altura de ellos mismos y viceversa, ideas buenas pero que no pudieron llegar al público de la mejor manera. Las que más me gustaron fueron (sin orden en particular):

• Autopsia de una intrusión. A la sombra del chacal, por Pedro Sánchez y Eduardo Abril
• Operación Triunfo Profesional, por Alejandro Ramos.
• Liberando un 0day en la Rooted CON, por Rubén Santamarta.
• Hackproofing Oracle Finantials 11i & R12, por Joxean Koret.
• RootedPanel “Hackers Históricos” con Grupo Apòstols, con Jordi Murgó (savage) y Ramón Martínez (rampa)
• New w32 hooking skills por David Regrera
• Hackers, encerrados en la viñeta por David López López
• iPhone + Botnets = FUN por David Barroso.
• Exploits y mitigaciones: EMET por Fermín J. Serna.

Impresionante también todo el trabajo detrás de Radare2, desarrollado por Sergi Álvarez y Roi Martín. Una de las charlas que me perdí y, que según dicen gustó mucho, fue la de Antonio Ramos, La seguridad como sistema. Factores limitantes y evolución en el tiempo, una pena. Todas las presentaciones se han subido a slideshare.

Por un lado penosa actuación de cierta empresa, además ¿no conocen El Efecto Streisand?

Por otro lado…pobres las azafatas!! se morían un poco de asco xD, bueno de vez en cuando se les escapaban alguna risa. En algún momento que me crucé con una le pregunté ¿no estás harta? a lo cual se le escapó un sincero y directo sí, 2 segundos más tarde se corrigió a sí misma para mantener la compostura: “ay, bueno no, quería decir, ehm, a ver, en realidad no está mal [sonrisa comprometida] he estado en congresos peores”

Eloi y yo decidimos que tocaba atender a las charlas cosa que era totalmente incompatible con el CTF, aún así Amín y Vicent le dedicaron unas cuantas horas, el pobre Amín se quedó a una prueba de quedar tercero y Dani Kachakil consiguió un merecido segundo puesto. Ahora mismo, Dani está en Korea compitiendo junto con los Intr3pids para darles cera a todos en el Codegate 2010.

Fue una lástima que no tuvieramos acceso a internet decente, yo no tenía 3G así que tenía que aprovechar los 30 minutos gratis que me daban en el hotel para revisarme el correo y el twitter. La noche del sábado, ya sin presiones, pudimos disfrutar de una fiesta todos juntos, cosa que se alargó hasta el amanecer sentados con cervezas.

Podréis encontrar otras reseñas del congreso aquí y fotos en el perfil de Flickr. En cuanto estén disponibles todos los videos ya actualizaré.

Lo que tengo muy claro es que acudiré a la Rooted CON 2011, ¡a poder ser como ponente de nuevo! Bueno xD eso será si me dejan o, más difícil aún, si me surge alguna idea buena. Por mi parte ha sido un honor, eso es todo hamijos!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Congreso de Seguridad Rooted CON 2010
• [Campus Party 09] Planning
• Ganadores del reto de criptografía

Cómo se puede leer ya en muchos sitios, este año se celebra un nuevo congreso de seguridad informática en España. Su web es http://www.rootedcon.es y como ellos mismos dicen su objetivo es ofrecer conferencias altamente técnicas y fomentar el conocimiento, no bastante con conocer que existen cosas, hay que saber cómo son y por qué funcionan así

Se va a organizar un wargame tipo Capture The Flag a manos de un Sexy Panda, ¿qué más se puede tener? Además hay una serie de talleres intensivos denominados RootedLabs donde podrás aprender con los mejores sobre: ingeniería inversa, análisis forense, análisis de malware, pentesting, securización de redes inalámbricas y seguridad web (aún quedan plazas libres en los labs si te interesa algún área).

Allá por noviembre me enteré de la existencia el congreso y desde un principio me interesó acudir, pero ¿por qué no algo más? Hablando con TuXeD nos planteamos la posibilidad de enviar algo al Call For Papers, estuvimos unas cuantas semanas dudando pero tiró para adelante…

Unas semanas después (contra todo pronóstico, por lo menos mío) resulta que nos han seleccionado la propuesta, además junto con los primeros ponentes confirmados, cosa que considero un honor más aún. Ya de por sí, ser el último mono iba a ser considerado un éxito 100% por nuestra parte.

Para que os hagáis una idea del personal, esto es lo que hay confirmado por ahora:
http://www.rootedcon.es/rooted-con-2010/ponentes.html

– David Barroso, de S21Sec
- Joxean Koret, de 48bits & Panda Security
- Alfonso Muñoz Muñoz, de la EUI-UPM y colaborador cátedra Applus-UPM.
- Alejandro Ramos “dab”, de SecurityByDefault.
- Antonio Ramos, de S21Sec.
- David Reguera, de Hispasec Sistemas.
- Rubén Santamarta, de ReverseMode & 48bits.
- Chema Alonso, de Informática64

Y TuXeD y yo! No puedo ocultar que estoy emocionado me lo voy a pasar de lo lindo seguro.

Poco a poco se tienen que ir confirmando más ponentes y saldrán los detalles de la conferencias. Esto promete.

Si queréis acudir al evento daos prisa porque debido a la gran acogida pronto colgarán el cartel de todo vendido. Me alegro de que haya surgido una nueva iniciativa así y más aún con precios populares y apostando por gente muy capaz que hay por nuestro país.

Por la mocosfera mucha gente ya se ha hecho eco del evento:
http://www.securitybydefault.com/search/label/rootedcon

Y aquí entrevistas a gente que lo organiza o va a estar danzando por ahí:
http://elladodelmal.blogspot.com/search/label/Entrevistas

Can’t wait!

ACTUALIZACIÓN: Ya empiezan a salir más nombres de ponentes y títulos de las conferencias. Toda la información aquí

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Rooted CON 2010 – All your base are belong to us
• 25C3: Nothing to Hide
• Cuando no se tiene cuidado con la criptografía…

Jaime tenía sus charlas de PHP a las 10 y eso es primerísima hora en la campus, que digo! es una hora inaceptable en la campus! Intentamos llegar a tiempo para poder apoyarle pero durmiendo fuera y acostándonos tarde (más bien cerca del amanecer) era complicado estar antes de las 11. Además se nos juntaba con el suplicio de aparcar y llegar andando desde donde cristo perdió la cruz, al año que viene nos cogemos parking. Este año estuvo a buen precio (no como años anteriores) pero se nos pasó el momento o no nos lo planteamos lo suficiente. El catering a mí me pareció peor que otros años, era otra empresa y encima la CP no dió paella para todos gratis el miércoles como venía siendo tradición… ratas.

A diferencia de otros años, que ya el domingo disponíamos de las acreditaciones y incluso alguna vez teníamos la tienda puesta de antes, esta vez llegábamos de viaje por la tarde y no fue hasta la noche cuando estuvimos acomodados en el puesto. Así cerquita estábamos kuasar, Jaime, Mageles, TuXeD (a partir del jueves), phobeo, Ernesto (encantado de conocerte!), Laura, Ender, akae y unos cuantos más, justo en el medio de la zona de innovación. Repartidos por el resto de la campus estaban muchos más conocidos pero no terminaría nombrándolos, bueno va, a Flexa sí, que se hizo una camiseta super molona con TOOOOODOS nuestros nicks . Sigue leyendo!

Hoy no os traigo un diario detallado, no hay ganas de escribir tanto y además seguro que aburriría, que con el viaje por el Bosnia y Croacia os dejé un misal, por lo menos! El año pasado sí fue un poco más extenso: Campus Party 08 Parte 1 y Campus Party 08 Parte 2

TuXeD dió su charla sobre Smartcards y Side Channel el jueves por la mañana y yo la mía el sábado sobre Sistemas de Detección de Intrusos. Hubo cosas interesantes, hasta vino Jose de Castro a tocar! Este año han subido a youtube bastantes videos con talleres y ponencias.

Un año más hubo concurso de seguridad, esta vez organizado por SecurityByDefault, a los cuales fue un placer conocer en persona. El año pasado participamos TuXeD, Amine y yo juntos y lo ganamos así que este año nos pusimos manos a la obra de nuevo. TuXeD no pudo mirarse nada hasta bien entrado el jueves y el pobre Amín trabajaba en el restaurante de sus padres  (el cual recomiendo) todos los días full-time así que no tenía más remedio conectarse desde el ordenador del restaurante por vnc a su casa y mirarse las cosillas entre que servía un plato y otro xDDD En fin, menudo plan, aún así el equipo funcionó a la perfección y nos pudimos hacer de nuevo con el primer puesto después de mucho empeño Enhorabuena chicos!

El concurso estaba divido en 4 categorías: redes, web, binarios y cripto, para cubrir pruebas de todo tipo. El concurso me gustó mucho, con más nivel que otros años pero… siempre hay un pero jeje, había demasiado fuerza bruta/suerte. Si acertabas a la primera pan comido si no… 2 días perdidos, fue el “fallo/feature” más criticado por los participantes.

Hubo pruebas de todo tipo, algunas muy originales. Por ejemplo, en redes había obtener que orden de nmap había sido ejecutada viendo una captura o crackear la sharedKey del handshake en una autenticación RADIUS, esta prueba me gustó mucho ya que no existía/teníamos herramienta para hacerlo así que hubo que tirar del RFC y programarse un crackeador (en C). En cripto hubo que crackear un certificado pkcs12 y unos mensajes de twitter en cifrados RC4, en binarios en una había que modificar el comportamiento del programa gracias a un LD_PRELOAD y en otra era un buffer overflow en el cual había que volver a los inicios con el señor Aleph One. En una de las pruebas de web una herramienta de Dani Kachakil (nuestro chico maravillas) nos solventó la papeleta y la web4 fue la única prueba que nos quedó por resolver porque nos quedamos atascado en un detalle… no acertar el nombre de un fichero php! Había que saltarse la directiva LIMIT de un apache y luego era un Blind SQL. Lástima. Las últimas horas del concurso fueron muy estresantes,  la noche del viernes Skull y Dade se había puesto manos a la obra hasta el amanecer y se posicionaron segundos, ellos había resuelto la web4 que valía más puntos que la cripto3 así que si resolvían una prueba más nos adelantaban. Estaban a puntito a puntito de obtener la solución de la cripto4 con la que nos adelantaban pero a falta de 15minutos pudimos sacarla nosotros y nos alejamos Maldito LSB! Probamos decenas de herramientas! Joca y cucaracha estuvieron muy muy fuertes en la competición así que felicidades a ellos también.

No me he extendido mucho en las pruebas del wargame pero la gente de SecurityByDefault se han currado unos posts con las soluciones por categorías: Redes, Web, Cripto y Binarios.

Ricardo y Ernesto participaron en un par de competiciones y se las llevaron al agua las 2, si es que están hechos unos crás. Luego Ricardo confesó que había amenazado a los contrincantes para que huyeran despavoridos.

La última noche la pasamos de buen rollo en los jardines de al lado de la CAC, como tiene que ser, tirados en el césped y con spirits!

Os pondría más fotos y más decentes pero no tenía cámara así que sólo tengo las que salen por el flickr de la campus xDD

Otro año más, a poder ser mejor.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• [Campus Party 08] Diario de a bordo – Parte 2
• En Berlin!
• [Campus Party 09] Planning

Primero de todo vamos a hacer un programa que nos permita calcular el hash md5 de un string que se le pase y luego ya pasaremos al crackeador.

Sería más fácil hacer un script en bash o perl gracias a la utilidad CLI de OpenSSL, a la hora de calcular un solo hash no importa mucho la velocidad pero si luego queremos hacer un pequeño crackeador no podemos partir de algo que ya sabemos que va a ser mucho más lento. Así que lo que vamos a usar es C y la librería de OpenSSL.

Si no sabemos por donde empezar un extracto del man:

$ man md5
...
SYNOPSIS
 
#include <openssl/md2.h>
 
        unsigned char *MD5(const unsigned char *d, unsigned long n,
                         unsigned char *md);
 
        int MD5_Init(MD5_CTX *c);
        int MD5_Update(MD5_CTX *c, const void *data,
                         unsigned long len);
        int MD5_Final(unsigned char *md, MD5_CTX *c);
...
DESCRIPTION
...
Applications should use the higher level functions EVP_DigestInit(3) etc. instead of calling the hash functions directly.
...

Vemos que podríamos añadir esa librería y usar las funciones MD5_Init(), MD5_Update y MD5_Final pero ya nos avisan que deberíamos usar unas funciones de más alto nivel así que: EVP_DigestInit

$ man EVP_DigestInit
...
SYNOPSIS
        #include <openssl/evp.h>
 
        void EVP_MD_CTX_init(EVP_MD_CTX *ctx);
        EVP_MD_CTX *EVP_MD_CTX_create(void);
 
        int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
        int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
        int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
               unsigned int *s);

De paso, aprovecho para desaconsejar el uso de MD5 a día de hoy y como mínimo usar SHA1 o incluso dejarte de monsergas y pasar a SHA256, SHA512.

He intentado que el programa sea bastante fácil de entender y seguir, ahí va:

#include <stdio.h>
#include <string.h>
 
#include <openssl/evp.h>
 
#ifdef DEBUG
#define DBG 1
#else
#define DBG 0
#endif
 
#define MAX_SIZE_WORD 200
 
unsigned char *simple_digest(char *algth, char *buffer, unsigned int len, int *olen){
 
	EVP_MD *m;
	EVP_MD_CTX ctx;
	unsigned char *ret;
 
	OpenSSL_add_all_digests ();
	if (!(m = (EVP_MD*) EVP_get_digestbyname(algth)))
		return NULL;
 
	if (!(ret = (unsigned char *) malloc(EVP_MAX_MD_SIZE)))
		return NULL;
 
	EVP_DigestInit(&ctx, m);
	EVP_DigestUpdate(&ctx, buffer, len);
	EVP_DigestFinal(&ctx, ret, olen);
 
	return ret;
}
 
void hex_print(unsigned char *buff,int len){
	int i;
	for(i=0;i<len;i++)
		printf("%02x",(unsigned char)(buff[i]&0xFF));	
}
 
int main(int argc, char **argv){
 
	unsigned char buff[MAX_SIZE_WORD];
	int olen;
	char *out;
 
	if(!argv[1]) {
	        printf("Usage: mymd5 word\n");
        	exit(1);
	}
 
	// copy arg string into a buffer
	if (strlen(argv[1]) < MAX_SIZE_WORD ){
 
		strncpy(buff, argv[1], strlen(argv[1]));
 
		// calculate string's md5 hash
		out = simple_digest("md5",buff,strlen(argv[1]),&olen);
 
		// print results	
		if (DBG){
			printf("Word: %s\n",argv[1]);
			printf("Hash: ");
		}
		hex_print(out,olen);
		printf("\n");
 
		return 0;
	}
 
	printf("\nNot computing hash\n");
	printf("\nI can feel your dark side... ;)\n");
 
	return -1;
}

Compilamos y probamos:

$ gcc mymd5.c -o mymd5 -l ssl
$ ./mymd5 passworddeelite
5b4f50aa173b977e4cd0850cf7c52bd0

Podemos comprobar su correcto funcionamiento comparando con webs online que ofrecen utilidades para calcular hashes MD5 [1], [2].

Y ahora a por el crackeador. No vamos a intentar buscar colisiones sino a partir de un diccionario sacar la clave. Le pasaremos como parámetros un fichero con el hash y un diccionario con una palabra por línea.

#include <stdio.h>
#include <string.h>
 
#include <openssl/evp.h>
 
#ifdef DEBUG
#define DBG 1
#else
#define DBG 0
#endif
 
#define MAX_SIZE_BUFF 200
 
unsigned char *simple_digest(char *algth, char *buffer, unsigned int len, int *olen){
 
	EVP_MD *m;
	EVP_MD_CTX ctx;
	unsigned char *ret;
 
	OpenSSL_add_all_digests ();
	if (!(m = (EVP_MD*) EVP_get_digestbyname(algth)))
		return NULL;
 
	if (!(ret = (unsigned char *) malloc(EVP_MAX_MD_SIZE)))
		return NULL;
 
	EVP_DigestInit(&ctx, m);
	EVP_DigestUpdate(&ctx, buffer, len);
	EVP_DigestFinal(&ctx, ret, olen);
 
	return ret;
}
 
void hex_print(unsigned char *buff,int len){
	int i;
	for(i=0;i<len;i++)
		printf("%02x",(unsigned char)(buff[i]&0xFF));	
}
 
void strtohex(unsigned char *in, unsigned char *out,int len){
	int i;
	char tmp[3];
	tmp[2]=0;
	for(i=0;i<len/2;i++){
		tmp[0]=in[2*i];
		tmp[1]=in[2*i+1];
		out[i]=strtol(tmp,NULL,16);
	}
}
 
int main(int argc, char **argv){
 
	int tries=0;
	unsigned char buff_words[MAX_SIZE_BUFF];
	unsigned char hash[16];
	unsigned char *line=NULL;
	int len=100,read;
	int olen;
	char *out;
 
	if(argc<3) {
	        printf("Usage: mymd5crack /path/to/hashfile /path/to/dictfile\n");
        	exit(1);
	}
 
	FILE *hashfile;
	hashfile = fopen(argv[1],"r");
	if(!hashfile){
		perror(argv[1]);
	return -1;
	}
 
 
	FILE *dictfile;
	dictfile = fopen(argv[2],"r");
	if(!dictfile){
		perror(argv[2]);
	return -1;
	}
 
	read = getline(&line, &len, hashfile);
	if(strlen(line)!=33){
		fprintf(stderr,"ERROR: Invalid hash length %d\n",strlen(line));
		return -1;
	}	
 
	strtohex(line,hash,32);
 
	if(DBG){
			printf("Input hash: %s\n", line);
			printf("Input buffer from hash: ");
			hex_print(hash,16);
			printf("\n\n");
	}
 
	//Read words in a loop
	while((read = getline(&line, &len, dictfile)) != -1){
		if( strlen(line) < 200){
			tries++;	
 
			//Copy word into buffer
			strcpy(buff_words,line);
 
			if(DBG)
				printf("Input buffer from dict: %s \n",buff_words);
			// compute md5
			out = simple_digest("md5",buff_words,strlen(line)-1,&olen);
 
			if(DBG){	
				printf("For password %s MD5 is: ",line);
				hex_print(out,olen);
				printf("\n\n");	
			}
 
			//Compare computed md5 with hash
			if(memcmp(out,hash,16) == 0){
 
				printf("PASSWORD FOUND!! in %d tries: %s\n",tries,line);
 
				fclose(hashfile);
				fclose(dictfile);
				free(out);
				if(line)
					free(line);
 
				return 0;	
			}
			free(out);
		}else{
			printf("\nWords from dict too long... cough*, cough*...\n");
		}
	}
 
	printf("Password not found in %d tries!\n",tries);
 
	if(line)
		free(line);
 
	fclose(hashfile);
	fclose(dictfile);
 
	return 0;
}

Y comprobamos su funcionamiento metiendo en /tmp/hash el hash obtenido anteriormente:

$ gcc mymd5cracker.c -o mymd5cracker -l ssl
$ ./mymd5cracker /tmp/hash /tmp/dict
PASSWORD FOUND!! in 6 tries: passworddeelite

Premio! Podéis ir en paz.

Para descargar mymd5.c y mymd5cracker.c

Gracias a TuXeD que siempre está ahí para echar una mano.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Descifrando un reto del FBI
• El kernel de linux en profundidad
• Soluciones del reto de criptografía – Parte 2

Os pongo una lista de conferencias que más me llaman del Fahrplan que hay:

- Solar-powering your Geek Gear: Alternative and mobile power for your all you little toys.

- FAIFA: A first open source PLC tool: PowerLineCommunication has now their open source tool.

- Security Failures in Smart Card Payment Systems: Tampering the Tamper-Proof. Esta para TuXeD

- Chip Reverse Engineering

- Cracking the MSP430 BSL

- Advanced memory forensics: The Cold Boot Attacks: Recovering keys and other secrets after power off.

- Locating Mobile Phones using SS7

- coreboot: Beyond The Final Frontier: Open source BIOS replacement with a radical approach to boot.

- Messing Around with Garage Doors: Breaking Remote Keyless Entry Systems with Power Analysis.

- Algorithmic Music in a Box: Doing music with microcontrollers.

- Anatomy of smartphone hardware: Dissecting contemporary cellphone hardware.

- Scalable Swarm Robotics: Formica: a cheap, open research platform.

- Console Hacking 2008: Wii Fail: Is implementation the enemy of design? Que gran pregunta.

- The Ultimate Commodore 64 Talk: Everything about the C64 in 64 Minutes. Brutal, enlace a su blog http://www.pagetable.com/?p=53

- Predictable RNG in the vulnerable Debian OpenSSL package: the What and the How. Aunque ya esté muy visto… para echarse unas risas.

Me ha llamado la atención lo que han denominado como Lightning Talks, rondas de 10 presentaciones de 4 minutos donde puedes exponer tu idea más descabellada, presentar tu proyecto, enseñar un cacho de hardware que te emocione, etc y así ganar adeptos para colaborar o simplemente echarte unas risas.

Y por supuesto, además de todo lo anterior, workshops sobre microcontroladores, el quadrocopter, etc.

En fin, otro año será, siempre me quedará youtube.com para ver las charlas.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• [HOW TO] Cómo recuperar GRUB
• Búsquedas curiosas – Volumen 1
• Va de pre-fetching, Wordpress y links malintencionados