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

Así que aquí va una lista de los mejores plugins que te ayudarán tu tarea de pwning. Gracias a todos los que me habéis recomendable alguno de ellos.

• Hex-Rays:  Creo que este era evidente. Uno de los mayores atractivos de IDA Pro.
• IDAPython: para poder manejar IDA desde scripts en python
• Turbodiff: para comparar cambios en binarios, comunmente llamado diffing. Otras opciones con el mismo propósito con Darungrim, Patchdiff y BinDiff
• Adobe Flash Disassembler: el nombre habla por sí mismo
• IDADWARF: para importar símbolos DWARF de binarios ELF. Nos facilita así conocer nombres y tipos, arregla algunos tipos y renombra variables y registros para una comprensión más sencilla. Vamos la pareja perfecta con Hex-Rays cuando es un binario de este tipo.
• Findcrypt: útil para reconocer algoritmos de cifrado, funciones hash y algoritmos de compresión usados dentro del binario. Está claro que algunos son fácilmente reconocibles según las pasadas que den u otras características pero no esta nada mal ahorrarte un buen rato intentando descubrir qué algoritmo es. Este plugin intenta buscar constantes típicas usadas en los algoritmos, ya sea en las famosas S-Boxes, como inicialización u otros.
• IDAStealth: para poder evitar y manejar las técnicas anti-debug más comunes
• COM Helper: busca GUIDs
• mIDA: extra las interfaces RPC y reconstruye su IDL
• ms_rtti: información de los Run-time Type Information para binarios C++
• PDB: proporciona información extra sobre los símbolos en binarios de Windows.
• Importar infomación de MSDN: podéis ver como hacerlo en este post de Zynamics, quizá incluso agobiante tanta información pero útil si vas perdido.
• Class Informer: más de lo mismo, más información sobre vftables, RTTI y RTCI
• BinNavi: para visualizar la estructura de un programa, ver el camino que sigue una ejecución, ver como llegar a ciertos puntos del código, etc.
• MyNav: el hermano pequeño pero de código libre de BinNavi. Se publicará en julio, mientras podréis ver una muestra en este post. Promete mucho

Además, en breve tendremos hoy 3 de junio ha salido una suculenta nueva característica que será el soporte para decompilación para ARM, como se nota que esta arquitectura está creciendo mucho

Seguro que hay algun plugin que usas de normal y no está en esta lista así que espero vuestros comentarios.

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

Similar Posts:

• Reconociendo volúmenes Truecrypt
• Reto FBI Mayo 09
• [Campus Party 09] Las crónicas

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…

Port-Knocking

Cuando nosotros tenemos un servicio en un servidor, éste, escucha en uno o varios puertos las peticiones externas. Este puerto deberá estar abierto en el firewall para que se puedan efectuar estas conexiones. La idea del Port Knocking es que el puerto del servicio permanece cerrado y sólo se abrirá bajo una petición externa basada en un paquete o grupo de paquetes específicos, previamente conocidos por el cliente, que serán enviados al servidor. Es decir, yo tendría mi servidor ssh con el puerto 22 cerrado y cuando un cliente envíe un paquete con ciertas características a otro puerto entonces el puerto 22 se abriría temporalmente para ese cliente. De este modo permanecería escondido antes escaneos de puertos e intentos automatizados de fuerza bruta, por ejemplo. Este sistema se podría ir mejorando:

• que tenga que ser una secuencia de puertos y no uno sólo
• que además tengan que ser unos puertos de origen específicos
• combinarlo con otras herramientas: Portsentry, denyhost, fail2ban (destaco la primera herramienta  ya que es una forma fácil de banear intentos de escaneos sin el uso de un IDS completo ni cortafuegos)
• jugar con las FLAGs TCP y opciones poco comunes de los paquetes
• abrir el puerto sólo para la IP llamante, no todas
• <paranoic>requerir una temporización determinada (algo elástica, claro está) entre en el envío de los paquetes</paranoic>
• y mil cosas que se nos puedan ocurrir

Para estos menesteres existen varias herramientas pero todo suelen terminar siendo scripts que escuchan los puertos y van cambiando reglas del cortafuegos y los servicios. Pero no todo es bonito e ideal, imaginad que no tienes una puerta trasera, ¿qué ocurre si cae el servicio encargado de escuchar el portknocking? Te quedas tú sin poder acceder. Deberías dejarte una IP blanca por ejemplo, que siempre tuviera acceso al puerto sin mayor barrera. O tener otro servicio que compruebe si el primer servicio está online y haga de watchdog xD.

Pero ¿cuál es la debilidad clave un sistema así? Replay Attack. Me explico, si mi máquina está en una subred y otra máquina de esa subred ha sido comprometida, ésta podría estar usando un sniffer (tcpdump, wireshark) y capturar la secuencia usada para la apertura de puertos. Y aquí es donde entra lo que he venido a contar.

Crypt-Port-Knocking

Vamos a cortar por lo sano esa debilidad: Single Packet Authentication. Esta manera de proceder difiere en que vamos a llamar a un puerto aleatorio cada vez y la conexión con el servicio también se hará en un puerto aleatorio cada vez pero lo que es más importante añadiremos información cifrada en el paquete gracias a OpenSSL con lo que se quiera hacer (en este caso usando 256-bit AES-cbc, se podría mejorar para ultraparanoicos™  usando un cifrado asimétrico con GPG, por ejemplo). Podríamos pensar que para evitar ataques replay en la información cifrada se podría incluir datos variantes en el tiempo, cambios preacordados de la clave de cifrado, usar iteraciones en una función de hashing pero se complica el tema cuando hay muchos usuarios. Para ello, es mejor opción aprovechar que podemos tener 16bytes de datos aleatorios en el paquete que luego podemos identificar gracias a un hash del mismo e ignorar todos los paquetes duplicados. Para crear los paquetes a medida podremos usar hping.

Para hacer uso de las características del Single Packet Authentication el autor del post, BoneKracker, ha creado una serie de scripts en bash, formados por un cliente y un servidor de una forma bastante clara y transparente. Echadle un vistazo que ahí está todo el código y con una explicación más extensa.

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

Similar Posts:

• Dejar bonito un server SSH – Parte 1
• [Campus Party 08] Taller de antenas y charla sobre servidores
• Dejar bonito un server SSH – Parte 2

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

http://DOMAIN_NAME.TLD/wordpress/wp-login.php?action=rp&key=o7naCKN3OoeU2KJMMsag

Hasta aquí normal, de vez en cuando salen vulnerabilidades, además cuando recibes un correo (por ejemplo) con el link maloso te das cuenta de que hay gato encerrado.. pero ¿puede haber otros factores? Uhm, sí. ¿Qué tal los acortadores de direcciones? No se vería en principio a donde vas.

Por otro lado, hace un par de días actualicé Firefox a la versión 3.5.2 y esta mañana me he dado cuenta de que tiene activado un pre-fetch de links para navegar de un modo más rápido, es decir, precarga la primera búsqueda de google, precarga el siguiente post del blog que estás leyendo, etc. ¿Precarga un link malicioso que has recibido intentando explotar el bug anterior?

No me parece nada segura este tipo de navegación acelerada así que para desactivar esta opción se puede entrar en el about:config y desactivarla:

network.prefetch-next = false

Y ahora el mundo es un poquito mejor (de hecho ya han ido llegando correos maliciosos por algún sitio intentando explotarlo).

Sobre Wordpress, ó se actualiza a la versión 2.8.4 ó se cambia a mano el código vulnerable.

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

Similar Posts:

• Búsquedas curiosas – Volumen 2
• Explota al máximo tu IDA Pro: los mejores plugins
• Soluciones del reto de criptografía – Parte 2

Muchas gracias a todos los que acudísteis a pesar de ser el último día y ser por la mañana, que el sueño hace mella…

PDF:Sistemas de Detección de Intrusos CP2k9

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

Similar Posts:

• 1 año de It Should Work y más
• [Campus Party 09] Planning
• [Campus Party 09] Las crónicas