por ·1 comentario

Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar una serie de crackmes. Los dos primeros pasaron algo desapercibidos, pero el Crackme nº3 tuvo una gran repercusión en el mundillo y, aunque no fue el primer crackme para Android ni mucho menos, si que fue uno de los más estudiados. Todos ellos fueron publicados a través de crackmes.de y el nº3 en cuestión el 6 de Noviembre de 2010. Os dejo una lista de unas cuantas webs donde aparece analizado para que veáis la repercusión que a mi parecer tuvo.

Soluciones al crackme

Referencias al crackme

Links

Del Hacking a la IA: Cómo Expediente X Abordó la Tecnología de Vanguardia
La serie "Expediente X" (The X-Files) ha capturado la imaginación de los espectadores desde su debut en 1993, con sus
Stego XVI - Bytes
Intro Os comparto un reto stego que me gustó cuando lo hice hace unos años. En realidad se tarda pocos
Solución a los retos criptográficos de Rogerfm.net
Introducción Cripto 1 Cripto 2 Cripto 3 Cripto 4 Cripto 5 Cripto 6 Cripto 7 Cripto 8 Cripto 9 Cripto 10
Cruehead's Crackme 3.0 Keygen [3/3]
Introducción Esta es la tercera y última entrega de los crackmes de Cruehead. En esta ocasión nos enfrentamos a un

por ·Sin comentarios

La serie «Expediente X» (The X-Files) ha capturado la imaginación de los espectadores desde su debut en 1993, con sus intrigantes historias de fenómenos paranormales y conspiraciones gubernamentales. Sin embargo, más allá de los extraterrestres y las criaturas sobrenaturales, la serie también exploró el mundo del hacking, la inteligencia artificial y la piratería informática, temas que se adelantaron a su tiempo y que siguen siendo relevantes hoy en día. A continuación, exploramos algunos de los episodios más emblemáticos que abordan estos temas, revelando detalles fascinantes, curiosidades y tomas falsas que los hicieron memorables.

«Ghost in the Machine» (Temporada 1, Episodio 7)

En este episodio, Mulder y Scully investigan un asesinato en una empresa de tecnología avanzada, Eurisko, donde un sistema de inteligencia artificial llamado «COS» (Central Operating System) podría ser el responsable. La trama se centra en las posibles implicaciones de las IA descontroladas y las vulnerabilidades tecnológicas.

Curiosidades:

  • Este episodio fue uno de los primeros en abordar el tema de la inteligencia artificial en la televisión.
  • El nombre «COS» es una referencia al sistema operativo OS/2 de IBM, que estaba en uso en la época.

Tomas falsas:

  • Durante una de las escenas de acción, el actor encargado de operar el COS tuvo dificultades para mantener la seriedad debido a los efectos especiales rudimentarios, resultando en varias tomas falsas.

«Kill Switch» (Temporada 5, Episodio 11)

Escrito por los renombrados autores de ciencia ficción William Gibson y Tom Maddox, este episodio trata sobre un hacker llamado Donald Gelman que desarrolla una inteligencia artificial avanzada y peligrosa. Mulder y Scully se encuentran en una carrera contra el tiempo para detener a la IA antes de que cause más daño.

Curiosidades:

  • William Gibson es considerado el padre del ciberpunk, y su influencia se nota en la atmósfera y el estilo del episodio.
  • La tecnología y los conceptos presentados en «Kill Switch» fueron increíblemente visionarios para su tiempo, anticipando el desarrollo de IA avanzada y redes cibernéticas.

Tomas falsas:

  • Las escenas de acción en el episodio, especialmente las que involucran a Mulder y Scully en entornos virtuales, resultaron en varios momentos divertidos detrás de cámaras, con los actores luchando por coordinar sus movimientos con los efectos especiales.

«First Person Shooter» (Temporada 7, Episodio 13)

En este episodio, Mulder y Scully se encuentran atrapados en un videojuego de realidad virtual mientras investigan una serie de asesinatos en una empresa de desarrollo de videojuegos. La trama explora los peligros potenciales de la inmersión tecnológica y los límites entre la realidad y la ficción.

En este episodio, Mulder y Scully se encuentran atrapados en un videojuego de realidad virtual mientras investigan una serie de asesinatos en una empresa de desarrollo de videojuegos. La trama explora los peligros potenciales de la inmersión tecnológica y los límites entre la realidad y la ficción.

Curiosidades:

  • Este episodio fue dirigido por Chris Carter, el creador de la serie, y escrito por William Gibson y Tom Maddox, quienes también escribieron «Kill Switch».
  • «First Person Shooter» fue criticado y elogiado a partes iguales por su tratamiento de la cultura de los videojuegos y la tecnología de realidad virtual.

Tomas falsas:

  • Las escenas dentro del videojuego requirieron el uso de efectos especiales avanzados para la época, lo que resultó en numerosos errores técnicos y momentos de risas entre el elenco.

«Rm9sbG93ZXJz» (Temporada 11, Episodio 7)

Este episodio de la temporada más reciente se centra en el impacto de la inteligencia artificial y la tecnología moderna en la vida cotidiana. Mulder y Scully son perseguidos por drones y dispositivos automatizados después de un malentendido en un restaurante automatizado.

Curiosidades:

  • El título del episodio, «Rm9sbG93ZXJz», es «Followers» en base64, una referencia a la temática del episodio sobre las redes sociales y la vigilancia tecnológica.
  • Este episodio es casi completamente sin diálogos, lo que crea una atmósfera única y tensa que subraya la dependencia moderna de la tecnología.

Tomas falsas:

  • La falta de diálogos resultó en situaciones cómicas durante el rodaje, ya que los actores tenían que comunicar mucho con expresiones faciales y movimientos, lo que llevó a varios malentendidos y momentos divertidos.

Cabe mencionar que, en esta ocasión, no he incluido ningún episodio protagonizado por los Pistoleros Solitarios, el trío de hackers y teóricos de la conspiración favoritos de los fans. Este grupo merece un artículo dedicado para explorar en profundidad sus contribuciones únicas a la serie y su propio spin-off, que también aborda numerosos temas tecnológicos y conspirativos con su estilo distintivo.

Estos episodios no solo nos ofrecen emocionantes tramas y misterios tecnológicos, sino que también nos brindan un vistazo a un futuro potencial, uno en el que la línea entre lo humano y lo artificial se vuelve cada vez más difusa. Las curiosidades y tomas falsas detrás de cámaras añaden una capa adicional de encanto, mostrando el esfuerzo y la creatividad necesarios para dar vida a estos complejos temas.

Como fanáticos de «Expediente X», podemos apreciar cómo la serie ha sido capaz de mantenerse relevante y cautivadora al abordar cuestiones tecnológicas que son tanto atemporales como urgentes. Nos ha llevado a cuestionar nuestra confianza en las máquinas, a temer las posibles repercusiones de una inteligencia artificial sin control y a maravillarnos con las posibilidades de la realidad virtual.

En resumen, «Expediente X» no solo ha sido un pionero en la televisión de ciencia ficción y misterio, sino que también ha demostrado una notable capacidad para explorar y anticipar los dilemas tecnológicos que enfrentamos hoy en día. Estos episodios son un recordatorio de que, en el vasto universo de lo desconocido, la tecnología juega un papel crucial y, a veces, aterrador. Para los verdaderos fans, cada uno de estos episodios es una joya que merece ser revivida y analizada, apreciando su profundidad y relevancia en nuestro mundo cada vez más digital.

Todas las imágenes de esta entrada han sido generadas con ChatGPT.

por ·Sin comentarios

Intro

Os comparto un reto stego que me gustó cuando lo hice hace unos años. En realidad se tarda pocos minutos en resolverlo pero depende de tus recursos es posible que se te atragante.

Procesando a la víctima

Cuando te has enfrentado a unos cuantos retos stego lo normal es que tengas un arsenal de herramientas por las que vas a pasar a la víctima. En mi caso cuando se trata de imágenes, mi fondo de armario está formado por steganabara y stegsolve. Si con esas dos herramientas no lo veo claro ya empiezo a mirar en sus entrañas y en este caso es justo lo que hace falta, mirar en su interior.

La víctima

imagen original del reto

Estamos ante una imagen GIF de 6,36KB (6513 bytes) cuya resolución es 236×42. Debido a la extensión tenderemos a analizar los frames por si se trata de una animación. Una vez desestimada la animación entran en juego steganabara, stegsolve y demás familia. Si todo lo anterior falla abro el archivo con un editor hexadecimal y lo reviso manualmente por si hay algo que me llama la atención.

Bytes

Explorando el interior del archivo enseguida encontramos algo que llama la atención, una sucesión de bytes con espacios intercalados.

Tras copiar los bytes lo primero es eliminar los espacios y empezar a jugar con ellos. Una de las cosas que podemos hacer es convertir los bytes a ascii y voilá, nos encontramos con lo que parece otro archivo GIF.

Copiamos los bytes con la ayuda de nuestro editor hexadecimal favorito, guardamos el archivo como GIF y reto superado.

Enlaces

Nota: si algo os pide clave es deurus.info

por ·Sin comentarios

Introducción

Los retos de encriptación son muy variados como hemos comentado anteriormente. Aquí tenemos unos buenos ejemplos de ello.

Cripto 1

En este primer nivel nos encontramos con un método de encriptación muy antíguo.    Sólo diré como pista, que es de los más antiguos que se conocen.

ozhlofxrlmvhxzorulimrz

Lo primero que suelo hacer en este tipo de retos cuando son solamente letras, es comprobar las dos opciones más típicas, que son el cifrado César y Vigenere. En este caso necesitamos ahondar un poco más, aunque enseguida llegamos a la conclusión de que el cifrado usado es el afín. Un ataque por fuerza bruta nos devuelve la solución y los coeficientes utilizados.

Solución: A=25,B=25  – LASOLUCIONESCALIFORNIA

Fuente: http://www.dcode.fr/chiffre-affine

Cripto 2

En este segundo nivel recordaremos a un general romano muy conocido. Lo complicaremos un poco, sólo lo justo para que cueste algo más de cinco minutos encontrar la clave 🙂

oehoeahhjoexhkzqhfsvzhffhwrhotqk

Lo primero que nos viene a la cabeza es el cifrado César pero no va. Probando varios cifrados por sustitución al final damos con el correcto. De nuevo un ataque por fuerza bruta nos da frutos.

Solución: (3,4,5)/1  – LACLAVEDELASEGUNDAPRUEBAESMEKONG

Fuente: https://www.dcode.fr/chiffre-decalages

Cripto 3

Este nivel también va a ser sencillo. Estos caracteres, pertenecientes a un sistema bastante conocido de encriptado, esconden una palabra que, al introducirla (en minúsculas), nos permitirá superar el nivel.

Investigando un poco llegamos a la conclusión de que se trata del cifrado Francmasón o Pig Pen.

Solución: primates

Fuente: https://www.dcode.fr/chiffre-pig-pen-francs-macons

Cripto 4

Esta prueba es tan simple que la he dividido en dos partes que, aunque de apariencia similar, se resuelven de distinta manera. La clave es la unión de las dos palabras resultantes de descifrar las dos líneas de números y que, juntas, forman una tercera palabra.

0111001101110101011100000110010101110010
0001001110011000111110100100110010010001

La primera parte se puede convertir en bloque:

0111001101110101011100000110010101110010 = super

Fuente: https://www.rapidtables.com/convert/number/binary-to-ascii.html

Para la segunda debemos separar en grupos de 5 dígitos y listo:

00010   01110   01100   01111   10100   10011   00100   10001

 C             O          M           P            U          T           E           R

Fuente: www.lindau-nobel.org

Cripto 5

Para descubrir la palabra clave sólo se necesita una mínima capacidad de observación.

31 04 40 23 20 34 33 13 23 22

Se trata del cuadrado de Polibio.

Cripto 6

Aquí hay que hacer un poco de trabajo de investigación: Hay que descubrir la clave que empleó un escritor francés (Una pista: «Lagardère») en una de sus novelas, que es la empleada aquí para formar la palabra clave (en minúsculas) que, por cierto, es alemana.

RI3I2MIL2I2A3

POR RESOLVER

Cripto 7

Seguimos con cosas fáciles. Se trata de descifrar este texto escrito en inglés.

kgw qkoev ol 617 qthpreoz iwjpz sdkg kgw pdeyeplk rwqdjzwe ipezwq spbbdq sgo sgwz goqkdbdkdwq iwjpz spq rwkwecdzwr ko cpmw gdq uweqozpb yozkedihkdoz ko kgw spe wlloek

Una vez descifrado, nos será fácil descubrir la clave:

pzpyozrp

Se trata de  un cifrado de sustitución mono alfabético.

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZLMIRVHUBGTFJKOASDWQPYEXCN

THE STORY OF 617 SQUADRON BEGAN WITH THE AIRCRAFT DESIGNER BARNES WALLIS WHO WHEN HOSTILITIES BEGAN WAS DETERMINED TO MAJE HIS PERSONAL CONTRIBUTION TO THE WAR EFFORT

Una vez descifrado el alfabeto la solución queda:

pzpyozrp = anaconda

Cripto 8

A veces, las cosas no son lo que parecen. Donde aparecen unos números, en realidad hay otros números distintos.

273664524572348321143738
853442616537643005319627

POR RESOLVER

Cripto 9

Para resolver algunos problemas, hay que tener una buena base. Este es un buen ejemplo de ello:

ZW50ZXJwcmlzZQ0K

¿Os suena base 64?

Solución: enterprise

Fuente: https://www.base64decode.org/

Cripto 10

Esto es más complicado. Para descifrar este texto que contiene la clave para superar el nivel, se necesita otra clave. Para que no sea demasiado difícil, he utilizado una palabra muy sencilla de sólo cuatro letras 🙂

myiemyuvbaeewcxweghkflxw

Mediante fuerza bruta matamos dos pájaros de un tiro.

lapalabraclaveesdiogenes

Fuente: https://www.guballa.de/vigenere-solver

Enlaces

por ·1 comentario

Introducción

Esta es la tercera y última entrega de los crackmes de Cruehead. En esta ocasión nos enfrentamos a un «keyfile«, un archivo llave para que nos entendamos. Tiene un poco más de dificultad que los anteriores pero es ideal para los que empiezan.

El algoritmo

Si iniciamos el crackme no pasa nada, lo único que vemos es la palabra «UNCRACKED» en el título. Abrimos el crackme con Olly y empezamos. En las «string references» vemos el nombre del archivo llave «crackme3.key«. Lo creamos y escribimos el serial 12345678 y empezamos a tracear.

El CMP EAX,-1 significa que está comprobando que el archivo no esté vacio, como no es nuestro caso continuamos.

07-09-2014 13-02-12

A continuación vemos que compara nuestra longitud de serial con 0x12 (18 en decimal). Nuestro serial tiene 8 dígitos así que nos tira fuera.

07-09-2014 13-07-59

Escribimos en el archivo llave el serial «deurus123456789012» y volvemos a tracear. Vemos que ahora si pasa los filtros iniciales y llegamos a la primera zona interesante. En la imágen está explicado pero os hago un resumen. En el bucle lo que hace es un XOR a los primeros 14 dígitos de nuestro serial con los valores del 41 al 4E (4F finaliza). El bucle solo se rompe si llegamos a 4F o si el resultado del XOR da 0. Además en EAX acumula la suma del resultado del XOR.

07-09-2014 17-13-57

Ejemplo:

d  e  u  r  u  s  1  2  3  4  5  6  7  8  9  0  1  2
64 65 75 72 75 73 31 32 33 34 35 36 37 38
                                          XOR
41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E
-----------------------------------------
25 27 36 36 30 35 76 7A 7A 7E 7E 7A 7A 76 = 4ED (Suma)

A continuación hace XOR entre 12345678 y 4ED, coge los 4 últimos dígitos de nuestro serial y los compara.

07-09-2014 17-23-45

Ejemplo:

12345678 XOR 4ED = 12345295
Compara 12345295 con 32313039
32313039 = 2109, nuestros 4 últimos dígitos al revés. Recordemos que nuestro serial era "deurus123456789012"

 El serial bueno para el nombre deurus12345678 serían los bytes correspondientes de «12345295», es decir, nuestro serial bueno sería:

Ejemplo:

Necesitamos 12345295 para la comparación.
12 34 52 95 hexadecimal
18 52 82 149 decimal
Tenemos que escribirlo al revés. Con Alt-Izq + 149 escribimos el primer caracter, el resto igual.
Nuestro serial quedaría: deurus12345678òR4↕

Metemos el serial y vemos que lo acepta pero que nos muestra un nombre extraño. Esto es por que nos está mostrando los bytes del nombre xoreados, tendremos que hacer un XOR antes al nombre que queramos para que lo muestre correctamente.

07-09-2014 18-15-19

Recapitulando

Con lo que sabemos ahora hay que empezar a coger el toro por los cuernos. Lo primero que queremos que muestre el nombre deurus y no deurus12345678. Para ello debemos cortar el bucle y eso solo lo podemos hacer forzando que el resultado del XOR sea 0. Ok pues para deurus el siguiente valor de BL, es decir el séptimo, en el bucle sería 47 lo que corresponde a la letra G. Pues si ponemos de serial deurusGxxxxxxxxxxx ya tendríamos la primera parte solucionada.

Pero recordemos que necesitamos XORear el nombre inicialmente, luego debemos escribir  el resultado del XOR.

Ejemplo:

d  e  u  r  u  s  
64 65 75 72 75 73
                  XOR
41 42 43 44 45 46
-----------------
25 27 36 36 30 35

25 27 36 36 30 35 ----- debemos meter esto en el archivo llave.
                  XOR
41 42 43 44 45 46
-----------------
64 65 75 72 75 73 ----- Al desencriptarlo el bucle se verá nuestro nombre correctamente.

En el archivo llave escribiriamos: %'6605

Ahora nos faltaría calcular el nuevo SUM. Como el resultado del XOR ahora es nuestro nombre, basta con sumar sus valores ascii (64+65+75+72+75+73 == 0x298)

0x12345678 XOR 0x298 == 0x123454E0

Luego nuestros 4 últimos dígitos deben ser lo correspondiente a los bytes E0, 54, 34, 12. Los pasamos a decimal y los escribimos en el archivo llave con el truco del ALT-Izq que hemos comentado antes.

El contenido final del archivo llave para el nombre deurus sería:

%’6605GxxxxxxxÓT4↕

07-09-2014 16-55-15

Aquí vemos el archivo llave normal.

keyfiletext

Y aquí lo vemos con un editor hexadecimal. Como veis se ven claramente los bytes E0, 54, 34, 12.

keyfilehex

Os dejo un keygen hecho en .Net para que probéis. Os genera el contenido del archivo y el archivo «crackme3.key».

keygen

Links

Crypto - Vodka
Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos
Solución a los CrackMes de CrkViZ 1-5
Introducción Herramientas disponibles CrkViz-1 (Serial a la vista) CrkViz-2 (Parcheando rutina aleatoria) CrkViz-3 (Nag+Keygen) CrkViz-4 (Límite de ejecuciones+Keygen) CrkViz-5 (Serial
Shadow's Register Me - Parchear un .Net
Introducción Este es un crackme hecho en .Net con dos Nags a parchear y un algoritmo muy sencillo pero que
This little bunny CrackMe
AVISO: Debido a que este reto está en activo no publicaré a donde pertenece. En este pequeño CrackMe se nos

por ·Sin comentarios

Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos encontrado es esto en un foro: шжзклмнпфъ = 1234567890

Mensaje secreto: нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл

Solución

Parece que el mensaje secreto está encriptado utilizando un alfabeto cifrado que corresponde a números. Según la clave proporcionada (шжзклмнпфъ = 1234567890), cada letra del alfabeto cirílico se sustituye por un número.

Primero, descompondremos la clave dada:
ш = 1
ж = 2
з = 3
к = 4
л = 5
м = 6
н = 7
п = 8
ф = 9
ъ = 0

Ahora, aplicamos esta clave al mensaje secreto:

нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл

Sustituyendo cada letra según la clave:

нж = 72
фн = 97
фф = 99
шън = 107
нф = 79
шшъ = 110
шжз = 123
мф = 69
шъп = 108
фл = 95
пк = 84
шъш = 101
шшм = 116
шшк = 114
шъл = 105
шшл = 115
фл = 95
шъш = 101
шшл = 115
фл = 95
шшн = 117
шшъ = 110
фл = 95
шъм = 106
шшн = 117
шъш = 101
шъз = 130
шшш = 111
фл = 95
пж = 82
шшн = 117
шшл = 115
шшш = 111
шжл = 125

El mensaje traducido a números es:

72, 97, 99, 107, 79, 110, 123, 69, 108, 95, 84, 101, 116, 114, 105, 115, 95, 101, 115, 95, 117, 110, 95, 106, 117, 101, 130, 111, 95, 82, 117, 115, 111, 125

Este parece ser un mensaje cifrado en números. La secuencia de números se puede interpretar de varias maneras (como ASCII, coordenadas, etc.). Si asumimos que es un texto codificado en ASCII:

Convertimos cada número a su correspondiente carácter ASCII:

72 = H
97 = a
99 = c
107 = k
79 = O
110 = n
123 = {
69 = E
108 = l
95 = _
84 = T
101 = e
116 = t
114 = r
105 = i
115 = s
95 = _
101 = e
115 = s
95 = _
117 = u
110 = n
95 = _
106 = j
117 = u
101 = e
130 = ?
111 = o
95 = _
82 = R
117 = u
115 = s
111 = o
125 = }

Juntando todo:

HackOn{El_Tetris_e_s_u_n_j_u_e?o_Ruso}

La parte «{El_Tetris_e_s_u_n_j_u_e?o_Ruso}» parece un mensaje en español. Probablemente deba ser leído como: HackOn{El_Tetris_es_un_juego_Ruso}

Así, el mensaje secreto es: HackOn{El_Tetris_es_un_juego_Ruso}.

La imagen de portada de la entrada ha sido generada con ChatGPT.

por ·1 comentario

Introducción

Esta vez vamos a analizar los CrackMes de un antiguo colaborador de Karpoff Spanish Tutor, CrkViZ. En estas cinco soluciones vamos a pelearnos con Visual Basic 5/6 nativo y Pcode, con el registro de Windows y tendremos que parchear algúna rutina antidebug. Los CrackMes son del año 2000 y aunque algunos estaban ya solucionados, los analizaremos igualmente para ver la diferencia que existe con los análisis realizados en aquellos años, sí, estamos hablando del Softice.

Herramientas disponibles

Cuando hablamos de Visual Basic 5/6, podemos destacar 3 herramientas que nos facilitan mucho la vida, VB Decompiler, VB Reformer y ExDec. Las dos primeras se defienden bien tanto con código nativo como pcode y ExDec solamente nos sirve para pcode. Aún así, si todo lo demás falla, Ollydbg nos sacará de apuros.

CrkViz-1

03-03-2015 13-16-27

03-03-2015 13-16-17

Este primer crackme está compilado en Pcode y hoy día, con las herramientas de que disponemos no supone ninguna dificultad. Tan solo debemos abrirlo con VB Decompiler y ya nos encontramos con el serial válido.

03-03-2015 13-14-18

Los opcodes obtenidos con ExDec se ven de la siguiente manera.

......
402F14: 04 FLdRfVar                local_008C
402F17: 21 FLdPrThis              
402F18: 0f VCallAd                 7b3fc340
402F1B: 19 FStAdFunc               local_0088
402F1E: 08 FLdPr                   local_0088
402F21: 0d VCallHresult            7b3fbe88
402F26: 6c ILdRf                   local_008C
402F29: 1b LitStr:                 57230198        <--------------
402F2C: Lead0/30 EqStr            
402F2E: 2f FFree1Str               local_008C
402F31: 1a FFree1Ad                local_0088
402F34: 1c BranchF:                403012
402F37: 21 FLdPrThis              
402F38: 0d VCallHresult            7b3fc2b0
402F3D: 3a LitVarStr:              ( local_00AC )  Gracias por Registrar!!      
402F42: Lead2/00 FStVarCopy       
402F46: 27 LitVar_Missing         
402F49: 27 LitVar_Missing         
402F4C: 3a LitVarStr:              ( local_00AC ) CrkViz
402F51: 4e FStVarCopyObj           local_00BC
402F54: 04 FLdRfVar                local_00BC
402F57: f5 LitI4:                  0x40  64  (...@)
402F5C: 04 FLdRfVar                local_009C
402F5F: 0a ImpAdCallFPR4:          _rtcMsgBox
402F64: 36 FFreeVar
402F6D: 27 LitVar_Missing         
402F70: 25 PopAdLdVar             
402F71: 27 LitVar_Missing
......

CrkViz-2

03-03-2015 13-18-32

Este segundo crackme también está compilado en pcode. La rutina del serial es muy sencilla pero al introducir un número aleatorio nos obliga a parchear. Cargamos el crackme en VB Decompiler y nos muestra esto:

03-03-2015 13-19-48

Básicamente vemos que genera un número aleatorio entre 1 y 999999999 y luego le suma 1. La forma de afrontar esto es parcheando. Nos fijamos en el offset aproximado (4037F2) y abrimos el crackme en un editor hexadecimal. La forma de convertir el offset que nos muestra VB Decompiler a lo que nos muestra un editor hexadecimal es la siguiente.

VBdec_offset - Image Base - VirtualOffset + RawOffset = Offset_Editor.H

4037F2 - 400000 - 1000 + 400 = 2BF2

03-03-2015 14-00-27

Una vez localizados los bytes, los cambiamos por ceros y guardamos.

01-03-2015 04-50-05 01-03-2015 04-52-10

Una vez parcheado, el serial correcto es 1.

CrkViz-3

11-03-2015 21-20-07

En esta tercera entrega, CrkViz aumentó la dificultad. El crackme está compilado en código nativo y nos enfrentamos a un serial asociado a un nombre y a una rutina antidebug que en realidad es una Nag, ya que se muestra siempre.

Afrontar la nag es muy sencillo, basta con localizarla y parchear la llamada.

CPU Disasm
Address   Hex dump          Command                                            Comments
004058E2    8D4D DC         LEA ECX,[EBP-24]
004058E5    C785 BCFDFFFF B MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.004033B8     ; UNICODE "  Debugger detectado!!!   "
004058EF    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8
004058F9    FFD7            CALL EDI
004058FB    B9 04000280     MOV ECX,80020004
00405900    B8 0A000000     MOV EAX,0A
00405905    898D FCFDFFFF   MOV DWORD PTR SS:[EBP-204],ECX
0040590B    898D 0CFEFFFF   MOV DWORD PTR SS:[EBP-1F4],ECX
00405911    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00405917    8D8D 14FEFFFF   LEA ECX,[EBP-1EC]
0040591D    8985 F4FDFFFF   MOV DWORD PTR SS:[EBP-20C],EAX
00405923    8985 04FEFFFF   MOV DWORD PTR SS:[EBP-1FC],EAX
00405929    C785 BCFDFFFF 8 MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.00403188     ; UNICODE "Error"
00405933    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8
0040593D    FF15 C8914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDup>]
00405943    8D85 F4FDFFFF   LEA EAX,[EBP-20C]
00405949    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
0040594F    50              PUSH EAX
00405950    8D95 14FEFFFF   LEA EDX,[EBP-1EC]
00405956    51              PUSH ECX
00405957    52              PUSH EDX
00405958    8D45 DC         LEA EAX,[EBP-24]
0040595B    6A 10           PUSH 10
0040595D    50              PUSH EAX
0040595E    FF15 50914000   CALL DWORD PTR DS:[<&MSVBVM50.#595>]               ; rtcMsgBox - NOPear para evitar la NAG
00405964    8D8D F4FDFFFF   LEA ECX,[EBP-20C]

Antes de llegar al keygen vemos que realiza unas llamadas al registro de Windows, ponemos un breakpoint «bp RegOpenKeyW» y ejecutamos.

CPU Disasm
Address   Hex dump            Command                                  Comments
00405677  |.  8B8D B8FDFFFF   MOV ECX,DWORD PTR SS:[EBP-248]
0040567D  |.  B8 54334000     MOV EAX,CrkMeViz-3.00403354              ; UNICODE "<Unregister>"
00405682  |.  68 B4304000     PUSH CrkMeViz-3.004030B4                 ; UNICODE "Serial number"
00405687  |.  894A 04         MOV DWORD PTR DS:[EDX+4],ECX
0040568A  |.  8985 BCFDFFFF   MOV DWORD PTR SS:[EBP-244],EAX
00405690  |.  68 84304000     PUSH CrkMeViz-3.00403084                 ; UNICODE "Register"
00405695  |.  68 58304000     PUSH CrkMeViz-3.00403058                 ; UNICODE "CrkMeViz3"
0040569A  |.  8942 08         MOV DWORD PTR DS:[EDX+8],EAX
0040569D  |.  8B85 C0FDFFFF   MOV EAX,DWORD PTR SS:[EBP-240]
004056A3  |.  8942 0C         MOV DWORD PTR DS:[EDX+0C],EAX
004056A6  |.  FF15 C0914000   CALL DWORD PTR DS:[<&MSVBVM50.#689>] 	; rtcGetSetting - Lee el numero de serie del registro
........
0040574F  |.  68 9C304000     PUSH CrkMeViz-3.0040309C                  ; UNICODE "User Name"
00405754  |.  68 84304000     PUSH CrkMeViz-3.00403084                  ; UNICODE "Register"
00405759  |.  68 58304000     PUSH CrkMeViz-3.00403058                  ; UNICODE "CrkMeViz3"
0040575E  |.  8948 08         MOV DWORD PTR DS:[EAX+8],ECX
00405761  |.  8B8D C0FDFFFF   MOV ECX,DWORD PTR SS:[EBP-240]
00405767  |.  8948 0C         MOV DWORD PTR DS:[EAX+0C],ECX
0040576A  |.  FF15 C0914000   CALL DWORD PTR DS:[<&MSVBVM50.#689>]	; rtcGetSetting - Lee el Usuario del registro

 Reconstruyendo la llamada al registro vemos que lee de esta ruta: HKEY_CURRENT_USER\Software\VB and VBA Program Settings\CrkMeViz3\Register el contenido de User Name y del Serial number.

Quizá uno de los fallos de éste crackme, es que no comprueba la autenticidad de estos parámetros y si los modificas parece que estás registrado. Un ejemplo:

11-03-2015 22-23-28

La rutina de comprobación del serial no es para nada complicada pero recordemos que estamos tratando con VB y éste delega el trabajo duro en otras librerias de modo que tenemos que «meternos» a tracear las llamadas para ver los valores que multiplica y divide.

CPU Disasm
Address     Hex dump          Command                                            Comments
00405A86      FF15 3C914000   CALL DWORD PTR DS:[<&MSVBVM50.#518>]    ;MSVBVM50.rtcLowerCaseVar
00405A8C      8D95 14FEFFFF   LEA EDX,[EBP-1EC]
00405A92      8D8D ACFEFFFF   LEA ECX,[EBP-154]
00405A98      FFD6            CALL ESI
00405A9A      8D95 ACFEFFFF   LEA EDX,[EBP-154]
00405AA0      8D8D 4CFEFFFF   LEA ECX,[EBP-1B4]
00405AA6      FFD7            CALL EDI
00405AA8      8D95 4CFEFFFF   LEA EDX,[EBP-1B4]
00405AAE      8D8D 7CFFFFFF   LEA ECX,[EBP-84]
00405AB4      FFD7            CALL EDI
00405AB6      8D85 14FEFFFF   LEA EAX,[EBP-1EC]
00405ABC      8D8D 7CFFFFFF   LEA ECX,[EBP-84]
00405AC2      50              PUSH EAX
00405AC3      6A 01           PUSH 1
00405AC5      8D95 04FEFFFF   LEA EDX,[EBP-1FC]
00405ACB      51              PUSH ECX
00405ACC      52              PUSH EDX
00405ACD      C785 1CFEFFFF 0 MOV DWORD PTR SS:[EBP-1E4],1
00405AD7      C785 14FEFFFF 0 MOV DWORD PTR SS:[EBP-1EC],2
00405AE1      FF15 68914000   CALL DWORD PTR DS:[<&MSVBVM50.#632>]   ;MSVBVM50.rtcMidCharVar (Esto lo hace 6 veces, lo omito para abreviar.)
........
00405CE1      FF15 34914000   CALL DWORD PTR DS:[<&MSVBVM50.#516>]   ;MSVBVM50.rtcAnsiValueBstr (Lo mismo, otras 6)
........
00405E7C    C785 BCFDFFFF 2 MOV DWORD PTR SS:[EBP-244],52E
00405E86    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00405E90    50              PUSH EAX
00405E91    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
		|
		->MSVBVM50.__vbaVarMul
			........
			741C19D3      0FB745 FE       MOVZX EAX,WORD PTR SS:[EBP-2]       ;Valor1
			741C19D7      0FB74D F2       MOVZX ECX,WORD PTR SS:[EBP-0E]      ;Valor2
			741C19DB      6BC0 12         IMUL EAX,EAX,12                     ;Valor1*Valor2
			........
00405E97    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
00405E9D    50              PUSH EAX
00405E9E    51              PUSH ECX
00405E9F    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EA5    8D95 F4FDFFFF   LEA EDX,[EBP-20C]
00405EAB    50              PUSH EAX
00405EAC    52              PUSH EDX
00405EAD    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EB3    50              PUSH EAX
00405EB4    8D85 E4FDFFFF   LEA EAX,[EBP-21C]
00405EBA    50              PUSH EAX
00405EBB    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EC1    8D8D D4FDFFFF   LEA ECX,[EBP-22C]
00405EC7    50              PUSH EAX
00405EC8    51              PUSH ECX
00405EC9    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405ECF    50              PUSH EAX
00405ED0    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00405ED6    8D85 C4FDFFFF   LEA EAX,[EBP-23C]
00405EDC    52              PUSH EDX
00405EDD    50              PUSH EAX
00405EDE    FF15 94914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
		|
		->MSVBVM50.__vbaVarDiv
			........
			741C8094      DD43 08         FLD QWORD PTR DS:[EBX+8]      ;Recupera el resultado de las multiplicaciones anteriores
			741C8097      0FBF47 08       MOVSX EAX,WORD PTR DS:[EDI+8] ;EAX = 1326 (52E)
			741C809B      8945 F8         MOV DWORD PTR SS:[EBP-8],EAX
			741C809E      DA75 F8         FIDIV DWORD PTR SS:[EBP-8]    ;Divide los dos resultados
			741C80A1      DD5E 08         FSTP QWORD PTR DS:[ESI+8]
			........
00405F44      FF15 24914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]          ;Len(nombre)
........
00405F85      FF15 94914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]           ;Resultado anterior / Len(nombre)
........

En resumen:

  • Pasa nuestro nombre a minúsculas.
  • Obtiene el valor ascii de los 6 primeros dígitos del nombre.
  • Los multiplica entre sí y divide el resultado acumulado entre 1326 (52E).
  • Divide el resultado anterior entre el tamaño del nombre.

Ejemplo para deurus

64*65*75*72*75*73 = 1A605D70EB8
1A605D70EB8 / 52E = 5179FBF4
5179FBF4 / 6 = D9454A9

11-03-2015 21-20-17

Al estar correctamente registrados desaparece el botón de registrar.

CrkViz-4

12-03-2015 23-09-07

El cuarto crackme es prácticamente igual que el tercero salvo que en vez de nag ahora contamos con limitación de ejecuciones. Del mismo modo utiliza el registro de Windows para guardar los datos de registro y las ejecuciones que llevamos.

Ponemos un breakpoint «bp RegOpenKeyW» y llegamos a la conclusión de que la ruta es HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register y los valores se guardan en Counter, User Name y Serial number respectivamente. Este crackme hereda el fallo del anterior y si alteramos los valores el crackme nos muestra como usuarios autorizados, aunque sabemos que no estamos registrados ya que seguimos limitados por ejecuciones. Ni que decir tiene que lo mismo que modificamos el nombre y número de serie, podemos modificar el contador a nuestro favor. Crear un archivo «Reiniciar_contador.reg» con el siguiente contenido sería suficiente.

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC]

[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register]
"Counter"="0"
"User Name"="deurus"
"Serial number"="12345"

El keygen es prácticamente igual que en el crackme anterior, solo cambia el divisor.

CPU Disasm
Address   Hex dump          Command                                                   Comments
........
00404BD2    C785 BCFDFFFF C MOV DWORD PTR SS:[EBP-244],6C1
00404BDC    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00404BE6    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
   |
    ->MSVBVM50.__vbaVarMul
	741C19F9    0FBF4F 08       MOVSX ECX,WORD PTR DS:[EDI+8]      ;Valor1
	741C19FD    0FBF43 08       MOVSX EAX,WORD PTR DS:[EBX+8]      ;Valor2
	741C1A01    0FAFC8          IMUL ECX,EAX                       ;Valor1*Valor2
........
00404BEC    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
00404BF2    50              PUSH EAX
00404BF3    51              PUSH ECX
00404BF4    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404BFA    8D95 F4FDFFFF   LEA EDX,[EBP-20C]
00404C00    50              PUSH EAX
00404C01    52              PUSH EDX
00404C02    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C08    50              PUSH EAX
00404C09    8D85 E4FDFFFF   LEA EAX,[EBP-21C]
00404C0F    50              PUSH EAX
00404C10    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C16    8D8D D4FDFFFF   LEA ECX,[EBP-22C]
00404C1C    50              PUSH EAX
00404C1D    51              PUSH ECX
00404C1E    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C24    50              PUSH EAX
00404C25    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00404C2B    8D85 C4FDFFFF   LEA EAX,[EBP-23C]
00404C31    52              PUSH EDX
00404C32    50              PUSH EAX
00404C33    FF15 B0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
   |
    ->MSVBVM50.__vbaVarDiv
	741C8094    DD43 08         FLD QWORD PTR DS:[EBX+8]              ; Recupera el resultado de las multiplicaciones anteriores
	741C8097    0FBF47 08       MOVSX EAX,WORD PTR DS:[EDI+8]         ; EAX = 1729 (6C1)
	741C809B    8945 F8         MOV DWORD PTR SS:[EBP-8],EAX
	741C809E    DA75 F8         FIDIV DWORD PTR SS:[EBP-8]

00404C39    8BD0            MOV EDX,EAX
........
00404CA0    FF15 3C914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]  ;Len(nombre)
........
00404CF1    FF15 B0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]   ;Resultado anterior / Len(nombre)

En resumen:

  • Pasa nuestro nombre a minúsculas.
  • Obtiene el valor ascii de los 6 primeros dígitos del nombre.
  • Los multiplica entre sí y divide el resultado acumulado entre 1729 (6C1).
  • Divide el resultado anterior entre el tamaño del nombre.

Ejemplo para deurus

64*65*75*72*75*73 = 1A605D70EB8
1A605D70EB8 / 6C1 = 3E7C594A
3E7C594A / 6 = A6A0EE2

CrkViz-5

11-03-2015 23-23-16

Este último crackme está compilado en código nativo y simplemente se trata de una comparación lineal. La única diferencia reside en que no hay botón de registro, la comprobación la gestiona un evento «On Change«, de modo que está comprobando el tamaño del serial que introducimos y cuando éste tiene 8 dígitos llegamos aquí.

........
0040A64F         .  C745 9C CDD4DD02    MOV DWORD PTR SS:[EBP-64],2DDD4CD      ;2DDD4CD = 48092365
0040A656         .  C745 94 03800000    MOV DWORD PTR SS:[EBP-6C],8003
0040A65D         .  FF15 08C14000       CALL DWORD PTR DS:[<&MSVBVM50.__vbaVa> ;MSVBVM50.__vbaVarTstEq
0040A663         .  66:85C0             TEST AX,AX
0040A666         .  0F84 BA000000       JE CrkMeViZ.0040A726                   ;Si salta BAD  BOY
........

Luego el serial correcto es 48092365.

Notas finales

¿Ha sido indoloro no?, claro que sí, Visual Basic es un coñazo de tracear pero hay que reconocer que con el tiempo las herramientas han mejorado mucho y nuestra vida es mucho más sencilla. Bueno, pués esto ha sido todo, como siempre os dejo todo el material utilizado y un Keygen.

12-03-2015 23-06-33

Enlaces

por ·Sin comentarios

Introducción

Este es un crackme hecho en .Net con dos Nags a parchear y un algoritmo muy sencillo pero que tendremos que parchear para poder resolverlo.

Las Nags

Se encuentran en los eventos de carga y cierre del formulario.

01-09-2014 07-30-07

// RegisterMe.Form1
private void Form1_Load(object sender, EventArgs e)
{
    Interaction.MsgBox("Register me pl0x!", MsgBoxStyle.OkOnly, "Nag!!!!");
}

// RegisterMe.Form1
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    Interaction.MsgBox("Register me pl0x!", MsgBoxStyle.OkOnly, "Nag2!!!!");
}

 Para parchear un ejecutable realizado en .Net primero necesitamos ubicarnos. Abrimos IL Dasm y vamos al evento «Form_Load«, nos fijamos en los bytes y los buscamos con un editor hexadecimal. Fijaros bien en los bytes ya que siguen un orden específico, en la imágen del editor hexadecimal se aprecia perfectamente. Para que quede parcheada la Nag basta con sustituir los valores por ceros. Se parchea todo excepto el «RET (2A)».

01-09-2014 08-03-23

01-09-2014 08-04-01

Para la  otra Nag sería lo mismo.

El algoritmo

El algoritmo es muy sencillo, consiste en la concatenación de varias palabras y un número aleatorio. El problema viene con el número aleatorio ya que lo tendremos que parchear para poder registrar el programa.

// RegisterMe.Form1
private void Button1_Click(object sender, EventArgs e)
{
    this.shadow = this.rand.Next(1, 99999999);
    if (Operators.ConditionalCompareObjectEqual(this.TextBox2.Text, Operators.ConcatenateObject(this.TextBox1.Text + this.TextBox3.Text + this.TextBox4.Text + this.TextBox5.Text + this.TextBox6.Text + this.TextBox7.Text + this.TextBox8.Text + this.TextBox9.Text + this.TextBox1.Text, this.shadow), false))
    {
        this.Button2.Enabled = true;
        this.Button1.Enabled = false;
        this.Button1.Text = "Registered to Shadow";
        this.Text = "Registered to Shadow!";
    }
    else
    {
        Interaction.MsgBox("Incorrect serial, noob.", MsgBoxStyle.OkOnly, null);
    }
}

La concatenación quedaría así:

TextBox1.Text = Nuestro usuario + TextBox3.Text = «ur» + TextBox4.Text = «a» + TextBox5.Text = «stupid» + TextBox6.Text = «dumb» + TextBox7.Text = «idiotic» + TextBox8.Text = «crazy» + TextBox9.Text = «noob» + TextBox1.Text = Nuestro usuario + El número aleatorio

 Ejemplo

  • Nombre: deurus
  • Clave: deurusurastupiddumbidioticcrazynoobdeurus98265385

Parcheando el número aleatorio

Buscamos el evento click en IL Dasm y nos fijamos que aparece el número «5F5E0FF» que en decimal equivale a «99999999«, buscamos los bytes en el editor hexadecimal y lo parcheamos a 1. De este modo anulamos la aletoriedad, ahora el número siempre es 1.

01-09-2014 09-25-23

01-09-2014 09-35-35

01-09-2014 09-36-59

Ahora ya podemos registrarnos.

01-09-2014 07-38-44

Links

Guía rápida para tener una red Gigabit en casa
Introducción A quien va dirigido Comprobaciones previas Lo que necesitamos Presupuesto Ejemplo de instalación Preguntas frecuentes Glosario Notas finales Introducción
Retos de Criptografía
Los retos de criptografía pueden ser muy variados como he dicho anteriormente. El secreto suele estar en saber a que
Yoire PE Stage 2 Reversing Challenge (Crackme Very Hard) - eXORcism
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
Blooper Tech Movie XIII – Copycat
Hoy analizamos Copycat, un thriller psicológico de 1995 que, como muchas películas de la época, no pudo resistirse a incorporar

por ·1 comentario

Introducción

Un día cualquiera se te ocurre comprarte un disco duro de red NAS para centralizar todo tu contenido multimedia. Lo conectas y todo va genial, pero de repente vas a copiar unos cuantos gigas de fotos y te encuentras con que la operación va a tardar días. En ese mismo instante te planteas sacar el máximo provecho a tu red doméstica y la solución se llama gigabit.

A quién va dirigido

Esta guía va dirigida a todo el mundo que esté pensando en hacer o mejorar la red LAN doméstica. Si eres un amante del WIFI, olvídate de esto, ya que para conseguir altas velocidades se necesita cablear la casa. Además, de lo que trata esta guía es de que se conecte un ordenador portátil o sobremesa de la forma más rápida posible al disco duro de red.

Comprobaciones previas

Probablemente dispongas de un Modem / Router proporcionado por tu compañia y que seguramente no sea gigabit (10/100/1000), esto es lo primero que debes comprobar. Busca tu modelo en internet y cerciorate.

También necesitas que la tarjeta de red del portátil o sobremesa sean gigabit, en este caso lo más probable es que lo sean pero asegúrate.

Lo que necesitamos

Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.

  • Router gigabit (en caso del que tu compañia no lo sea).

Si el nuestro no es gigabit existen soluciones económicas como el TP-Link TL-WR1043ND que lo tenemos por 44€ en pccomponentes. Os recomiendo esta tienda por rapidez, seriedad y no abusan con los gastos de envío.

tp_link_tl_wr1043nd_ultimate_router_neutro_wifi_11n_usb_4

  • Switch gigabit (para ampliar puertos)

En caso de que los cuatro puertos que vienen con el router se nos queden cortos, la solución más economica y acertada es un Switch ethernet gigabit como el TP-LINK TL-SG1005D que lo tenemos por 16€. Este dispositivo es una maravilla ya que nos brinda 4 puertos más y no requiere configuración alguna.

tp_link_tl_sg1005d_switch_5_puertos_gigabit

  • Tarjeta de red gigabit (para pc sobremesa en caso de no ser o no disponer)

Son muy económicas, las puedes encontrar por 10€-15€ en cualquier tienda especializada. Ejemplo PCI. Ejemplo PCI-e. Video instalación de una tarjeta de red.

tarjeta-de-red-tp-link-tg-3269-gigabit-pci-internet-101000-1859-MLU4520989306_062013-F

  • Bobina de cable de red Categoría 6.

100m de cable UTP categoría 6 viene a costar sobre unos 42€.

bobina_100m_cable_red_rigido_utp_cat_6_10_100_1000

  • Cables Cat6 interconexionado router / switch / pc.

Para interconexionado de equipos recomiento estos de 50cm por 1,5€. Para conexión del pc tienes otras larguras más apropiadas. También podéis haceros vosotros los cables con lo sobrante de la bobina, para ello necesitaréis una crimpadora y terminales rj45.

digitus_cable_de_red_rj45_cat_6_10_100_1000_gris__50cm_

  • Tomas RJ45 categoría 6.

Esto depende de tu instalación y la gama que elijas. En mi caso utilizo tomas Niessen que solo el conector vale 16€, pero tienes tomas más económicas. De superficie por 2,75€ y empotrable por 8,25€.

roseta_de_superficie_cat6_conector_red_hembra_rj45 roseta_empotrable_cat5e_2_conectores_red_45__hembra_rj_45

  • Insertadora (punch down) para las tomas RJ45.

Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.

PCS058007_large

  • Disco duro de red NAS

Esto es una recomendación personal ya que la elección puede variar en función de las necesidades de almacenamiento y conexiones. Una solución barata y con espacio suficiente para uso doméstico es el disco WD My Cloud 3TB que lo podeis adquirir por 159€.

wd_my_cloud_4tb

Presupuesto (Precios Octubre 2014)

  • Router = 44€
  • Switch = 16€
  • Tarjeta de red = 15€
  • Bobina de cable = 42€
  • Cables interconexionado 50cm x4 = 6€
  • Cable conexión pc / switch o router 1,8m = 2,95€
  • Tomas RJ45 x 2 = 16,5€
  • Disco duro de red NAS = 159€
  • TOTAL = 345,45€ + gastos de envío.

Esto puede variar en función de los componentes que elijas comprar pero el coste oscilará entre 250 y 350€, algo bastante asequible para centralizar contenido multimedia. Digo asequible por que la mitad del presupuesto se lo lleva el disco de red, los componentes son más bien baratos.

Ejemplo de instalación

Esquema inicial

En mi esquema disponemos del router proporcionado por el proveedor de internet que en mi caso sí es gigabit pero que solo lo utilizo para dar internet al router neutro.El router neutro junto con el switch me proporcionan 8 puertos gigabit. El router neutro además gestiona el wifi de la casa, pero en el mejor de los casos (Wifi n) estos dispositivos solo podrán mover datos a 300mbps. Utilizo como media center mis amadas Raspberry Pi que en este caso no se benefician de la velocidad ya que disponen de conexión 10/100.

esquema

Configurar router neutro

Lo primero a conectar es el router neutro y en este caso, TP-Link te lo pone fácil si no te defiendes muy bien con las redes, ya que proporciona un CD que se encarga de guiarte paso a paso. Lo más importante es la asignación de la IP privada, por defecto es 192.168.2.1 y a no ser que el router de la compañia tenga esa misma IP lo podéis dejar como está.

Disco duro de red NAS

Para configurar el disco de red normalmente viene un CD para ayudar al usuario novel. Lo único que tenéis que tener en cuenta es que la IP debe estar en consonancia con la del router neutro, si el router neutro es 192.168.2.1 al disco NAS podéis asignarle 192.168.2.150. Para más información aquí tenéis la guía de instalación.

Preguntas frecuentes. FAQ

  • ¿El cable normal o cruzado?

Podéis usar cable normal, también llamado conexión Pin a Pin ó 1:1, para toda la instalación ya que los dispositivos de hoy en día aceptan cualquier cable y resuelven internamente en función del cable conectado. Pero si nos ponemos quisquillosos, para conectar elementos pasivos entre sí (router a switch, etc) se utiliza cable normal 1:1. Para conectar elementos activos (PC a router/switch) cable cruzado.

  • ¿Qué norma de colores uso?

Mi consejo es que uses el standard EIA/TIA 568B tanto en la conexión de las cajas como en la creación de los cables.

image002

Cada roseta o toma en su interior tiene definido el orden que debes seguir para conectar los cables según el standard A o B, esto es una aproximación y puede no coincidir con tu toma.

con_roseta

  • Tengo todo instalado y es categoría 6 pero mi pc me marca que me conecta a 100mbps ¿qué pasa?

Si estás seguro de que las rosetas están bien conectadas, que has usado los cables correctos, que todos los dispositivos son gigabit y tu pc hace de las suyas, quizás debas de forzar a tu tarjeta de red a trabajar en modo gigabit ó 100 full duplex ó 100FD. Esto es debido a que el driver de la tarjeta de red por defecto viene con la opción de «autonegociación» activada y a veces necesita que le «obligues» a trabajar en gigabit.

En cada tarjeta de red puede venir diferente, yo os muestro mi caso desde windows 7:

Diríjete a Inicio > Panel de control > Ver el estado y las tareas de red > conexión de area local

En mi caso marca 1 Gbps pero si estais teniendo problemas os marcará 100 mbps. A continuación pulsa Propiedades.

31-10-2014 21-47-55

Pulsa Configurar.

31-10-2014 21-49-19

En la pestaña Opciones avanzadas busca la opción de la velocidad, en mi caso «Speed/duplex settings» y selecciona 100 mb Full Duplex. De este modo le forzais a la tarjeta de red a trabajar en modo gigabit. Si no lo consiguiera trabajará en el modo que pueda pero no os dejará sin conexión.

31-10-2014 21-50-31

Glosario

  1. NAS – del inglés Network Attached Storage, es el nombre dado a una tecnología de almacenamiento dedicada a compartir la capacidad de almacenamiento a través de una red. Estos discos vienen equipados como mínimo con una conexión RJ45 para integrarlo en una red de forma rápida y sencilla.
  2. Full Duplex – Que transmite y recibe en ambas direcciones al mismo tiempo por cables independientes.
  3. Switch – Un conmutador o switch es un dispositivo digital lógico de interconexión de equipos que opera en la capa de enlace de datos del modelo OSI. Su función es interconectar dos o más segmentos de red, de manera similar a los puentes de red, pasando datos de un segmento a otro de acuerdo con la dirección MAC de destino de las tramas en la red.
  4. Gigabit Ethernet – también conocida como GigaE, es una ampliación del estándar Ethernet (concretamente la versión 802.3ab y 802.3z del IEEE) que consigue una capacidad de transmisión de 1 gigabit por segundo, correspondientes a unos 1000 megabits por segundo de rendimiento contra unos 100 de Fast Ethernet (También llamado 100BASE-TX).

Notas finales

Soy consciente de que me he dejado muchas cosas en el tintero pero mi pretensión es que el lector de un vistazo rápido tenga una idea clara de lo que necesita para lograr una red decente en casa.

por ·Sin comentarios

Los retos de criptografía pueden ser muy variados como he dicho anteriormente. El secreto suele estar en saber a que te enfrentas y posteriormente construir una herramienta para descifrarlo o usar una ya existente (la mayoría de los casos).

Una web con la que suelo resolver la mayoría de retos es dcode.fr. Si os fijáis en el enlace, la lista de categorías asciende a 48 y disponéis de unos 800 algoritmos para rebanaros los sesos.

A continuación veamos unos cuantos retos que podéis encontrar por la red. Cabe destacar que normalmente el título del reto dice mucho del algoritmo.

  • Enunciado: The grass is always greener on the other side
  • Texto encriptado: TSDLN ILHSY OGSRE WOOFR OPOUK OAAAR RIRID
  • Solución: César
  • Enunciado: Prove you’re not drunk?
  • Texto encriptado: gsv kzhh blfi ollprmt uli rh zoxlslo
  • Solución: Atbash
  • Enunciado: ¿?
  • Texto encriptado: 4C240DDAB17D1796AAD3B435B51404EE
  • Solución: Aquí nuestro primer impulso es utilizar fuerza bruta a MD5, pero cuando nos damos contra la pared el siguiente candidato es LAN Manager. Aquí la opción que más os guste, Cain, John The Ripper, etc.

Con John The Ripper tenemos que preparar un archivo de texto del estilo: deurus.info:1011:4C240DDAB17D1796AAD3B435B51404EE:4C240DDAB17D1796AAD3B435B51404EE:::

y ejecutar el comando: john –format=lm LM.txt

  • Enunciado: a lot harder than SMS
  • Texto encriptado: .- -. . .- … -.– — -. . – …. . .–. .- … … .– — .-. -.. .. … -.. — – -.. .- … …. -.. .- … …. -.. — –
  • Solución: Morse
  • Enunciado: Now I see!

 

  • Enunciado: Polly the parrot loves to square dance?
  • Texto encriptado: 442315 3511434352344214 2443 442432154411123115
  • Solución: Polybios
  • Enunciado: Aquí hay problemas de base.
  • Texto encriptado: VGhlIHBhc3N3b3JkIGlzIG9qZXRlIG1vcmVubw==
  • Solución: Base64
  • Enunciado: Conversión
  • Texto encriptado: 6c6120736f6c756369c3b36e2065733a20366533303664333137333734333337323739
  • Solución: Hexadecimal
  • Enunciado: Método de encriptación de los más antiguos que se conocen.
  • Texto encriptado: ozhlofxrlmvhxzorulimrz
  • Solución: Cifrado Afín
  • Enunciado: /_vti_pvt/administrators.pwd
  • Texto encriptado: admin:dut4HlQyu4dSA
  • Solución: Creamos un archivo de texto con el texto encriptado y ponemos a John The Ripper a trabajar con el comando john –show administrators.pwd
  • Enunciado: En ocasiones veo en binario
  • Texto encriptado:0111001101110101011100000110010101110010
    0001001110011000111110100100110010010001
  • Solución: Para la primera parte la conversión es directa. Para la segunda, la dificultad reside en darse cuenta que hay que separar en grupos de cinco y decodificar por separado.
  • Enunciado: Un clásico
  • Texto encriptado: WLYGUKVAIIXAVGLRWCHVDRWC
  • Solución: Vigenere
  • Enunciado: Una antigua estirpe
  • Enunciado: eXORcism
  • Texto encriptado: 7d5313525e52475713544113414046025052
  • Solución: XOR. La clave la podéis obtener por fuerza bruta. Mira este artículo par saber como.
  • Enunciado: Edgar Allan Poe
  • Texto encriptado: 05-05¶88)8)-5(525,‡
  • Solución: Escarabajo de oro
  • Enunciado: MD encryption
  • Texto encriptado: 6FBCF7B5CE6637C28EEDC43988A9509B
  • Solución: MD5
  • Enunciado: American coding system used in the context of World War II
  • Texto encriptado: A-WOH LIN AH-JAH CLA-GI-AIH BE-LA-SANA KLESH DIBEH GLOE-IH NE-AHS-JAH GAH BE YEH-HES DIBEH A-CHIN WOL-LA-CHEE A-KEH-DI-GLINI TSE-NILL YIL-DOI A-KHA
  • Solución: Código Navajo
  • Enunciado: Run, run, run
  • Texto encriptado: T1H1E1P1A1S2W1O1R1D1I1S1R1U1N2I1N1G1
  • Solución: Run-length encoding

Conversiones, cifra clásica, hash, simétricos, asimétricos, combinaciones de varios algoritmos y un largo etcetera. Como veis los hay para todos los gustos, ten en cuenta que aquí os muestro una pequeñísima parte de lo que os encontrareis en las webs de retos, pero para despertar la curiosidad es suficiente.

¡Hala, a decodificar!

Enlaces

por ·Sin comentarios
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si continuas leyendo este manual es que no utilices la respuesta para completar la prueba sin esfuerzo. 😉

Analizando…

Cargamos el crackme en Ollydbg y vamos a las «Referenced Strings«. Vemos una referencia muy interesante que se llama «checkkey«.

 Pinchamos sobre ella y aparecemos aquí:

Vemos una referencia a «GetDlgItemTextA» y depués un Call también interesante, vamos a explorarlo.

Entendiendo la rutina de comprobación del serial

 

Dentro del Call hay dos bucles, uno realiza una operación con nuestro serial (bucle nombre) y el otro comprueba nuestro serial con «3d34273130276a» dígito a dígito (bucle comprobación).

Bucle nombre se puede resumir así:

MOVSX EAX,BYTE PTR DS:[EBX]   --> Dígito a EAX
XOR EAX,55                    --> EAX xor 55
...
CMP BYTE PTR DS:[EBX],0       --> ¿hemos acabado?
JNZ SHORT 10001022            --> bucle
LEA ECX,DWORD PTR SS:[EBP-20] --> ECX = nuestro serial xoreado

Bucle comprobación se podría resumir así:

MOV EDX,10006000             --> EDX = "3d34273130276a"
...
MOV AL,BYTE PTR DS:[ECX]     --> AL = 1ºdígito serial xoreado
CMP AL,BYTE PTR DS:[ECX+EDX] --> AL = 1ºdígito de EDX?
JNZ SHORT 1000105A           --> Si no son iguales bad boy
INC ECX 

TEST AL,AL
JNZ SHORT 1000104A           --> bucle

Ejemplo para «deurus».

   Nombre: d  e  u  r  u  s
Ascii hex: 64 65 75 72 75 73 
   XOR 55: 31 30 20 27 20 26

Serial XOReado para deurus sería = 313020272026 que obviamente se aleja bastante de 3d34273130276a.
Por suerte XOR es una función reversible por lo que si revertimos 3d34273130276a nos dará el serial correcto.

Serial correcto XOReado: 3d 34 27 31 30 27 6a
XOR 55:                  68 61 72 64 65 72 3F
Valor ascii:             h  a  r  d  e  r  ?

Links

Andy's Keygenme Keygen (AutoIt)
Introducción  Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro
Blooper Tech Movie XIII – Copycat
Hoy analizamos Copycat, un thriller psicológico de 1995 que, como muchas películas de la época, no pudo resistirse a incorporar
ThisIsLegal.com - SQL Challenge 2
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Solución al CrackMe DAE 430
Introducción Herramientas utilizadas Desempacado con Ollydbg 2 (Videotutorial) Desempacado con Ollydbg 1 (Videotutorial) Análisis de la rutina del número de

por ·Sin comentarios

En esta ocasión vamos a hablar de una película de culto de los años 90, Hackers – Piratas Informáticos. La verdad es que aunque puede ser entretenida, tecnológicamente es una pesadilla y es que esta película es un claro ejemplo de cuando Hollywood prefiere agradar visualmente a representar escenas realistas.

Tras cuatro minutos en los que se nos presenta a Dade (Jonny Lee Miller) y sus problemas con la ley a una temprana edad, saltamos unos años después hasta ver a Dade encerrado en su habitación volviendo a las andadas intentando acceder ilegítimamente a los servidores de una cadena de televisión. Para ello hace uso de algo muy conocido en el mundillo Hacker, la Ingeniería Social, y es que aunque ahora disponemos de «cierta» conciencia en seguridad informática, en los años 90 no había ninguna. Bien, el caso es que Dade llama a las oficinas de la citada cadena de televisión a una hora en la que no hay más que el vigilante de seguridad y éste le proporciona un número que debemos suponer que es la IP de un Módem y comienza la intrusión.

BTM

Para empezar, se le ve al protagonista escribir comandos cuando en la pantalla no hay más que una animación en algo parecido a una ventana de terminal al estilo «Commander», pero no vemos lo que escribe, algo irreal.

vlcsnap-2015-11-25-18h00m25s936

A continuación y como por arte de magia entra en el sistema y lo que se muestra es una animación parpadeante con el logo de la compañia y el nombre del sistema al que estamos accediendo, también irreal.

vlcsnap-2015-11-25-12h43m18s762

Finalmente nos muestra sus intenciones, y son nada más y nada menos que cambiar la programación actual simplemente cambiando de VHS, inmejorable. A continuación os muestro la secuencia.

Por lo menos nos queda el consuelo de que cambia la tertulia de un tipejo con ciertos prejuicios raciales por una programación más interesante como «The Outer limits«, aquí conocida como «Más allá del límite«.

El resto de escenas informáticas de la película carecen de veracidad, la única que se salva, puede ser cuando accede al servidor del Instituto para programar el sistema contra incendios y vengarse de Kate (Angelina Jolie), ya que las imágenes que aparecen son de los primeros entornos gráficos de Mac.

vlcsnap-2015-11-25-18h29m08s043

vlcsnap-2015-11-25-18h29m15s390

vlcsnap-2015-11-25-18h29m31s550

Es extraño que casi todas las intrusiones las realiza desde su propia casa, algo poco inteligente, ya que por muy bueno que seas, siempre dejas huellas. Solo cuando se enfrentan a un Super-Hacker se empiezan a tomar las cosas en serio y realizan los ataques desde cabinas telefónicas.

En la película También hacen mención al Phreaking y a algunos de los libros que eran famosos por aquella época pero poco más que destacar. Por todo esto y mucho más, y aunque me caen igual de bien tanto Angelina como Jonny, la película se merece un majestuoso sello de BTM.

hackers_sello

Enlaces

Solución al Crackme RSA (RSA24) de TSC
Introducción Esta vez se trata de un crackme realizado en VC++ 5.0/6.0 y en sus entrañas utiliza RSA-24. En este
Solución a los retos javascript de rogerfm.net
Introducción Javascript 1 (Serial a la vista) Javascript 2 (La función charAt()) Javascript 3 (Input) Javascript 4 (Fuerza bruta manual) Javascript
WinFan's NETCrackMe#1 Keygen
Introducción Tal y como nos adelanta el creador está programado en .NET. Lo abrimos para ver su comportamiento y a
Solución al CrackMe Matrix de ZemoZ
Introducción Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie

por ·Sin comentarios

Introducción

Esta vez se trata de un crackme realizado en VC++ 5.0/6.0 y en sus entrañas utiliza RSA-24. En este caso la peculiaridad es que el nombre no interviene en la generación del serial siendo un resultado único.

Resumen RSA

Parámetros

p = Primer número primo
q = Segundo número primo
e = Exponente público que cumpla MCD(e,(p-1)*(q-1))==1
n = Módulo público siendo n=p*q
d = Exponente privado que cumpla d=e^(-1) mod ((p-1)*(q-1))

De este modo e y n son la parte pública de la clave y d y n la parte privada. Los número primos p y q se utilizan solo para generar los parámetros y de ahí en adelante se pueden desechar.

Funciones de Cifrado/Descifrado

cifrado = descifrado ^ e mod n
descifrado = cifrado ^ d mod n

OllyDbg

Nuestro primer vistazo con OllyDbg nos muestra cuatro números de los que podemos hacernos una idea de que 9901 es un buen candidato a ser el exponente público (e) y 12790891 el módulo n ya que casualmente es un número de 24 bits. Los otros dos números de momento no nos dicen nada.

Referencias de texto

A continuación de los números tenemos la rutina de comprobación en la que comprueba que nuestro serial tenga 14 dígitos y lo divide en dos partes de 7 dígitos. Interesante ya que los otros dos números que aparecían en las referencias de texto tienen 7 dígitos cada uno.

004029CD  |.  68 DC004200   PUSH    RSA24.004200DC                         ;  ASCII "9901"
004029D2  |.  8D8C24 E40000>LEA     ECX,[DWORD SS:ESP+E4]
004029D9  |.  E8 52E7FFFF   CALL    RSA24.00401130
004029DE  |.  68 D0004200   PUSH    RSA24.004200D0                         ;  ASCII "12790891"
004029E3  |.  8D4C24 1C     LEA     ECX,[DWORD SS:ESP+1C]
004029E7  |.  C78424 640600>MOV     [DWORD SS:ESP+664],0
004029F2  |.  E8 39E7FFFF   CALL    RSA24.00401130
004029F7  |.  68 C8004200   PUSH    RSA24.004200C8                         ;  ASCII "8483678"
004029FC  |.  8D8C24 740200>LEA     ECX,[DWORD SS:ESP+274]
00402A03  |.  C68424 640600>MOV     [BYTE SS:ESP+664],1
00402A0B  |.  E8 20E7FFFF   CALL    RSA24.00401130
00402A10  |.  68 C0004200   PUSH    RSA24.004200C0                         ;  ASCII "5666933"
00402A15  |.  8D8C24 AC0100>LEA     ECX,[DWORD SS:ESP+1AC]
00402A1C  |.  C68424 640600>MOV     [BYTE SS:ESP+664],2
00402A24  |.  E8 07E7FFFF   CALL    RSA24.00401130
00402A29  |.  8B9424 680600>MOV     EDX,[DWORD SS:ESP+668]
00402A30  |.  83CE FF       OR      ESI,FFFFFFFF
00402A33  |.  8BFA          MOV     EDI,EDX
00402A35  |.  8BCE          MOV     ECX,ESI
00402A37  |.  33C0          XOR     EAX,EAX
00402A39  |.  C68424 600600>MOV     [BYTE SS:ESP+660],3
00402A41  |.  F2:AE         REPNE   SCAS [BYTE ES:EDI]
00402A43  |.  F7D1          NOT     ECX
00402A45  |.  49            DEC     ECX
00402A46  |.  83F9 0E       CMP     ECX,0E                                 ;  serial 0xE chars -> 14 digitos
00402A49  |.  0F85 63010000 JNZ     RSA24.00402BB2
00402A4F  |.  33C9          XOR     ECX,ECX
00402A51  |>  8A0411        /MOV     AL,[BYTE DS:ECX+EDX]                  ;  {
00402A54  |.  3C 30         |CMP     AL,30
00402A56  |.  0F8C 56010000 |JL      RSA24.00402BB2
00402A5C  |.  3C 39         |CMP     AL,39                                 ;  comprueba que el serial sea numerico
00402A5E  |.  0F8F 4E010000 |JG      RSA24.00402BB2
00402A64  |.  41            |INC     ECX
00402A65  |.  83F9 0E       |CMP     ECX,0E
00402A68  |.^ 7C E7         \JL      SHORT RSA24.00402A51                  ;  }
00402A6A  |.  8BC2          MOV     EAX,EDX
00402A6C  |.  C64424 17 00  MOV     [BYTE SS:ESP+17],0                     ;  {
00402A71  |.  C64424 0F 00  MOV     [BYTE SS:ESP+F],0
00402A76  |.  8B08          MOV     ECX,[DWORD DS:EAX]
00402A78  |.  894C24 10     MOV     [DWORD SS:ESP+10],ECX
00402A7C  |.  66:8B48 04    MOV     CX,[WORD DS:EAX+4]
00402A80  |.  66:894C24 14  MOV     [WORD SS:ESP+14],CX
00402A85  |.  8B4A 07       MOV     ECX,[DWORD DS:EDX+7]
00402A88  |.  8A40 06       MOV     AL,[BYTE DS:EAX+6]                     ;  divide el serial en dos partes de 7 digitos
00402A8B  |.  894C24 08     MOV     [DWORD SS:ESP+8],ECX
00402A8F  |.  884424 16     MOV     [BYTE SS:ESP+16],AL
00402A93  |.  8D42 07       LEA     EAX,[DWORD DS:EDX+7]
00402A96  |.  8D4C24 10     LEA     ECX,[DWORD SS:ESP+10]
00402A9A  |.  66:8B50 04    MOV     DX,[WORD DS:EAX+4]
00402A9E  |.  8A40 06       MOV     AL,[BYTE DS:EAX+6]                     ;  }

A continuación hace una serie de operaciones matemáticas para finalmente comparar el resultado con 8483678 y con 5666933. Lo que está haciendo es cifrar con nuestro serial en dos partes para comprobar que tenemos el número descifrado. Veamos un ejemplo con el serial 12345678901234.

descifrado ^ e mod n = cifrado
x1 = 1234567 y x2 = 8901234
1º parte del serial
x1 ^ 9901 mod 12790891 != 8483678
2º parte del serial
x2 ^ 9901 mod 12790891 != 5666933

Obviamente el resultado de las operaciones anteriores no da ese resultado y el Crackme nos tira fuera de modo que no nos queda más que atacar a RSA para obtener los primos p y q y el módulo privado d. De este modo podremos obtener los números buenos.

Los primos p y q se obtienen factorizando (botón Factor N) y una vez que tenemos p y q hallamos d (botón Calc. D). Todo esto es coser y cantar con la ayuda de la herramienta RSA-Tool 2. El exponente público e se introduce en hexadecimal.

Obteniendo p, q y d

Una vez que tenemos d hallamos el serial de forma sencilla con la herramienta Big Integer Calculator.

cifrado ^ d mod n = descifrado
1º parte del serial
8483678 ^ 10961333 mod 12790891 = 7167622
2º parte del serial
5666933 ^ 10961333 mod 12790891 = 3196885

SERIAL = 71676223196885
1º parte del serial
2º parte del serial

Enlaces

por ·Sin comentarios

Introducción

Los retos de Javascript son los retos más sencillos que podemos encontrar. Muchas veces solamente mirando el código fuente obtenemos la respuesta. Suponen una mala implementación de seguridad debido a que el código se ejecuta del lado del cliente, por lo que el código fuente es accesible y por lo tanto, javascript no garantiza seguridad alguna. En estos cinco casos haremos un recorrido por lo más básico, cinco retos fáciles de superar y que nos proporcionan los conocimientos base para Javascript. Dicho esto os puedo asegurar que en ocasiones he encontrado retos javascript realmente complicados que requieren de horas descifrarlos y en los que es fácil tirar la toalla.

Cuando el reto lo requiera, es buena idea utilizar un compilador online para obtener de forma rápida el valor de una variable o realizar una prueba concreta. Yo utilizo Jsfiddle para realizar pruebas pero existen muchos más.

Javascript 1

Este primer reto es lo básico, en el código fuente se pueden apreciar directamente el usuario y la clave.

<script language=JavaScript>
function Verify(name,pass)
{
if (name=="admin" & pass=="3***3")
	{
	location.href = name + pass + '.htm';
	}
else 
	{
	alert("Si ya fallamos el primero...");
	};
}
</script>

Javascript 2

Este segundo reto es bastante sencillo pero ya te obliga a conocer la función charAt() de Javascript. Dicha función lo que hace es coger el caracter indicado mediante un índice que comienza en cero. Por ejemplo si nombre = deurus y hacemos letra = nombre.charAt(3), estariámos extrayendo la cuarta letra, es decir, la letra r de la variable nombre.

function Verify(name,pass)
{
var name1 = "CrawlinG", pass1 = "capriccio"
	if (name==name1 & pass==pass1)
	{
	location.href = name + ".htm";
	}
else 
	{
	var x =  name1.charAt(7) + pass1.charAt(3)+ name1.charAt(2) + pass1.charAt(5) +  name1.charAt(5) + pass1.charAt(1);x = x.toLowerCase();
	var y =  name.charAt(3) + name.charAt(1) + pass.charAt(1)+ pass.charAt(6) +  pass.charAt(7) + name.charAt(2);var x1 = "des" + y;
	if (x==y){location.href = x1 + ".htm"}else{alert("Esto no va bien");location.href = "js2.htm"}
	}
}

Lo interesante está en la formación de las variables x e y. La variable x se forma de las variables name1 y pass1, formando la palabra gracia. Por otro lado, la variable y se forma con el nombre y clave que introduzcamos nosotros. Vemos que la variable x e y deben ser iguales, por lo tanto debemos construir un nombre (name) y una clave (pass) que cumpla con lo siguiente:

  • 4ª letra del nombre = 1ª letra de la palabra «gracia»
  • 2ª letra del nombre = 2ª letra de la palabra «gracia»
  • 2ª letra de la clave = 3ª letra de la palabra «gracia»
  • 7ª letra de la clave = 4ª letra de la palabra «gracia»
  • 8ª letra de la clave = 5ª letra de la palabra «gracia»
  • 3ª letra del nombre = 6ª letra de la palabra «gracia«

Como véis simplemente se trata de interpretar correctamente la función charAt() y de fijarse bien en los nombres de las variables.

Javascript 3

Este reto nos muestra diálogo donde nos pide la contraseña para validar el reto. Al fallar  o cancelar vuelve al índice para no dejarnos ver el código fuente. Aquí se pueden seguir varios caminos como bloquear el uso de javascript en el navegador o instalar un plugin en chrome o firefox para habilitar/deshabilitar de forma rápida el uso de javascript.

Una vez deshabilitado javascript vemos lo siguiente:

<script language="JavaScript" src="js3.gif" type=text/javascript>
<!--
function verify()
{
var pass="thebest";
var password=prompt("Introduce el password para superar el nivel","");
	if (password==pass)
		{
		location.href = pass + ".htm";
		}
	else
		{
		alert("No vamos bien...");
		location.href = "index.htm";
		}
}
//-->
</script>

Aquí el truco es darse cuenta que el código que se está ejecutando esta en «js3.gif» y no el código que nos muestra como válida la clave thebest. Si descargamos el archivo js3.gif y lo abrimos con un archivo de texto vemos nuestra querida clave.

function verify()
{
var pass="mo****ver";
var password=prompt("Introduce el password para superar el nivel","");
	if (password==pass)
		{
		location.href = pass + ".htm";
		}
	else
		{
		alert("No vamos bien...");
		location.href = "index.htm";
		}
}

Javascript 4

En este reto ya entramos con que la clave no es reversible y la debemos obtener por fuerza bruta. En este reto utiliza una nueva función como charCodeAt() que lo que hace es obtener el valor ascii del caracter indicado.

function Verify(pass1)
{
var cont1= 2, cont2= 6
var suma1 = 0, suma2 = 0
var pass2 = "FDRLF"
for(i = 0; i < pass1.length; i++) 
{
suma1 += (pass1.charCodeAt(i) * cont1);
cont1++
}
for(i = 0; i < pass2.length; i++) 
{
suma2 += (pass2.charCodeAt(i) * cont2);
cont2++
}
if (suma1==suma2)
{
window.location=suma1+".htm";
}
else
{
alert ("Algo no va bien...");
}
}

Vemos dos bucles en los que se calculan sendos valores suma que finalmente se comparan. la variable suma1 se calcula mediante nuestro password y la variable suma2 la obtiene de la palabra «FDRLF». Con el script que os muestro a continuación obtenemos que usando como clave deurus, suma1 = 3048 y suma2 = 2936. Nuestro punto de referencia es suma2 = 2936, de modo que vamos alterando con paciencia la variable pass1 obteniendo valores cercanos a 2936. Por ejemplo «deurua» nos da suma1 = 2922, un valor bastante cercano.

var pass1 = "deurus";
var cont1= 2, cont2= 6
var suma1 = 0, suma2 = 0
var pass2 = "FDRLF"
for(i = 0; i < pass1.length; i++) 
{
suma1 += (pass1.charCodeAt(i) * cont1);
cont1++
}
for(i = 0; i < pass2.length; i++) 
{
suma2 += (pass2.charCodeAt(i) * cont2);
cont2++
}
alert (suma1);
alert (suma2);

La solución a este reto es múltiple. Dos claves válidas son por ejemplo dfurqf y zwfabz.

Javascript 5

Este último reto es similar al anterior pero ya nos obliga a crearnos una pequeña herramienta que nos busque el serial válido.

function Verify(pass)
{
var suma=0
var cadena = "abcdefghijklmnopqrstuvwxyz"
for (var i = 0; i < pass.length; i++) 
	{
	var letra = pass.charAt(i)
	var valor = (cadena.indexOf(letra))
	valor++
	suma *= 26
	suma += valor
	}
if (suma==6030912063)
	{
	window.location=pass+".htm";
	}
else
	{
	alert ("Algo no va bien...");
	}
}

Para esta ocasión utiliza una nueva función llamada indexOf() que lo que hace es devolver un número entero que representa la posición en la que se encuentra el parámetro pasado a la función. Por ejemplo, si tengo variable = deurus y realizo posición = variable.indexOf(«s»), obtengo como resultado 5 (se empieza a contar desde cero).

Las operaciones que realiza el bucle son las siguientes:

  • Coge las letras del nombre una a una.
  • valor = posición de nuestra letra dentro de la variable de texto llamada cadena.
  • valor = valor + 1.
  • Multiplica la variable suma por 26.
  • Suma = suma + valor.

Aunque el proceso de recuperación de esta clave es algo más largo, podemos acortarlo introduciendo una clave de inicio de fuerza bruta próxima al objetivo. Al ser una función bastante lineal podemos rápidamente mediante pruebas con nuestro código de fuerza bruta o con un compilador online, establecer que la clave tendrá 7 caracteres e incluso que para ahorrar tiempo podemos aproximar la clave para que su valor suma esté cercano al valor suma buscado 6030912063.

Realizando pruebas obtenemos:

  • Clave = aaaaaaa -> suma = 321272407
  • Clave = zzzzzzz -> suma = 8353082582
  • Clave = smaaaaa -> suma = 6024332887
  • Clave = smkkkkk -> suma = 6029085437

Como vemos, la clave smkkkkk ya está bastante próxima al objetivo y será un buen punto para lanzar la fuerza bruta.

Os dejo el código de fuerza bruta en .Net

Module Module1
    Sub Main()
inicio:
        Console.WriteLine("-------------------------")
        Console.WriteLine("Modo [1] Prueba password")
        Console.WriteLine("Modo [2] Fuerza bruta")
        Console.WriteLine("-------------------------")
        Dim modo = Console.ReadLine()
        '
        If modo = 2 Then
            Console.WriteLine("¿Password para comenzar?")
            Dim pass = Console.ReadLine()
inicio2:
            Dim cadena As String = "abcdefghijklmnopqrstuvwxyz"
            Dim valor As Integer = 0
            Dim suma As Long = 0
            Dim letra As String
            For i = 0 To pass.Length - 1
                letra = Mid(pass, i + 1, 1)
                valor = cadena.IndexOf(letra)
                valor += 1
                suma *= 26
                suma += valor
            Next
            Console.WriteLine("Password: " & pass & " - Sum: " & suma.ToString)
            pass = IncrementString(pass)
            If suma = 6030912063 Then
                MsgBox("Password is " & pass)
            Else
                If pass = "aaaaaaaa" Then
                    Console.WriteLine("pass not found")
                    Console.ReadKey()
                Else
                    GoTo inicio2
                End If
            End If
        End If
        '------------------------------------------------
        If modo = 1 Then
            Console.WriteLine("Password:")
            Dim pass = Console.ReadLine()
            Dim cadena As String = "abcdefghijklmnopqrstuvwxyz"
            Dim valor As Integer = 0
            Dim suma As Long = 0
            Dim letra As String
            For i = 0 To pass.Length - 1
                letra = Mid(pass, i + 1, 1)
                valor = cadena.IndexOf(letra)
                valor += 1
                suma *= 26
                suma += valor
            Next
            Console.WriteLine("Password: " & pass & " - Sum: " & suma.ToString)
            Console.WriteLine(".......")
            Console.WriteLine("Good = 6030912063")
            Console.WriteLine("Suma = " & suma.ToString)
            Console.ReadKey()
            Console.Clear()
            GoTo inicio
        End If
    End Sub
    Function IncrementString(ByVal strString As String) As String
        '
        ' Increments a string counter
        ' e.g.  "a" -> "b"
        '       "az" -> "ba"
        '       "zzz" -> "aaaa"
        '
        ' strString is the string to increment, assumed to be lower-case alphabetic
        ' Return value is the incremented string
        '
        Dim lngLenString As Long
        Dim strChar As String
        Dim lngI As Long

        lngLenString = Len(strString)
        ' Start at far right
        For lngI = lngLenString To 0 Step -1
            ' If we reach the far left then add an A and exit
            If lngI = 0 Then
                strString = "a" & strString
                Exit For
            End If
            ' Consider next character
            strChar = Mid(strString, lngI, 1)
            If strChar = "z" Then
                ' If we find Z then increment this to A
                ' and increment the character after this (in next loop iteration)
                strString = Left$(strString, lngI - 1) & "a" & Mid(strString, lngI + 1, lngLenString)
            Else
                ' Increment this non-Z and exit
                strString = Left$(strString, lngI - 1) & Chr(Asc(strChar) + 1) & Mid(strString, lngI + 1, lngLenString)
                Exit For
            End If
        Next lngI
        IncrementString = strString
        Exit Function

    End Function
End Module

Enlaces

por ·Sin comentarios

Introducción

Tal y como nos adelanta el creador está programado en .NET. Lo abrimos para ver su comportamiento y a simple vista ya vemos algo que no nos gusta y es que se abre una ventana de DOS y posteriormente aparece el crackme. Esto indica que el ejecutable está escondido dentro de otro, empaquetado, encriptado o vete a saber.

Desempaquetado

Nuestras sospechas eran ciertas, abrimos el executable con ILSpy y no encontramos lo que buscamos, pero si vemos que al assembly se le hace algo parecido a un XOR. Probemos con algo sencillo, abrimos el crackme y la herramienta .Net Generic Unpacker y probamos a desempaquetar.
27-08-2014-2B12-33-33
Esto nos genera un par de «exes» que ahora si abre correctamente nuestro decompilador.

Decompilado

Vamos a fijarnos en la rutina de comprobación del serial. Lo interesante se encuentra en btnCheckClick y TLicense.
Código fuente.
Como vemos en el código, License.a.a, License.a.b y License.a.c cogen 8 dígitos y License.a.d coge 10. A continuación comprueba que Licenseb.a = License.a.a XOR License.a.b y que Licenseb.b = License.a.c XOR License.a.d.
Una imagen vale más que mil palabras.
En su día hice un keygen, aquí teneis una captura.
Podeis encontrar el crackme, mi solución y otras soluciones en crackmes.de.

Links

AfKayAs's CrackMe#2 KeyGen
Intro Hoy vamos a desmitificar un poco a Visual Basic. El Crackme reza que acabemos con la nag y hagamos
Temática Hacking
Libros Hacker Épico La apacible existencia de Ángel Ríos da un vuelco cuando una antigua compañera de clase, de la
VideoTutorial - KeyGen para el Crackme#1 de WinFan
http://youtu.be/b9-GdmIQINQ Lista de reproducción
Keygen para el CrackMe Pythagoras de Spider
Introducción Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por

por ·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Introducción

Realistic Challenge 2: You have heard about people being targeted by a new religion called Egitology. Another hacker infiltrated the group and discovered that the list of people they target is stored on the site but he doesn’t know where.

Break into the site, find the file and remove it. Also leave no evidence that you was ever there so they wont realise until its too late!

El enunciado del reto nos dice que tenemos que localizar la lista de objetivos y eliminarla sin dejar evidencias.

Analizando la seguridad de la víctima

Echamos un vistazo y vemos que tienen un Login para usuarios registrados, este será nuestro primer testeo.
Lo primero que se no viene a la cabeza con un formulario de este tipo es Inyección SQL, probamos varios métodos y tenemos suerte.
User: admin
Pass: ‘ or 1=1–‘;
 
 Vemos que hemos entrado como admin y enseguida nos llama la atención «Back up Database«. Pulsamos a ver que pasa.
 Obtenemos el hash de las claves de los usuarios Admin y SuperAdmin. Por suerte son hashes MD5. Obtenemos la clave de SuperAdmin y nos loguemos.

Solo nos queda borrar la lista de objetivos y nuestras huellas. Para ello borramos los siguientes archivos y reto superado.

Lista de objetivos: root/misc/targets
Logs: root/images/logs

Links

por ·Sin comentarios

Introducción

Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por eso, vamos a tener que lidiar con ciertas peculiaridades al realizar el keygen con un lenguaje de bajo nivel.

Al inicio comprueba la longitud del nombre y de el número de serie. El nombre debe tener al menos 6 caracteres y el número de serie debe tener 10. Os adelanto ya que la asignación de memoria del nombre es de 9 caracteres, es decir, da igual la longitud del nombre que solo va a usar 9.

004014AD | E8 1A 02 00 00           | call <pythagoras.GetWindowTextA>        | ;Lee el nombre
004014B2 | 83 F8 06                 | cmp eax,6                               | ;Nombre >=6 caracteres
004014B5 | 0F 82 03 01 00 00        | jb pythagoras.4015BE                    |
004014BB | 6A 14                    | push 14                                 |
004014BD | 68 D9 31 40 00           | push pythagoras.4031D9                  | ;004031D9:"1234567890"
004014C2 | FF 35 10 32 40 00        | push dword ptr ds:[403210]              |
004014C8 | E8 FF 01 00 00           | call <pythagoras.GetWindowTextA>        | ;Lee el serial
004014CD | 83 F8 0A                 | cmp eax,A                               | ;Serial debe tener 10 (A) caracteres
004014D0 | 0F 85 E8 00 00 00        | jne pythagoras.4015BE                   |

Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890

A continuación chequea que nuestro serial tenga caracteres hexadecimales.

004014DA | 8A 81 D9 31 40 00        | mov al,byte ptr ds:[ecx+4031D9]         | ; ecx+004031D9:"1234567890"
004014E0 | 3C 00                    | cmp al,0                                | ; contador del bucle
004014E2 | 74 1F                    | je pythagoras.401503                    | ; fin del bucle
004014E4 | 3C 30                    | cmp al,30                               | ; 0x30 = número 1
004014E6 | 0F 82 D2 00 00 00        | jb pythagoras.4015BE                    | ; < 30 bad boy
004014EC | 3C 46                    | cmp al,46                               | ; 0x46 = letra F
004014EE | 0F 87 CA 00 00 00        | ja pythagoras.4015BE                    | ; > 46 bad boy
004014F4 | 3C 39                    | cmp al,39                               | ; 0x39 = número 9
004014F6 | 76 08                    | jbe pythagoras.401500                   | ; <=39 ok continua el bucle
004014F8 | 3C 41                    | cmp al,41                               | ; 0x41 = letra A
004014FA | 0F 82 BE 00 00 00        | jb pythagoras.4015BE                    | ; <41 bad boy
00401500 | 41                       | inc ecx                                 | ; contador += 1
00401501 | EB D7                    | jmp pythagoras.4014DA                   | ; bucle

Continua realizando un sumatorio con nuestro nombre, pero tenemos que tener especial cuidado al tratamiento de los datos, ya que el crackme al estar hecho en ensamblador puede jugar con los registros como quiere y eso nos puede inducir a error.

0040150B | 3C 00                    | cmp al,0                                | ; ¿Fin bucle?
0040150D | 74 05                    | je pythagoras.401514                    | ; Salta fuera del bucle si procede
0040150F | 02 D8                    | add bl,al                               | ; bl = bl + al
00401511 | 41                       | inc ecx                                 | ; contador +=1
00401512 | EB F1                    | jmp pythagoras.401505                   | ; bucle

Si os fijáis utiliza registros de 8 bits como son AL y BL. Debajo os dejo una explicación de EAX pero para EBX es lo mismo.

               EAX
-----------------------------------
                         AX
                  -----------------
                     AH       AL
                  -------- --------
00000000 00000000 00000000 00000000
 (8bit)   (8bit)   (8bit)   (8bit)
 

  EAX     (32 bit)
--------
     AX   (16 bit)
    ----
    AHAL  (AH y AL 8 bit)
--------
00000000

El uso de registros de 8 bits nos implica tomar precauciones al realizar el Keygen debido a que por ejemplo, en .Net no tenemos la capacidad de decirle que haga una suma y que nos devuelva solamente 8 bits del resultado. Veamos como ejemplo para el nombre «deurus». La suma de los caracteres hexadecimales quedaría:

64+65+75+72+75+73 = 298, es decir, EAX = 00000298

Pero recordad que el crackme solo cogerá el 98 que es lo correspondiente al registro AL. De momento nos quedamos con nuestro SUMNOMBRE = 98.

Primera condición

A continuación coge los dos primeros caracteres del serial y les resta nuestro SUMNOMBRE y comprueba que el resultado esté entre 4 (0x4) y -4 (0xFC).

0040154B | 0F B6 05 F3 31 40 00     | movzx eax,byte ptr ds:[4031F3]          |
00401552 | 8A C8                    | mov cl,al                               |
00401554 | 2A CB                    | sub cl,bl                               | ; CL = CL - BL | CL = 12 - 98 = 7A
00401556 | 80 F9 04                 | cmp cl,4                                | ; Compara CL con 4
00401559 | 7F 63                    | jg pythagoras.4015BE                    | ; Salta si es mayor
0040155B | 80 F9 FC                 | cmp cl,FC                               | ; Compara CL con FC (-4)
0040155E | 7C 5E                    | jl pythagoras.4015BE                    | ; Salta si es menor

Como veis, el resultado de la resta da 7A (122) que al ser mayor que 4 nos echa vilmente. Aquí de nuevo utiliza registros de 8 bits por lo que debemos tener cuidado con las operaciones matemáticas para no cometer errores, veamos un ejemplo para clarificar de aquí en adelante.

Utilizando 8 bits
-----------------
12 - 98 = 7A que en decimal es 122

Utilizando 16 bits
------------------
0012 - 0098 = FF7A que en decimal es -134

Ahora ya veis la diferencia entre FC (252) y FFFC (-4). Estrictamente, el crackme comprueba el rango entre 4 (4) y FC (122) al trabajar con registros de 8 bits pero nosotros, como veremos más adelante tomaremos el rango entre 4 y -4. De momento, para poder continuar depurando cambiamos los dos primeros caracteres del serial de 12 a 98, ya que 98 – 98 = 0 y cumple la condición anterior.

Introducimos Nombre: deurus y Serial: 9834567890

Segunda condición

Analicemos el siguiente código.

00401560 | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
00401562 | 8B D8                    | mov ebx,eax                             | ; EBX = EAX
00401564 | 0F B7 05 F4 31 40 00     | movzx eax,word ptr ds:[4031F4]          | ; EAX = 3456 (4 dígitos siguientes del serial)
0040156B | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
0040156D | 03 D8                    | add ebx,eax                             | ; EBX = EBX + EAX
0040156F | 0F B7 05 F6 31 40 00     | movzx eax,word ptr ds:[4031F6]          | ; EAX = 7890 (4 últimos dígitos del serial)
00401576 | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
00401578 | 33 C3                    | xor eax,ebx                             | ; EAX
0040157A | 75 42                    | jne pythagoras.4015BE                   | ; Salta si el flag ZF no se activa

En resumen:

  • 98 * 98 = 5A40 (98²)
  • 3456 * 3456 = 0AB30CE4 (3456²)
  • 0AB36724 + 5A40 = 0AB36724
  • 7890 * 7890 = 38C75100 (7890²)
  • 38C75100 XOR 0AB36724 = 32743624
  • Si el resultado del XOR no es cero nuestro serial no pasa la comprobación.

Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²

Serial = aabbbbcccc

Tercera condición

Finalmente comprueba lo siguiente:

0040157C | 66 A1 F6 31 40 00        | mov ax,word ptr ds:[4031F6]             | ; AX = 7890
00401582 | 66 2B 05 F4 31 40 00     | sub ax,word ptr ds:[4031F4]             | ; AX = 7890 - 3456 = 443A
00401589 | 2C 08                    | sub al,8                                | ; AL = 3A - 8 = 32
0040158B | 75 31                    | jne pythagoras.4015BE                   | ; Si el resultado de la resta no ha sido cero, serial no válido
0040158D | 6A 30                    | push 30                                 |
0040158F | 68 B0 31 40 00           | push pythagoras.4031B0                  | ;004031B0:":-) Well done!!!"
00401594 | 68 7F 31 40 00           | push pythagoras.40317F                  | ;0040317F:"Bravo, hai trovato il seriale di questo CrackMe!"
00401599 | FF 75 08                 | push dword ptr ds:[ebp+8]               |

En resumen:

  • 7890 – 3456 – 8 = 0

Creación del Keygen

Nuestro serial tiene que cumplir tres condiciones para ser válido.

  • a – SUMNOMBRE debe estar entre 4 y -4
  • c² = a² + b²
  • c – b – 8 = 0

Como hemos dicho anteriormente, tomaremos el SUMNOMBRE y le sumaremos y restaremos valores siempre y cuando el resultado esté entre 4 y -4. Para deurus hemos dicho que el SUMNOMBRE es 98 por lo que los posibles valores de «a» se pueden ver debajo. Además debemos tener en cuenta que el crackme solo lee los 9 primeros dígitos del nombre.

98-4 = 94		
98-3 = 95		
98-2 = 96		
98-1 = 97		
98-0 = 98		
98+1 = 99		
98+2 = 9A		
98+3 = 9B		
98+4 = 9C

Es evidente que para encontrar el valor de «c» vamos a tener que utilizar fuerza bruta chequeando todos los valores  de «b» comprendidos entre 0 y FFFF (65535). Además, como trabajaremos en un lenguaje de alto nivel, debemos descartar los resultados decimales. Esto nos limitará los seriales válidos asociados a un determinado nombre. Si realizáramos el keygen en ensamblador obtendríamos bastantes más seriales válidos.

Una vez encontrados los valores enteros de la operación «c² = a² + b²», se debe cumplir que «c – b – 8 = 0», lo que nos limitará bastante los resultados.

    Private Sub btn_generar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_generar.Click
        Try
            If txt_nombre.TextLength > 5 Then
                lst_serials.Items.Clear()
                Dim tmp, c, cx As String
                Dim sumanombre, tmp2 As Integer
                If txt_nombre.TextLength > 9 Then tmp2 = 8 Else tmp2 = txt_nombre.TextLength - 1
                'Calculo el SUMNOMBRE
                For i = 0 To tmp2
                    sumanombre += Asc(Mid(txt_nombre.Text, i + 1, 1)) 'Acumulo suma
                    tmp = Strings.Right(Hex(sumanombre).ToString, 2)  'Solo 8 bits (Registro AL)
                    sumanombre = Val("&H" & tmp) 'Paso a decimal
                Next
                tmp = Strings.Right(Hex(sumanombre).ToString, 2)
                sumanombre = CInt("&H" & tmp)
                txtdebug.Text = "- SumNombre = " & Hex(sumanombre) & vbCrLf
                txtdebug.Text &= "----------------------------------------------" & vbCrLf
                Dim a(8) As Integer
                '
                'a - sumanombre >=4 y <=4
                '
                a(0) = sumanombre - 4
                a(1) = sumanombre - 3
                a(2) = sumanombre - 2
                a(3) = sumanombre - 1
                a(4) = sumanombre
                a(5) = sumanombre + 1
                a(6) = sumanombre + 2
                a(7) = sumanombre + 3
                a(8) = sumanombre + 4
                txtdebug.Text &= "- Posibles valores de 'a'" & vbCrLf
                For i = 0 To a.Length - 1
                    txtdebug.Text &= Hex(a(i)) & " "
                Next
                txtdebug.Text &= "----------------------------------------------" & vbCrLf
                txtdebug.Text &= "- Buscando valores de b y c" & vbCrLf
                txtdebug.Text &= "Serial = aabbbbcccc" & vbCrLf
                '
                'c = sqr(a^2 + b^2)
                '
                txtdebug.Text &= "(1) c = raiz(a^2 + b^2)" & vbCrLf
                txtdebug.Text &= "(2) c - b - 8 = 0" & vbCrLf
                For i = 0 To a.Length - 1 ' todas las posibilidades de a
                    For b = 0 To 65535 'b -> 0000 - FFFF
                        c = Math.Sqrt(a(i) ^ 2 + b ^ 2)
                        If c.Contains(".") Then 'busco enteros
                        Else
                            cx = c - b - 8
                            cx = Hex(cx).PadLeft(4, "0"c)
                            lbl_info.Text = cx
                            If cx = "0000" Then
                                txtdebug.Text &= " (1) " & Hex(c).PadLeft(4, "0"c) & " = raiz(" & Hex(a(i)).PadLeft(2, "0"c) & "^2 + " & Hex(b).PadLeft(4, "0"c) & "^2)" & vbCrLf
                                lst_serials.Items.Add(Hex(a(i)).PadLeft(2, "0"c) & Hex(b).PadLeft(4, "0"c) & Hex(c).PadLeft(4, "0"c))
                                txtdebug.Text &= " (2) " & Hex(c).PadLeft(4, "0"c) & " - " & Hex(b).PadLeft(4, "0"c) & " - 8 = 0" & vbCrLf
                            End If
                        End If
                        Application.DoEvents()
                    Next
                Next
                lbl_info.Text = "Búsqueda finalizada"
            End If
        Catch ex As Exception
            MsgBox(ex.ToString)
        End Try

Enlaces

por ·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Intro

This crackme is for the crack challenge 6 of canyouhack.it.

In this crackme the goal is to turn on all the lights. Note that a light off to the next, so if we interrupt this, we win.

Tools

Exeinfo (For crackme info)

Delphi Decompiler (For decompile)

 OllyDbg (For debug)

Decompiling

With Delphi Decompiler we can found easy the buttons and his offsets.
Go to the offset 401A64 in OllyDbg and analyze the code.
We view two jumps, one turn ON the light and the other Turn OFF the next light. Patching the call from offset 401A8B we get the serial.

Links

VideoTutorial - KeyGen para el Crackme#2 de AfKayAs
http://youtu.be/mk_rzitZ4CM Lista de reproducción
Yoire PE Stage 2 Reversing Challenge (Crackme Very Hard) - eXORcism
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
ideku_nih's Code this Keygen
Introducción Hoy tenemos aquí un crackme hecho en Visual Basic 6 (pcode), pero lo vamos a abordar de una manera
ThisIsLegal.com - User Challenge 1 (Javascript)
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

por ·Sin comentarios
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si continuas leyendo este manual es que no utilices la respuesta para completar la prueba sin esfuerzo. 😉

Analizando…

Cargamos el crackme en Ollydbg y vamos a las «Referenced Strings«. Vemos una referencia muy interesante que se llama «checkkey«.

 Pinchamos sobre ella y aparecemos aquí:

Vemos una referencia a «GetDlgItemTextA» y depués un Call también interesante, vamos a explorarlo.

Entendiendo la rutina de comprobación del serial

 

Dentro del Call hay dos bucles, uno realiza una operación con nuestro serial (bucle nombre) y el otro comprueba nuestro serial con «3d34273130276a» dígito a dígito (bucle comprobación).

Bucle nombre se puede resumir así:

MOVSX EAX,BYTE PTR DS:[EBX]   --> Dígito a EAX
XOR EAX,55                    --> EAX xor 55
...
CMP BYTE PTR DS:[EBX],0       --> ¿hemos acabado?
JNZ SHORT 10001022            --> bucle
LEA ECX,DWORD PTR SS:[EBP-20] --> ECX = nuestro serial xoreado

Bucle comprobación se podría resumir así:

MOV EDX,10006000             --> EDX = "3d34273130276a"
...
MOV AL,BYTE PTR DS:[ECX]     --> AL = 1ºdígito serial xoreado
CMP AL,BYTE PTR DS:[ECX+EDX] --> AL = 1ºdígito de EDX?
JNZ SHORT 1000105A           --> Si no son iguales bad boy
INC ECX 

TEST AL,AL
JNZ SHORT 1000104A           --> bucle

Ejemplo para «deurus».

   Nombre: d  e  u  r  u  s
Ascii hex: 64 65 75 72 75 73 
   XOR 55: 31 30 20 27 20 26

Serial XOReado para deurus sería = 313020272026 que obviamente se aleja bastante de 3d34273130276a.
Por suerte XOR es una función reversible por lo que si revertimos 3d34273130276a nos dará el serial correcto.

Serial correcto XOReado: 3d 34 27 31 30 27 6a
XOR 55:                  68 61 72 64 65 72 3F
Valor ascii:             h  a  r  d  e  r  ?

Links

CanYouHack.it Crack6 Challenge - Lights Out (English)
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
ThisIsLegal.com - Realistic Challenge 3
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Videotutorial - KeyGen para el Crackme#8 de Kwazy Webbit
https://www.youtube.com/watch?v=iOYAn4l4wco Lista de reproducción
This little bunny CrackMe
AVISO: Debido a que este reto está en activo no publicaré a donde pertenece. En este pequeño CrackMe se nos

por ·Sin comentarios

Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de programación esotérico bastante complejo.

[-]>[-]<>++++++++[<++++++++++>-]<.+++++++++++++++++.>+++[<++++++>-]<..++++.-
-------.+++.--------------.>++++++[<------>-]<-.>+++++[<------>-]<-.,>,>,>,>
>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++
+++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++>>>>++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<
<<<<<<<<<<<<<<<<[>>>>>>>-<<<<<<<-]>>>>>>><<+>>[[-]++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.<]<[>]<<<<<[>>>>>>>>>>-<<<<<<<<
<<-]>>>>>>>>>><<+>>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++.<]<[>]<<<<<<<<[>>>>>>>>>>>>>-<<<<<<<<<<<<<-]>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.<]<[>]<<<<<<<<<<<[>>>>>>>>>>>>>>>>-<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++.<]<[>]>>>[-]>[-]<+++++++++++++.---.>+++++++[<++++++++++++>-]<.>+++++++[<
--------->-]<+.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------
->-]<.>++++++++[<+++++++++>-]<+.+++++++++++.>+++++++[<----------->-]<.>+++++
++[<+++++++++++>-]<-.>+++++++[<------------>-]<+.>++++++++[<+++++++++++>-]<-
.-----.---------.+++++++++++..---------------.+++++++++.>++++++[<-----------
-->-]<.+++++++.>+++++[<++++++>-]<+.-----.++++++++.+++.>++++++[<------>-]<-.-
------.>++++++++[<++++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>++
+++[<++++++>-]<+.-----.+++++++++++.>++++++[<------>-]<-.-------.>++++++++[<+
+++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>+++++[<+++++>-]<+.+++
+++++.+++.>++++++[<------>-]<-.+++++++...--------------.>++++++++[<+++++++++
++>-]<+.----------.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-
]<.-------.>+++[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++
+++++[<++++++++++>-]<.-----.++++++++.+++.-------.-.>++++++[<--------->-]<.--
------------.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------->
-]<.>+++++++[<++++++++++++>-]<.------------.---.+++++++++++++.-------------.
>+++++++[<---------->-]<+.>++++++++[<+++++++++>-]<+.++++++++++.>+++++++[<---
--------->-]<+.>++++++[<+++++++++++++>-]<.+.+++++.------------.+.+++++.-----
--.>++++++[<---------->-]<+.------------.>++++++++[<+++++++++++>-]<+.-------
---.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-]<.-------.>+++
[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++++++++[<+++++++
++++>-]<-.--------------.+++++.>++++++[<------------->-]<.+.

La solución que he encontrado yo, es convertir el código brainfuck a algo más amigable y depurarlo hasta encontrar la solución. La conversión la he realizado con VBBrainFNET y luego la depuración con Visual Studio. El crackme te pide una clave de cuatro cifras para darte la solución, pero si no quieres volverte loco puedes amañar los bucles para encontrar la solución.

¡SUERTE!

Enlaces

 

por ·Sin comentarios

Intro

Hoy vamos a hacer algo diferente, vamos a hacer un keygen con la propia víctima. El término anglosajón para esto es «selfkeygening» y no es que esté muy bien visto por los reversers pero a veces nos puede sacar de apuros.

La víctima elegida es el Crackme 2 de LaFarge. Está hecho en ensamblador.

Injerto Light

Primeramente vamos a realizar un injerto light, con esto quiero decir que vamos a mostrar el serial bueno en la MessageBox de error.

Abrimos Olly y localizamos el código de comprobación del serial, tenemos suerte ya que el serial se muestra completamente y no se comprueba byte a byte ni cosas raras. En la imagen inferior os muestro el serial bueno para el nombre deurus y el mensaje de error. Como podeis observar el serial bueno se saca de memoria con la instrucción PUSH 406749 y el mensaje de error con PUSH 406306.

parche01

Si cambiamos el PUSH del serial por el de el mensaje de error ya lo tendriámos. Nos situamos encima del PUSH 406306 y pulsamos espacio, nos saldrá un diálogo con el push, lo modificamos y le damos a Assemble.

10-09-2014 20-37-18

Ahora el crackme cada vez que le demos a Check it! nos mostrará:

nagserial

Keygen a partir de la víctima

Pero no nos vamos a quedar ahí. Lo interesante sería que el serial bueno lo mostrara en la caja de texto del serial. Esto lo vamos a hacer con la función user32.SetDlgItemTextA.

setdlgitemtext

Según dice la función necesitamos el handle de la ventana, el ID de la caja de texto y el string a mostrar. La primera y segunda la obtenemos fijándonos en la función GetDlgItemTextA que recoje el serial introducido por nosotros. La string es el PUSH 406749.

handleandid

Con esto ya tenemos todo lo que necesitamos excepto el espacio dentro del código, en este caso lo lógico es parchear las MessageBox de error y acierto. Las seleccionamos, click derecho y Edit > Fill with NOPs.

10-09-2014 20-39-24

nopeamos

Ahora escribimos el injerto.

injertokeygen

Finalmente con Resource Hack cambiamos el aspecto del programa para que quede más profesional y listo. Tenemos pendiente hacer el keygen puro y duro, venga agur.

10-09-2014 21-04-52

Links

Blooper Tech Movie XIII – Copycat
Hoy analizamos Copycat, un thriller psicológico de 1995 que, como muchas películas de la época, no pudo resistirse a incorporar
Retos de encriptación XOR de Yoire
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Shadow's Register Me - Parchear un .Net
Introducción Este es un crackme hecho en .Net con dos Nags a parchear y un algoritmo muy sencillo pero que
CanYouHack.it Crack6 Challenge - Lights Out (English)
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

por ·Sin comentarios

Hoy analizamos Copycat, un thriller psicológico de 1995 que, como muchas películas de la época, no pudo resistirse a incorporar elementos tecnológicos que, vistos desde una perspectiva actual, nos sacan una sonrisa. Vamos a desmontar algunos gazapos tecnológicos y curiosidades relacionadas con los sistemas informáticos que aparecen en la película.

El escritorio de tres pantallas: ¿el futuro en 1995?

La protagonista, la Dra. Helen Hudson (Sigourney Weaver), trabaja en un escritorio con tres pantallas, algo futurista para la época. En 1995, esto no era tan común como hoy en día. Para lograrlo, probablemente necesitaría tres ordenadores conectados de forma independiente, ya que los sistemas operativos y hardware de la época no solían soportar múltiples monitores en una sola máquina. Esto plantea preguntas interesantes sobre la logística de su set-up: ¿Cómo sincronizaba su trabajo entre tres PCs?

Un detalle curioso es que, en algunas tomas, se distingue la marca Compaq en los equipos. Compaq era una de las compañías líderes en la fabricación de ordenadores personales durante los 90 y conocida por sus soluciones de alta calidad. Este dato refuerza la idea de que el set-up de Helen estaba diseñado para representar lo último en tecnología de la época, aunque hoy resulte un tanto rudimentario. La elección de Compaq no es casual: en ese momento, era sinónimo de equipos potentes, usados tanto en oficinas como en entornos domésticos avanzados.

Internet y la magia de los módems

En una escena, Helen navega por internet con lo que suponemos es un módem de 28.8 kbps (o como mucho, un flamante 33.6 kbps, tecnología de vanguardia allá por 1995). Hasta ahí, vale. Sin embargo, la fluidez de su conexión sorprende: carga archivos, recibe correos y no se queda esperando con una pantalla de “Conectando…”. Pero lo mejor llega cuando, estando conectada, ¡suena el teléfono! En la realidad, esto cortaría la conexión o comunicaría, a menos que tuviera dos líneas telefónicas (algo raro en domicilios particulares de la época) o algún dispositivo milagroso que no conocemos.

¿Qué sistema operativo usa?

Aunque no se distingue claramente el sistema operativo, vemos una interfaz gráfica con ventanas y una consola de comandos. Esto podría ser un guiño a Windows 3.1 o Windows 3.11, ya maduro en esa época aunque la interfaz no termina de encajar. Sin embargo, también podría ser una mezcla ficticia para hacer que el entorno luciera “tecnológico” sin comprometerse demasiado con la realidad. Detalle curioso: en los 90, las películas solían personalizar las interfaces para no tener problemas legales.

El email como el epicentro de la tecnología

En los 90, el email era el rey. En las películas, los escritorios siempre tenían un gran icono de correo (a menudo animado, porque lo cool siempre parpadeaba). En Copycat, Helen recibe un correo con un archivo AVI de unos 30 segundos, lo cual plantea otra duda técnica: ¿Cuánto espacio ocupaba ese archivo en 1995?

Un AVI de 30 segundos probablemente tendría una resolución baja (320×240 píxeles o menos) y una tasa de compresión eficiente para la época, pero aun así podría pesar entre 2 y 5 MB, dependiendo de la calidad del audio y vídeo. Eso hubiera supuesto una odisea por email, ya que los servidores de la época limitaban los adjuntos a unos pocos cientos de KB. ¿Quizás el villano usó un protocolo privado para saltarse las restricciones?

Tomorrow.AVI

Tras recibir un inquietante archivo AVI, la protagonista llama a la policía, lo que desencadena una conversación cargada de decisiones tecnológicas cuestionables:

  • «¿Cómo le han enviado esto?» / «Consiguiendo su dirección de internet»: El archivo es descrito como enviado a través de «su dirección de internet», un término extraño para la época en la que lo habitual habría sido referirse al correo electrónico. Esto refleja un intento de sonar sofisticado sin usar los términos correctos.
  • «¿No podríamos localizarlo?»: La respuesta de los policías es que no pueden rastrear el origen del archivo «a no ser que esté conectado». Sin embargo, incluso en 1995, las cabeceras de los emails contenían suficiente información para rastrear el servidor de origen, aunque la práctica era más rudimentaria que en la actualidad. Ignorar esto parece una licencia creativa del guion o un concepto equivocado de localizar asociándolo quizá a las llamadas telefónicas.
  • «Es demasiado grande para pasarlo a disco»: Aquí surge el principal obstáculo: el archivo AVI es considerado «demasiado grande» para transferirlo a un disquete de 3,5 pulgadas (con una capacidad máxima de 1,44 MB). Aunque esto tiene sentido desde una perspectiva técnica, resulta extraño que fuera posible enviarlo por email en primer lugar, dado que los servidores de correo de la época tenían limitaciones más estrictas que un disquete. Esto sugiere una inconsistencia en la lógica tecnológica de la escena.
  • «Lo pasaremos a vídeo»: Ante la imposibilidad de transferirlo a un disquete, la solución propuesta es convertir el archivo a un formato reproducible en un dispositivo analógico (probablemente una cinta VHS) para transportarlo físicamente. Aunque esta decisión es plausible dentro de las limitaciones tecnológicas de la época, omite soluciones más digitales, como volver a enviarlo por email (¿acaso la policía no tenía correo electrónico?). Además, surge la pregunta de por qué no se recurre a los forenses técnicos de la policía (o del FBI) para analizar el disco duro, quienes, curiosamente, no aparecen en ningún momento de la película.
  • «Oh, Dios. ¿Cómo sabes todas estas cosas?» / «Malgasté mi juventud en los salones de videojuegos»: Esta frase añade un toque humorístico, pero no tiene relación alguna con las habilidades necesarias para resolver el problema en cuestión. Más bien, refuerza la desconexión entre los diálogos y las acciones tecnológicas presentadas.

Conclusión

Copycat (1995) es un buen ejemplo de cómo el cine de los 90 abordaba la tecnología con una mezcla de admiración y confusión. Desde la exageración de tener tres monitores en el escritorio de Helen hasta la torpe gestión del archivo Tomorrow.AVI, la película refleja tanto las limitaciones tecnológicas de la época como las libertades creativas de los guionistas.

En el caso del archivo AVI, los personajes deciden que no se puede gestionar digitalmente y optan por convertirlo a vídeo analógico, ignorando soluciones más simples como volver a enviarlo por correo electrónico (suponiendo que fuera posible). Este detalle, combinado con la ausencia aparente de personal técnico en la policía, subraya una desconexión entre la narrativa y las capacidades reales de la tecnología, incluso para 1995.

Aunque estos detalles pueden parecer cómicos 30 años después, forman parte del encanto de un cine que imaginaba el futuro sin comprender del todo su presente. Más que errores, son un recordatorio de cómo la tecnología ha evolucionado y de cómo nuestra percepción de ella también lo ha hecho.

Enlaces

  • Copycat [IMDb]
  • Historia de Internet [Wikipedia]
  • Correo electrónico [Wikipedia]
  • Compaq [Wikipedia]
  • Silicon Cowboys: la historia de cómo Compaq retó (y venció) a IBM y Apple [Xataka]
  • Formato de vídeo AVI [Wikipedia]
  • Analysis of video file formats in forensics (.avi example) [DiViLine]

Galería

por ·1 comentario

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Introducción

El cifrado XOR es uno de los algoritmos más utilizados en el mundillo de la encriptación. Aunque por sí solo no es seguro, suele formar parte de cifrados más complejos e incluso si sois aficionados a los crackmes os habréis dado cuenta de que raro es el crackme que no lo utiliza.

Hoy vamos a hacer un recorrido sobre los retos de encriptación que nos propone yoire.com, que aunque son muy sencillos, nos proporcionan una estupenda base para iniciarnos en este tipo de retos.

/challenges/crypt/xor/0_chall_very_easy

En este primer reto, el autor te da directamente la solución, ya que, nos da un texto cifrado y nos dice que está cifrado con la clave 10. Lo que el autor no indica es que la clave es hexadecimal, mas adelante ya aprendereis a fijaros en esos detalles.

Texto cifrado: uqci0t~7d0ie0dxy~{

Clave: 10

challenges_crypt_xor_0_chall_very_easy

/challenges/crypt/xor/1_chall_easy

Esta vez disponemos de un texto cifrado pero sin pistas. Si nos fijamos en el código fuente veremos que la clave utilizada esta vez es 20 y decimal.

<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Easy"));
print Challenges::header();
?>
Convierte la solución que está cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php

$solution_xored="m{a4s{`4}`5";
$key           = sprintf("%2x",20);
$solution      = Crypt::XorData($solution_xored,$key);

print "La solución es: ".$solution_xored;

print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>

challenges_crypt_xor_1_chall_easy

/challenges/crypt/xor/2_chall_mid

En esta ocasión debemos ojear el código fuente para averiguar como solucionar el reto. En esta ocasión y como de lo que se trata es de aprender, este lo dejaré sin solucionar.

<?php 
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Mid"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php

foreach (
        preg_split("/\./","2.4.10.71.3698") 
        as $something
        ) 

$value=pow($something,2);

$key            = dechex($value);
$solution_xored = base64_decode("ucSnos+lo8Oqtw==");
$solution       = Crypt::XorData($solution_xored,$key);

print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>

<?php
if(Common::getString("showSource")!==false) {
    print "<hr>";
    highlight_file(__FILE__);
}
print Website::footer();
?>
  • Lo primero es mediante un compilador online de PHP, obtener la variable $key.
  • Decodificar la clave xoreada «ucSnos+lo8Oqtw==«.
  • Solución = base64_decode(«ucSnos+lo8Oqtw==») XOR $key

Venga que casi lo tienes.

/challenges/crypt/xor/3_chall_average

En este reto nos indican que el código fuente está encriptado. Cuando nos enfrentamos a XOR en texto grandes y teniendo un indicio de lo que puede contener el código desencriptado es sencillo encontrar lo que buscamos. En este caso en concreto podemos intuir que seguramente el texto contenga la palabra «php«, una vez llegamos a esa conclusión la solución llega sola. Este método no deja de ser un ataque por fuerza bruta.

Código encriptado

lo 8 p]Z9>3<%45xr~~~~~~3?"5~ 8 ryk]Z "9>$p52#9$5jj85145"x1""1)xr$9


lt;5rmnr85pp81<$p81<<5>75#jj85145"xyk]Zon]Z1"535p!%5p5$5p81p#94?p396"14?~~~p%===~~~p$5>4"±#p!%5p1&5"97%1"p3£=?p 1"1p?2$5>5"p<1p"5# %5#$1p1p5#$5p"5$?j]Zl2"nl2"n]Zlo 8 ]Z]Zt;5)ppppppppppppmpre`rk]Zt=5pppppppppppppmp69<575$3?>$5>$#xyk]Zt=5(?"54pppppppmp") $jj?"1$1xt=5|t;5)yk]Z]Z "9>$p81<<5>75#jj#?<%$9?>?(xyk]Z "9>$p81<<5>75#jj3853;?<%$9?>xr3````aryk]Zon]Zl1p8"56mrlomtrr onolom%"<5>3?45x") $jj?"1$1xr#8?'?%"35r|t;5)yyonrn5"p3£497?p6%5>$5l1n]Z]Zlo 8 ]Z96x?==?>jj75$$"9>7x") $jj?"1$1xr#8?'?%"35r|t;5)yyqmm61<#5yp+]ZY "9>$prl8"nrk]ZY "9>$pt=5(?"54k]Z-]Z "9>$p52#9$5jj6??$5"xyk]Zon]Z


Código desencriptado


challenges_crypt_xor_3_chall_average


/challenges/crypt/xor/4_chall_hard


En este último reto nos aparece un mensaje que nos dice «La solución es: 7b1a4147100a155a0f45574e0f58«. Nos fijamos en el código fuente y vemos que en la encriptación interviene una cookie llamada «PHPSESSID«.


Código fuente


<?php 
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Hard"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php

$sessid             = isset($_COOKIE["PHPSESSID"])?$_COOKIE["PHPSESSID"]:">hi!|m¬_ö_Ó_;m'`ñ·$\"<";
$key                = Encoder::asc2hex($sessid);
$hiddenSolution     = file_get_contents(Config::$challsHiddenData."crypt_xor_average.solution");
$hex_xored_solution = Encoder::data2hex(Crypt::XorData($hiddenSolution,$key));

print "La solucion es: ".$hex_xored_solution;

print "<br><br>";

print Challenges::solutionBox();
print Challenges::checkSolution($hiddenSolution);
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>

<?php
if(Common::getString("showSource")!==false) {
    print "<hr>";
    highlight_file(__FILE__);
}
print Website::footer();
?>


Desde Firefox vamos a usar una extensión muy interesante llamada Advanced Cookie Manager que nos permitirá visualizar y modificar dicha cookie.


challenges_crypt_xor_4_chall_hard_02


Una particularidad de la encriptación XOR es que si realizamos «algo XOR 0 == algo«, por lo que un ataque típico sería anular la cookie. La modificamos poniendo como valor 0 y guardamos. Recargamos la web con F5 y ahora nos fijamos que el valor de la solución ha cambiado a «7e5f4410435f1058514254100a19«. Finalmente y teniendo en cuenta que el texto que tenemos es hexadecimal, hacemos fuerza bruta marcando la opción Output First y clickamos en Search.


crypt_xor_4_chall_hard_2


En el mismo directorio donde tenemos el programa se genera un archivo llamado «XOR_enumeration.txt«, que contiene todos los resultados, echamos un vistazo y hemos tenido suerte.


crypt_xor_4_chall_hard_3


Enlaces


								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						

Introducción


Este es un crackme hecho en .Net con dos Nags a parchear y un algoritmo muy sencillo pero que tendremos que parchear para poder resolverlo.


Las Nags


Se encuentran en los eventos de carga y cierre del formulario.


01-09-2014 07-30-07


// RegisterMe.Form1
private void Form1_Load(object sender, EventArgs e)
{
    Interaction.MsgBox("Register me pl0x!", MsgBoxStyle.OkOnly, "Nag!!!!");
}

// RegisterMe.Form1
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    Interaction.MsgBox("Register me pl0x!", MsgBoxStyle.OkOnly, "Nag2!!!!");
}


 Para parchear un ejecutable realizado en .Net primero necesitamos ubicarnos. Abrimos IL Dasm y vamos al evento «Form_Load«, nos fijamos en los bytes y los buscamos con un editor hexadecimal. Fijaros bien en los bytes ya que siguen un orden específico, en la imágen del editor hexadecimal se aprecia perfectamente. Para que quede parcheada la Nag basta con sustituir los valores por ceros. Se parchea todo excepto el «RET (2A)».


01-09-2014 08-03-23


01-09-2014 08-04-01


Para la  otra Nag sería lo mismo.


El algoritmo


El algoritmo es muy sencillo, consiste en la concatenación de varias palabras y un número aleatorio. El problema viene con el número aleatorio ya que lo tendremos que parchear para poder registrar el programa.


// RegisterMe.Form1
private void Button1_Click(object sender, EventArgs e)
{
    this.shadow = this.rand.Next(1, 99999999);
    if (Operators.ConditionalCompareObjectEqual(this.TextBox2.Text, Operators.ConcatenateObject(this.TextBox1.Text + this.TextBox3.Text + this.TextBox4.Text + this.TextBox5.Text + this.TextBox6.Text + this.TextBox7.Text + this.TextBox8.Text + this.TextBox9.Text + this.TextBox1.Text, this.shadow), false))
    {
        this.Button2.Enabled = true;
        this.Button1.Enabled = false;
        this.Button1.Text = "Registered to Shadow";
        this.Text = "Registered to Shadow!";
    }
    else
    {
        Interaction.MsgBox("Incorrect serial, noob.", MsgBoxStyle.OkOnly, null);
    }
}


La concatenación quedaría así:


TextBox1.Text = Nuestro usuario + TextBox3.Text = «ur» + TextBox4.Text = «a» + TextBox5.Text = «stupid» + TextBox6.Text = «dumb» + TextBox7.Text = «idiotic» + TextBox8.Text = «crazy» + TextBox9.Text = «noob» + TextBox1.Text = Nuestro usuario + El número aleatorio


 Ejemplo


    

  • Nombre: deurus
    • 

  • Clave: deurusurastupiddumbidioticcrazynoobdeurus98265385
    • 



Parcheando el número aleatorio


Buscamos el evento click en IL Dasm y nos fijamos que aparece el número «5F5E0FF» que en decimal equivale a «99999999«, buscamos los bytes en el editor hexadecimal y lo parcheamos a 1. De este modo anulamos la aletoriedad, ahora el número siempre es 1.


01-09-2014 09-25-23


01-09-2014 09-35-35


01-09-2014 09-36-59


Ahora ya podemos registrarnos.


01-09-2014 07-38-44


Links





    

        

      

        

        

  

        

                    Andy's Keygenme Keygen (AutoIt)
            

    

        Introducción  Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro            

            
      

    

  

        

        

  

        

                    ¿El crackme de android más famoso del mundo?
            

    

        Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar            

            
      

    

  

        

        

  

        

                    Blooper Tech Movie IV – La Jungla 4.0 (Live Free or Die Hard)
            

    

        La esperada cuarta entrega de La Jungla de Cristal se metió de lleno en el mundo de los Hackers. Cuando            

            
      

    

  

        

        

  

        

                    Stego XVI - Bytes
            

    

        Intro Os comparto un reto stego que me gustó cuando lo hice hace unos años. En realidad se tarda pocos            

            
      

    

  
    

    
      
      
    
  
  



								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						
Introducción


 Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro keygen. Como comprobareis si no se ofusca o se toman otro tipo de medidas recuperar información sensible es muy sencillo.




AutoIt es un lenguaje freeware multiproposito y de automatización para Microsoft Windows. Es un Visual Basic Killer, ya que mejora las características de los ejecutables (entre otras portabilidad, velocidad y peso, no fat-coding), y facilitan la programación con un buen repertorio de funciones «pre-diseñadas», y usando un Basic de fácil aprendizaje. Se ha expandido desde sus comienzos de automatización incluyendo muchas mejoras en el diseño del lenguaje de programación y sobre todo en nuevas funcionalidades.




El Script


Func CHECKKEY($USER, $PASS)
Local $OPKEY = "", $SIG = ""
Local $USER_LEN = StringLen($USER)
Local $PASS_LEN = StringLen($PASS)
If $USER_LEN < $PASS_LEN Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
ElseIf $USER_LEN < 4 Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
EndIf
$PASS_INT = Int($USER_LEN / $PASS_LEN)
$PASS_MOD = Mod($USER_LEN, $PASS_LEN)
$OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
For $INDEX = 1 To $USER_LEN
$SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
Next
If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
MsgBox(0, "INFO", "Your key was registered.")
Exit
Else
MsgBox(0, "INFO", "Your key is invalid.")
EndIf
EndFunc


 El Algoritmo


El algoritmo es tremendamente sencillo ya que es nuestro nombre al revés y en mayúsculas.


 Modificando el script para generar nuestro propio keygen


El decompilador se llama myAut2exe y tiene este aspecto.


01-09-2014 11-56-37


Programar en AutoIt es muy sencillo e intuitivo. Nuestro keygen quedaría así.


$MAIN = GUICreate("Another keygen by deurus", 300, 80, -1, -1, 382205952, 385)
$NAME_LBL = GUICtrlCreateLabel("Username", 5, 5, 60, 20, BitOR(4096, 1))
$NAME_INP = GUICtrlCreateInput("", 70, 5, 225, 20, 1)
$PASS_LBL = GUICtrlCreateLabel("Key", 5, 30, 60, 20, BitOR(4096, 1))
$PASS_INP = GUICtrlCreateInput("", 70, 30, 225, 20, 1)
$REGISTER = GUICtrlCreateButton("Register", 5, 55, 60, 20)
$GIVE_UP = GUICtrlCreateButton("Generate", 70, 55, 60, 20)    <- Change name of button, Give Up by Generate
$TASK = GUICtrlCreateButton("?", 140, 55, 20, 20)
$AUTHOR = GUICtrlCreateLabel("keygen by deurus", 165, 55, 130, 20, BitOR(4096, 1))
GUISetState(@SW_SHOW, $MAIN)
While True
    $MSG = GUIGetMsg()
    Switch $MSG
        Case $REGISTER
            Call("CHECKKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))
        Case $GIVE_UP
            Call("GETKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))    <- Add the function to the button
        Case $TASK
            MsgBox(0, "Info", "keygen by deurus")
        Case - 3
            Exit
    EndSwitch
    Sleep(15)
WEnd

Func GETKEY($USER, $PASS)        <- this is our keygen function
    Local $OPKEY = "", $SIG = ""
    Local $USER_LEN = StringLen($USER)
    Local $PASS_LEN = StringLen($USER)
    If $USER_LEN < 4 Then
        GUICtrlSetData($PASS_INP  ,"min 4 chars");
    Else
    For $INDEX = 1 To $USER_LEN
        $SIG = Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), 32)) & $SIG
    Next
        GUICtrlSetData($PASS_INP  ,$SIG);
    EndIf
EndFunc

Func CHECKKEY($USER, $PASS)        <- check function, the original
    Local $OPKEY = "", $SIG = ""
    Local $USER_LEN = StringLen($USER)
    Local $PASS_LEN = StringLen($PASS)
    If $USER_LEN < $PASS_LEN Then
        MsgBox(0, "ERROR", "Invalid username or key.")
    ElseIf $USER_LEN < 4 Then
        MsgBox(0, "ERROR", "Invalid username or key.")
        Exit
    EndIf
    $PASS_INT = Int($USER_LEN / $PASS_LEN)
    $PASS_MOD = Mod($USER_LEN, $PASS_LEN)
    $OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
    For $INDEX = 1 To $USER_LEN
        $SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
    Next
    If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
        MsgBox(0, "INFO", "Your key was registered.")
    Else
        MsgBox(0, "INFO", "Your key is invalid.")
    EndIf
EndFunc


Este es el resultado.


01-09-2014 12-18-28


Links





    

        

      

        

        

  

        

                    Canyouhack.it – Crack Challenge 4 (Brain Fuck Me)
            

    

        Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de            

            
      

    

  

        

        

  

        

                    Blooper Tech Movie III – Mentiras arriesgadas
            

    

        Continuamos con los BTM awards. Esta vez analizaremos brevemente una escena de la película del casi siempre excelente James Cameron,            

            
      

    

  

        

        

  

        

                    Stego X - Chunk
            

    

        Intro Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir            

            
      

    

  

        

        

  

        

                    Solución al Crackme RSA (RSA24) de TSC
            

    

        Introducción Esta vez se trata de un crackme realizado en VC++ 5.0/6.0 y en sus entrañas utiliza RSA-24. En este            

            
      

    

  
    

    
      
      
    
  
  



								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						
Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de programación esotérico bastante complejo.


[-]>[-]<>++++++++[<++++++++++>-]<.+++++++++++++++++.>+++[<++++++>-]<..++++.-
-------.+++.--------------.>++++++[<------>-]<-.>+++++[<------>-]<-.,>,>,>,>
>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++
+++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++>>>>++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<
<<<<<<<<<<<<<<<<[>>>>>>>-<<<<<<<-]>>>>>>><<+>>[[-]++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.<]<[>]<<<<<[>>>>>>>>>>-<<<<<<<<
<<-]>>>>>>>>>><<+>>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++.<]<[>]<<<<<<<<[>>>>>>>>>>>>>-<<<<<<<<<<<<<-]>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.<]<[>]<<<<<<<<<<<[>>>>>>>>>>>>>>>>-<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++.<]<[>]>>>[-]>[-]<+++++++++++++.---.>+++++++[<++++++++++++>-]<.>+++++++[<
--------->-]<+.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------
->-]<.>++++++++[<+++++++++>-]<+.+++++++++++.>+++++++[<----------->-]<.>+++++
++[<+++++++++++>-]<-.>+++++++[<------------>-]<+.>++++++++[<+++++++++++>-]<-
.-----.---------.+++++++++++..---------------.+++++++++.>++++++[<-----------
-->-]<.+++++++.>+++++[<++++++>-]<+.-----.++++++++.+++.>++++++[<------>-]<-.-
------.>++++++++[<++++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>++
+++[<++++++>-]<+.-----.+++++++++++.>++++++[<------>-]<-.-------.>++++++++[<+
+++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>+++++[<+++++>-]<+.+++
+++++.+++.>++++++[<------>-]<-.+++++++...--------------.>++++++++[<+++++++++
++>-]<+.----------.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-
]<.-------.>+++[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++
+++++[<++++++++++>-]<.-----.++++++++.+++.-------.-.>++++++[<--------->-]<.--
------------.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------->
-]<.>+++++++[<++++++++++++>-]<.------------.---.+++++++++++++.-------------.
>+++++++[<---------->-]<+.>++++++++[<+++++++++>-]<+.++++++++++.>+++++++[<---
--------->-]<+.>++++++[<+++++++++++++>-]<.+.+++++.------------.+.+++++.-----
--.>++++++[<---------->-]<+.------------.>++++++++[<+++++++++++>-]<+.-------
---.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-]<.-------.>+++
[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++++++++[<+++++++
++++>-]<-.--------------.+++++.>++++++[<------------->-]<.+.


La solución que he encontrado yo, es convertir el código brainfuck a algo más amigable y depurarlo hasta encontrar la solución. La conversión la he realizado con VBBrainFNET y luego la depuración con Visual Studio. El crackme te pide una clave de cuatro cifras para darte la solución, pero si no quieres volverte loco puedes amañar los bucles para encontrar la solución.


¡SUERTE!




Enlaces



 

								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						
Continuamos con los BTM awards. Esta vez analizaremos brevemente una escena de la película del casi siempre excelente James Cameron, Mentiras Arriesgadas. En esta ocasión vamos a analizar una situación que se da mucho en el cine de Hollywood, esto es, el Plug and Play mágico. Cuando vemos películas de espías, es habitual encontrarnos con situaciones en las que el protagonista conecta un «algo» en el ordenador al que quiere acceder y ¡chas!, como por arte de magia sin tocar ninguna tecla se copian o se borran unos archivos, le da acceso remoto a algún compañero etc.


BTM


Este film no iba a ser menos y es que cuando Harry Tasker (Arnold Schwarzenegger) con sus inigualables dotes para el espionaje, entra en la mansión del objetivo en cuestión, conecta un módem, lo enciende y sin teclear un solo comando le da a su compañero Faisil (Grant Heslov) que se encuentra en una furgoneta a unos kilómetros,  acceso a la máquina, nos quedamos perplejos.


vlcsnap-2015-11-25-11h24m51s404


Esta situación es posible en la vida real, lo que la hace difícil de creer es que Harry no teclee ni un solo comando al conectar el módem, independientemente del Sistema Operativo que corra la máquina. Si nos situamos un poco, estamos hablando del año 1995, con una máquina corriendo Windows 3.1 y estamos conectando un módem a un puerto RS-232. En aquella época, por avanzada que fuera la tecnología espía, es difícil de creer que las cosas funcionen solas. Otra cosa a destacar es que a no ser que Faisil estuviera conectados a un poste de teléfono, la conexión tendría que ser inalámbrica, casi una quimera hace 20 años. A continuación os muestro la secuencia.




Como se puede observar en el vídeo, incluso parece que el equipo de Faisil, que también corre Windows 3.1, accede al equipo en modo escritorio remoto, tecnología que no existía en aquella época. Para que la secuencia tuviera un mínimo de credibilidad, Harry al conectar el módem y encender el equipo, debiera de haber introducido un par de comandos como mínimo para asignarle un puerto COM al módem y así iniciar la comunicación con Faisil. Ni que decir tiene que Faisil hubiera tenido que hacer todas las transmisiones mediante línea de comandos.


Aunque la película es entretenida y me gustó mucho cuando la vi allá por el año 1998, no nos queda más remedio que ponerle nuestro sello BTM de NO credibilidad.


sellazoment


Enlaces



Otros posts que te pueden interesar


    

        

      

        

        

  

        

                    Yoire PE Stage 3 Reversing Challenge (Benten) - Fuerza Bruta
            

    

        Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si            

            
      

    

  

        

        

  

        

                    Blooper Tech Movie VI - Dexter 1x08 (S01E08)
            

    

        Hace poco me puse a leer El oscuro pasajero de Jeff Lindsay, novela que inspiró la serie Dexter. La nostalgia            

            
      

    

  

        

        

  

        

                    Challengeland.co Realistic 1
            

    

        Alerta de Spoiler: El reto está en activo a fecha de publicación. Spoiler alert: The challenge is still alive. Este            

            
      

    

  

        

        

  

        

                    ThisIsLegal.com - Realistic Challenge 5
            

    

        Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en            

            
      

    

  
    

        
      
    
  
  



								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						
Warning: This challenge is still active and therefore should not be resolved using this information.

Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.



Introducción


Realistic Challenge 2: You have heard about people being targeted by a new religion called Egitology. Another hacker infiltrated the group and discovered that the list of people they target is stored on the site but he doesn’t know where.


Break into the site, find the file and remove it. Also leave no evidence that you was ever there so they wont realise until its too late!


El enunciado del reto nos dice que tenemos que localizar la lista de objetivos y eliminarla sin dejar evidencias.


Analizando la seguridad de la víctima


Echamos un vistazo y vemos que tienen un Login para usuarios registrados, este será nuestro primer testeo.




Lo primero que se no viene a la cabeza con un formulario de este tipo es Inyección SQL, probamos varios métodos y tenemos suerte.






User: admin 

Pass: ‘ or 1=1–‘;


 


 Vemos que hemos entrado como admin y enseguida nos llama la atención «Back up Database«. Pulsamos a ver que pasa.




 Obtenemos el hash de las claves de los usuarios Admin y SuperAdmin. Por suerte son hashes MD5. Obtenemos la clave de SuperAdmin y nos loguemos.




Solo nos queda borrar la lista de objetivos y nuestras huellas. Para ello borramos los siguientes archivos y reto superado.


Lista de objetivos: root/misc/targets

Logs: root/images/logs


Links


								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						


Introducción





La película «Contact«, estrenada en 1997 y dirigida por Robert Zemeckis, es una adaptación de la novela homónima de Carl Sagan. Más allá de su profunda exploración sobre la existencia de vida extraterrestre y el debate entre ciencia y fe, la película ofrece un interesante vistazo a la tecnología de la época. En este análisis, nos enfocaremos en los aspectos tecnológicos presentes en la película, detallando los sistemas operativos, software y hardware utilizados por los protagonistas.





Sinopsis





La Dra. Eleanor «Ellie» Arroway, interpretada por Jodie Foster, es una científica dedicada al proyecto SETI (Búsqueda de Inteligencia Extraterrestre). Tras años de búsqueda, capta una señal proveniente del espacio profundo que contiene instrucciones para construir una máquina enigmática. A medida que se desarrolla la trama, Ellie enfrenta desafíos políticos, religiosos y personales mientras lucha por interpretar el mensaje y lo que podría significar para la humanidad.





Análisis Tecnológico





Sistemas Operativos y Software





Uno de los aspectos más destacados en Contact es la presencia del sistema operativo UNIX. A lo largo de la película, se observan pistas que indican su uso, como pegatinas en las pantallas con mensajes del estilo: «Join the UNIX PARTY (The open system platform)». UNIX, desarrollado en la década de 1970, es conocido por su estabilidad y eficiencia, características esenciales en entornos científicos y de investigación.





La utilización de Netscape Navigator es recurrente. El logo de Netscape aparece en varias ocasiones, especialmente durante las videoconferencias que se muestran sin retrasos apreciables. Netscape fue uno de los primeros navegadores web ampliamente utilizados y jugó un papel crucial en la expansión de Internet durante los años 90.





Es importante destacar que, aunque la película promueve la idea de sistemas abiertos a través del uso de UNIX, Netscape Navigator no era software libre en el momento en que se rodó la película. Durante esa época, antes de 1997, Netscape era un navegador propietario. Sin embargo, en sistemas UNIX, Netscape tenía poca competencia y era el navegador predominante, soportando estándares abiertos como HTTP y HTML. Curiosamente, en 1998, poco después del estreno de la película, Netscape liberó el código fuente de su navegador, iniciando el proyecto Mozilla y contribuyendo significativamente al movimiento del software libre.





El software o plataforma denominada MADDEN HADDEN es utilizado por los protagonistas en diversas localizaciones, sugiriendo que es un estándar en su campo. Aunque en la realidad no existe un software conocido con ese nombre en el ámbito científico, en la película parece ser una herramienta integral para el análisis de datos y comunicación.





Videoconferencias y Comunicaciones





Las videoconferencias sin «lags» (retrasos) que se muestran en la película son notables, especialmente considerando las limitaciones tecnológicas de la época. La presencia del logo de Netscape durante estas comunicaciones resalta el optimismo sobre las capacidades de Internet en 1997. En ese entonces, las conexiones de alta velocidad no eran comunes, y las videollamadas de calidad eran más una aspiración que una realidad.





Estándares y Sistemas Abiertos





La promoción de sistemas abiertos es evidente en la película. El uso de UNIX, basado en estándares abiertos, refleja una filosofía de colaboración y accesibilidad en el ámbito científico. Aunque Netscape Navigator no era software libre durante la producción de la película, su soporte para estándares abiertos de Internet lo convirtió en una herramienta esencial para la comunicación y el intercambio de información entre científicos y profesionales.





Hardware





En términos de hardware, la película presenta una variedad de equipos representativos de la tecnología de los años 90:





Monitor NEC MultiSync XE21: Un monitor CRT de 21 pulgadas conocido por su alta resolución y calidad de imagen, ideal para aplicaciones que requieren detalles precisos.





Monitores con marcas ocultas: Es interesante notar que en varios monitores se utilizan post-its o adhesivos para cubrir la marca y el modelo. Esto podría deberse a decisiones de producción para evitar publicidad no deseada o cuestiones legales relacionadas con derechos de marca.





Monitor CTX: Aunque no se especifica el modelo, los monitores CTX eran populares por su fiabilidad y rendimiento a un costo razonable.





Monitor Hansol Mazellan 17px: Los monitores Hansol eran reconocidos por su calidad en la reproducción de gráficos, siendo utilizados en diseño y aplicaciones multimedia.





Monitor IBM: IBM fue pionera en tecnología informática, y sus monitores eran sinónimo de calidad y durabilidad. Aunque no se especifica el modelo exacto, es probable que se trate de uno de sus populares monitores CRT utilizados en entornos profesionales.





Evolución de UNIX y Windows





Para entender el contexto tecnológico de la época, es útil comparar la evolución de UNIX y Windows, así como de los navegadores Netscape Navigator e Internet Explorer.












Detalles Adicionales





Cobertura de marcas: La práctica de cubrir las marcas y modelos en los monitores podría indicar un intento de la producción por crear un entorno más universal y atemporal, evitando asociar la tecnología presentada con productos específicos que podrían quedar obsoletos rápidamente. En bastantes fotogramas se nota que esto es completamente intencionado.





Representación de la tecnología: La película equilibra la precisión técnica con las necesidades narrativas. Si bien algunas representaciones, como las videoconferencias fluidas, eran tecnológicamente avanzadas para la época, sirven para enfatizar la conectividad y colaboración global entre los científicos.





SETI y la Búsqueda de Vida Extraterrestre: En Contact, la Dra. Ellie Arroway dedica su vida al proyecto SETI (Search for Extraterrestrial Intelligence), reflejando el esfuerzo real de la comunidad científica por encontrar señales de inteligencia extraterrestre. SETI es una iniciativa internacional que utiliza radiotelescopios para detectar posibles comunicaciones de civilizaciones fuera de la Tierra. La película captura la pasión y los desafíos asociados con este tipo de investigación, destacando la dedicación de los científicos que trabajan en el límite de lo conocido.





El Mensaje de Arecibo: El radiotelescopio de Arecibo en Puerto Rico juega un papel significativo tanto en la realidad como en la película. En 1974, desde este observatorio, se envió el famoso Mensaje de Arecibo, una transmisión de radio dirigida al cúmulo estelar M13, diseñada para demostrar los avances tecnológicos humanos y nuestra existencia a posibles civilizaciones extraterrestres. El mensaje contenía información codificada sobre la composición humana, nuestro sistema numérico, la estructura del ADN y nuestra posición en el sistema solar. En «Contact», aunque la señal recibida por Ellie proviene de Vega y no está directamente relacionada con el Mensaje de Arecibo, la película establece paralelismos con este acontecimiento histórico. La utilización de Arecibo como escenario subraya la conexión entre los esfuerzos reales y ficticios en la búsqueda de inteligencia extraterrestre. La película explora la posibilidad de que, así como enviamos mensajes al espacio, podríamos recibir respuestas o comunicaciones de otras civilizaciones.





Matthew McConaughey: Es interesante notar cómo este actor ha participado en dos de las películas más destacadas de la ciencia ficción: Contact e Interstellar. En Contact, McConaughey interpreta un papel secundario como Palmer Joss, un escritor y asesor espiritual que cuestiona las implicaciones éticas y filosóficas del descubrimiento científico. Diecisiete años después, en Interstellar, asume el rol protagonista de Cooper, un ex piloto de la NASA que emprende una misión interestelar para salvar a la humanidad.





Números primos: El inicio de la investigación seria de la señal extraterrestre en la película se desencadena cuando, al analizar la señal recibida, los científicos descubren que esta codifica una secuencia de números primos. Este hallazgo resulta crucial, ya que los números primos, al ser divisibles únicamente por 1 y por sí mismos, no surgen de forma aleatoria en procesos naturales conocidos. Su presencia en la señal sugiere intencionalidad e inteligencia detrás de su emisión, lo que confirma que no se trata de ruido cósmico sino de una posible comunicación deliberada desde una civilización avanzada. Este descubrimiento impulsa a los científicos a profundizar en la decodificación, marcando el verdadero inicio de la búsqueda de vida extraterrestre.





Conclusión





Contact no solo es una obra que invita a reflexionar sobre nuestro lugar en el universo y la posibilidad de vida más allá de la Tierra, sino que también es un retrato de la tecnología de su tiempo. La inclusión de sistemas operativos como UNIX, navegadores como Netscape y hardware específico refleja una atención al detalle que enriquece la narrativa. A pesar de que Netscape Navigator no era software libre durante la producción de la película, su presencia destaca la importancia de los estándares abiertos y la colaboración en el avance científico.





También destaca por su compromiso con la precisión científica, en gran parte debido a la influencia de Carl Sagan, autor de la novela original y asesor en la producción. La representación de los procedimientos del SETI, el análisis de señales y las discusiones éticas y filosóficas reflejan debates reales en la comunidad científica. La inclusión de elementos como el Mensaje de Arecibo y las operaciones del radiotelescopio añaden autenticidad a la narrativa y acercan al público a la realidad de la exploración espacial.





Bibliografía y Enlaces









Galería







































































































































































































































































































































































































































































								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						
Intro


Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma más limpia posible.


Analizando a la víctima


Abrimos el crackme con Olly y ya a simple vista vemos los mensajes de la Nag y parte del código interesante. Si necesitaramos localizar la Nag podemos mirar en las intermodular calls las típicas subrutinas, en este caso se ve claramente  a MessageBoxA, bastaría con poner un breakpoint para localizar quien llama.


Aquí vemos la implicación de MessageBoxA.


004010A7     |> \6A 40                    PUSH 40                                         ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
004010A9     |.  68 61304000              PUSH Nag1.00403061                              ; |Title = "[NAG] Please register this software!"
004010AE     |.  68 86304000              PUSH Nag1.00403086                              ; |Text = "[BULLSHIT] Please register this software for support and you'll receive the full version!"
004010B3     |.  FF75 08                  PUSH [ARG.1]                                    ; |hOwner = 7FFDF000
004010B6     |.  E8 49010000              CALL <JMP.&user32.MessageBoxA>                  ; \MessageBoxA
........
00401137     |.  6A 40                    PUSH 40                                         ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
00401139     |.  68 6E324000              PUSH Nag1.0040326E                              ; |Title = "Thank you!"
0040113E     |.  68 79324000              PUSH Nag1.00403279                              ; |Text = "Thank you for registering this software!"
00401143     |.  FF75 08                  PUSH [ARG.1]                                    ; |hOwner = 7FFDF000
00401146     |.  E8 B9000000              CALL <JMP.&user32.MessageBoxA>                  ; \MessageBoxA
........
00401155     |.  6A 40                    PUSH 40                                         ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
00401157     |.  68 E0304000              PUSH Nag1.004030E0                              ; |Title = "About"
0040115C     |.  68 E6304000              PUSH Nag1.004030E6                              ; |Text = "Remove the NAG by TDC\r\n\n..: Coded by\t: TDC\t\t\t:..\t\r\n..: Also known as\t: The Dutch Cracker\t:..\t\r\n..: Protection\t: Custom\t\t\t:..\t\r\n..: Contact info\t: tdc123@gmail.com\t:..\t\r\n..: Release date\t: 09-08-2005\t\t:..\t"...
00401161     |.  FF75 08                  PUSH [ARG.1]                                    ; |hOwner = 7FFDF000
00401164     |.  E8 9B000000              CALL <JMP.&user32.MessageBoxA>                  ; \MessageBoxA


 Un poco encima vemos la función SetDlgItemTextA, que nos mostrará el mensaje de que hemos parcheado correctamente.


dlgitem


00401106     |> \68 21304000              PUSH Nag1.00403021                              ; /Text = "Dirty crack! Nag removed not registered!"
0040110B     |.  6A 73                    PUSH 73                                         ; |ControlID = 73 (115.)
0040110D     |.  FF75 08                  PUSH [ARG.1]                                    ; |hWnd = 7FFDF000
00401110     |.  E8 FB000000              CALL <JMP.&user32.SetDlgItemTextA>              ; \SetDlgItemTextA
00401115     |.  EB 36                    JMP SHORT Nag1.0040114D
00401117     |>  68 10304000              PUSH Nag1.00403010                              ; /Text = "Nag not removed!"
0040111C     |.  6A 73                    PUSH 73                                         ; |ControlID = 73 (115.)
0040111E     |.  FF75 08                  PUSH [ARG.1]                                    ; |hWnd = 7FFDF000
00401121     |.  E8 EA000000              CALL <JMP.&user32.SetDlgItemTextA>              ; \SetDlgItemTextA
00401126     |.  EB 25                    JMP SHORT Nag1.0040114D
00401128     |>  68 4A304000              PUSH Nag1.0040304A                              ; /Text = "Clean crack! Good Job!"
0040112D     |.  6A 73                    PUSH 73                                         ; |ControlID = 73 (115.)
0040112F     |.  FF75 08                  PUSH [ARG.1]                                    ; |hWnd = 7FFDF000
00401132     |.  E8 D9000000              CALL <JMP.&user32.SetDlgItemTextA>              ; \SetDlgItemTextA


Encima de SetDlgItemTextA vemos el código que analiza si la Nag tiene que aparecer.


004010E6     |.  E8 C4000000              CALL Nag1.004011AF                              ;  ; Llamada interesante a analizar
004010EB     |.  803D B0324000 03         CMP BYTE PTR DS:[4032B0],3
004010F2     |.  74 12                    JE SHORT Nag1.00401106                          ;  ; Si de la llamada volvemos con un 3 -> Parcheo chapuza
004010F4     |.  803D B0324000 02         CMP BYTE PTR DS:[4032B0],2
004010FB     |.  74 1A                    JE SHORT Nag1.00401117                          ;  ; Si de la llamada volvemos con un 2 -> Sin parchear
004010FD     |.  803D B0324000 01         CMP BYTE PTR DS:[4032B0],1
00401104     |.  74 22                    JE SHORT Nag1.00401128                          ;  ; Si de la llamada volvemos con un 1 -> Buen trabajo Joe!
........
004011AF     /$  68 A2324000              PUSH Nag1.004032A2                              ; /String2 = "Value1"
004011B4     |.  68 A9324000              PUSH Nag1.004032A9                              ; |String1 = "Value2"
004011B9     |.  E8 64000000              CALL <JMP.&kernel32.lstrcmpA>                   ; \lstrcmpA
004011BE     |.  50                       PUSH EAX                                        ;  kernel32.BaseThreadInitThunk
004011BF     |.  85C0                     TEST EAX,EAX                                    ;  kernel32.BaseThreadInitThunk
004011C1     |.  75 10                    JNZ SHORT Nag1.004011D3
004011C3     |.  33C0                     XOR EAX,EAX                                     ;  kernel32.BaseThreadInitThunk
004011C5     |.  58                       POP EAX                                         ;  kernel32.75CDEE1C
004011C6     |.  85C0                     TEST EAX,EAX                                    ;  kernel32.BaseThreadInitThunk
004011C8     |.  74 15                    JE SHORT Nag1.004011DF
004011CA     |.  C605 B0324000 03         MOV BYTE PTR DS:[4032B0],3
004011D1     |.  EB 17                    JMP SHORT Nag1.004011EA
004011D3     |>  58                       POP EAX                                         ;  kernel32.75CDEE1C
004011D4     |.  33C0                     XOR EAX,EAX                                     ;  kernel32.BaseThreadInitThunk
004011D6     |.  C605 B0324000 02         MOV BYTE PTR DS:[4032B0],2
004011DD     |.  EB 0B                    JMP SHORT Nag1.004011EA
004011DF     |>  33C0                     XOR EAX,EAX                                     ;  kernel32.BaseThreadInitThunk
004011E1     |.  C605 B0324000 01         MOV BYTE PTR DS:[4032B0],1
004011E8     |.  EB 00                    JMP SHORT Nag1.004011EA
004011EA     \>  C3                       RETN


 Vemos dentro del Call 4011AF que Compara si Value1 = Value2 y dependiendo de esa comparación guarda en memoria (4032B0), los valores 1, 2 ó 3.


Basta con modificar en un editor hexadecimal la parabra «Value2» por «Value1» y ya tenemos el problema resuelto.


09-09-2014 11-04-03


09-09-2014 11-04-34


09-09-2014 11-05-26


Al pulsar Re-Check


09-09-2014 11-06-01


Notas finales


Se podía haber parcheado un montón de código para obtener el mismo resultado pero fijándonos en el código lo hemos conseguido parcheando un solo byte. Recuerda, cuando halla que parchear, cuantos menos bytes mejor.


 Links





    

        

      

        

        

  

        

                    Blooper Tech Movie XII – Enemigo público
            

    

        Sinopsis Enemigo público (Enemy of the State) es una película de acción y suspense dirigida por Tony Scott, estrenada en            

            
      

    

  

        

        

  

        

                    Migas de pan
            

    

        Se nos entrega el siguiente ELF: Extracción de la Flag Si nos fijamos en las líneas 41 a la 45            

            
      

    

  

        

        

  

        

                    Solución a los retos criptográficos de Rogerfm.net
            

    

        Introducción Cripto 1 Cripto 2 Cripto 3 Cripto 4 Cripto 5 Cripto 6 Cripto 7 Cripto 8 Cripto 9 Cripto 10            

            
      

    

  

        

        

  

        

                    VideoTutorial - KeyGen para el Crackme#1 de WinFan
            

    

        http://youtu.be/b9-GdmIQINQ Lista de reproducción            

            
      

    

  
    

    
      
      
    
  
  



								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						


Sinopsis





Enemigo público (Enemy of the State) es una película de acción y suspense dirigida por Tony Scott, estrenada en 1998. La historia sigue a Robert Clayton Dean (Will Smith), un abogado de Washington D.C. que se ve atrapado en una conspiración de vigilancia masiva cuando recibe, sin saberlo, una cinta de video que documenta el asesinato de un congresista a manos de un alto funcionario de la Agencia de Seguridad Nacional (NSA), interpretado por Jon Voight. La situación se complica cuando la NSA utiliza toda su tecnología de espionaje para seguir y neutralizar a Dean.





Dean encuentra ayuda en Edward «Brill» Lyle (Gene Hackman), un exanalista de la NSA convertido en un experto en vigilancia que vive en el anonimato. Juntos intentan descubrir la verdad y exponer la conspiración, mientras son perseguidos por la propia NSA. Un papel crucial también lo desempeña el personaje de Daniel Zavitz, interpretado por Jason Lee, un joven investigador que graba accidentalmente el asesinato y termina transmitiendo la evidencia a Dean. El elenco incluye además a Lisa Bonet, Regina King, Jack Black, Barry Pepper, y Seth Green.





Tecnología utilizada





En Enemigo Público, la tecnología juega un papel crucial no solo en la trama sino también en la ambientación de la película. La precisión y el realismo de los equipos informáticos utilizados contribuyen a la atmósfera de paranoia y vigilancia que define la narrativa.





El PC de Daniel Zavitz (Jason Lee)





Jason Lee, en su papel de Daniel Zavitz, utiliza un PC clónico, claramente identificado por el logo de Sun Microsystems en la torre del ordenador. Sin embargo, el sistema operativo que corre en esta máquina es Windows 3.1, una versión que, para 1998, ya estaba obsoleta, habiendo sido lanzada en 1992. Esta elección subraya el hecho de que Zavitz utiliza equipamiento más económico y anticuado, en contraste con la tecnología más avanzada de otros personajes.





Zavitz también utiliza Media Player, un reproductor de video básico integrado en Windows 3.1. Durante la reproducción del archivo de video crucial para la trama, se puede observar que la extensión del archivo es .CAM. Este tipo de archivo podría implicar un video capturado por una cámara, pero también sugiere (por otros fotogramas de la película) que el codec utilizado para comprimir el video podría ser QuickTime, permitiendo una reproducción cruzada entre diferentes sistemas operativos.





Además, Zavitz utiliza un reproductor portátil NEC Turbo Express, un dispositivo de videojuegos portátil de la época. En la película, este dispositivo es empleado de manera innovadora para reproducir y transferir datos, algo poco realista pero que añade dramatismo a la escena. La tarjeta PCMCIA de 200MB que Zavitz utiliza para almacenar el video es otro ejemplo de la tecnología de la época, reflejando la capacidad de almacenamiento portátil antes de la popularización de los dispositivos USB.





El Equipo de Edward «Brill» Lyle (Gene Hackman)





Por su parte, Gene Hackman, en su papel de Brill, maneja un sistema considerablemente más avanzado, utilizando Windows 98. Este sistema operativo, lanzado también en 1998, representaba lo más avanzado en términos de compatibilidad y usabilidad en ese momento, lo que refuerza la imagen de Brill como un experto en tecnología con acceso a mejores recursos.





Aunque en la película no se detalla el hardware específico de Brill, el hecho de que use Windows 98, junto con las capacidades de manipulación y decodificación de video que se muestran, sugiere que tiene acceso a tecnología de alta gama para la época. En una escena clave, se observa cómo Brill decodifica el video utilizando una interfaz gráfica llamativa, diseñada claramente para atraer la atención del espectador, más que para reflejar la realidad de la tecnología disponible en ese momento.





Conclusión





La producción de Enemigo Público es destacable por su atención al detalle en lo referente al equipamiento tecnológico de los personajes. El contraste entre el equipo más antiguo y económico utilizado por Daniel Zavitz (Jason Lee) y el sistema más avanzado de Edward Lyle (Gene Hackman) refleja de manera efectiva el trasfondo de los personajes. Zavitz, como investigador freelance, se maneja con recursos limitados, mientras que Lyle, con su pasado en la NSA y mayor poder adquisitivo, tiene acceso a tecnología más avanzada.





Otro detalle interesante es la diferenciación en el equipamiento dentro de la central de la NSA. Mientras los empleados comunes utilizan monitores CRT, que eran estándar en la época, el personaje de Thomas Reynolds (Jon Voight) dispone de una pantalla plana, lo que subraya su estatus superior dentro de la agencia. Estos detalles de producción contribuyen a la autenticidad y la profundidad visual de la película.























Sin embargo, la película no está exenta de licencias creativas que sacrifican el realismo tecnológico en favor del impacto visual. Un ejemplo claro es cuando un técnico de la NSA, a partir de un fotograma de un vídeo de seguridad, rota la imagen en 3D para simular lo que Zavitz podría haber introducido en la bolsa de Dean. Aunque esta secuencia añade dramatismo, carece de una base tecnológica realista.




































































Del mismo modo, la escena donde Brill decodifica el vídeo utilizando una interfaz visualmente llamativa es un claro ejemplo de cómo la película opta por elementos más glamurosos para captar la atención del espectador, alejándose de la realidad técnica, donde estos procesos serían mucho menos espectaculares y más funcionales. Además se pueden observar las siguientes curiosidades: 





    

  • Se ve el escritorio de Windows 98 con fondo negro y tres aplicaciones abiertas, QuickTime for Windows, una carpeta y una imagen. 
    • 




  • Una carpeta abierta con cuatro archivos DIR y nombres que nos hacen creer que uno está encriptado y otro no. Dos archivos de imagen con extensión TIF y dos archivos de vídeo con extensión MOV. Ojo porque DIR es la extensión de proyectos de Adobe Director, ahí lo dejo.
    • 




  • La animación muestra el 100% antes que la barra de progreso llegue al final.
    • 




  • Una vez decodificado se nos muestra el vídeo pero como se nos mostró anteriormente con el media player de Windows 3.1. Incluso se ve el icono de minimizar típico de Windows 3.1 en la parte superior izquierda (última imagen).
    • 






























































































En resumen, Enemigo Público logra un equilibrio eficaz entre el realismo tecnológico y las exigencias dramáticas del cine. A pesar de algunas exageraciones en la representación de la tecnología, la atención al detalle en los aspectos técnicos y la diferenciación de equipos según los personajes y sus circunstancias es un testimonio del buen trabajo de producción que hace que la película siga siendo entretenida, incluso más de dos décadas después de su estreno.

								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						

Se nos entrega el siguiente ELF:





/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
   Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

__int64 (**init_proc())(void);
void sub_1020();
// int printf(const char *format, ...);
// int getchar(void);
// int fflush(FILE *stream);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
// int __fastcall _cxa_finalize(void *);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
FILE **deregister_tm_clones();
__int64 register_tm_clones(); // weak
FILE **_do_global_dtors_aux();
__int64 __fastcall frame_dummy(_QWORD, _QWORD, _QWORD); // weak
int __fastcall main(int argc, const char **argv, const char **envp);
_BOOL8 __fastcall comprobacion(char a1, char a2, int a3);
void _libc_csu_fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// int __fastcall __cxa_finalize(void *);
// __int64 _gmon_start__(void); weak

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN _libc_csu_init;
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
void *_dso_handle = &_dso_handle; // idb
char *a = "MdfnJk"; // weak
char *b = "jYx}"; // weak
char *c = "gWmfk"; // weak
char *d = "mlvpc"; // weak
char *f = "neU++w"; // weak
FILE *_bss_start; // idb
char completed_0; // weak


//----- (0000000000001000) ----------------------------------------------------
__int64 (**init_proc())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}
// 40D0: using guessed type __int64 _gmon_start__(void);

//----- (0000000000001020) ----------------------------------------------------
void sub_1020()
{
  JUMPOUT(0LL);
}
// 1026: control flows out of bounds to 0

//----- (0000000000001090) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  _libc_start_main(
    (int (__fastcall *)(int, char **, char **))main,
    v4,
    &retaddr,
    (void (*)(void))_libc_csu_init,
    _libc_csu_fini,
    a3,
    &v5);
  __halt();
}
// 1096: positive sp value 8 has been found
// 109D: variable 'v3' is possibly undefined

//----- (00000000000010C0) ----------------------------------------------------
FILE **deregister_tm_clones()
{
  return &_bss_start;
}

//----- (00000000000010F0) ----------------------------------------------------
__int64 register_tm_clones()
{
  return 0LL;
}
// 10F0: using guessed type __int64 register_tm_clones();

//----- (0000000000001130) ----------------------------------------------------
FILE **_do_global_dtors_aux()
{
  FILE **result; // rax

  if ( !completed_0 )
  {
    if ( &__cxa_finalize )
      _cxa_finalize(_dso_handle);
    result = deregister_tm_clones();
    completed_0 = 1;
  }
  return result;
}
// 4080: using guessed type char completed_0;

//----- (0000000000001175) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
  char v4; // [rsp+7h] [rbp-9h] BYREF
  int v5; // [rsp+8h] [rbp-8h]
  bool v6; // [rsp+Fh] [rbp-1h]

  v6 = 1;
  v5 = 0;
  while ( v6 )
  {
    fflush(_bss_start);
    printf("\nIntroduce la letra correcta:\t");
    __isoc99_scanf("%c", &v4);
    getchar();
    if ( v5 > 5 )
    {
      if ( v5 > 9 )
      {
        if ( v5 > 14 )
        {
          if ( v5 > 19 )
            v6 = comprobacion(v4, f[v5 - 20], 10);
          else
            v6 = comprobacion(v4, d[v5 - 15], 2);
        }
        else
        {
          v6 = comprobacion(v4, c[v5 - 10], 8);
        }
      }
      else
      {
        v6 = comprobacion(v4, b[v5 - 6], 17);
      }
    }
    else
    {
      v6 = comprobacion(v4, a[v5], 5);
    }
    if ( !v6 )
    {
      printf("Incorrecta");
      exit(1);
    }
    printf("\n%c\n", (unsigned int)v4);
    if ( v5 == 25 )
    {
      printf("Ya tienes la flag!!");
      exit(1);
    }
    ++v5;
  }
  return 0;
}
// 1060: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4050: using guessed type char *a;
// 4058: using guessed type char *b;
// 4060: using guessed type char *c;
// 4068: using guessed type char *d;
// 4070: using guessed type char *f;

//----- (0000000000001352) ----------------------------------------------------
_BOOL8 __fastcall comprobacion(char a1, char a2, int a3)
{
  return a1 == (a3 ^ a2);
}

//----- (0000000000001390) ----------------------------------------------------
void __fastcall _libc_csu_init(unsigned int a1, __int64 a2, __int64 a3)
{
  signed __int64 v4; // rbp
  __int64 i; // rbx

  init_proc();
  v4 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
  if ( v4 )
  {
    for ( i = 0LL; i != v4; ++i )
      ((void (__fastcall *)(_QWORD, __int64, __int64))*(&_frame_dummy_init_array_entry + i))(a1, a2, a3);
  }
}
// 1170: using guessed type __int64 __fastcall frame_dummy(_QWORD, _QWORD, _QWORD);
// 3DE8: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 3DF0: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();

//----- (00000000000013F4) ----------------------------------------------------
void term_proc()
{
  ;
}





Extracción de la Flag





Si nos fijamos en las líneas 41 a la 45 vemos las siguientes cadenas:





a = «MdfnJk»
b = «jYx}»
c = «gWmfk»
d = «mlvpc»
f = «neU++w»





Usaremos las cadenas y los valores XOR especificados para cada rango de v5 en el main (líneas 123 a 182) para determinar los caracteres correctos.





Para v5 de 0 a 5: v6 = comprobacion(v4, a[v5], 5);
Significa que: v4 debe ser igual a a[v5] ^ 5





Para v5 de 6 a 9: v6 = comprobacion(v4, b[v5 – 6], 17);
Significa que: v4 debe ser igual a b[v5 – 6] ^ 17





Para v5 de 10 a 14: v6 = comprobacion(v4, c[v5 – 10], 8);
Significa que: v4 debe ser igual a c[v5 – 10] ^ 8





Para v5 de 15 a 19: v6 = comprobacion(v4, d[v5 – 15], 2);
Significa que: v4 debe ser igual a d[v5 – 15] ^ 2





Para v5 de 20 a 25: v6 = comprobacion(v4, f[v5 – 20], 10);
Significa que: v4 debe ser igual a f[v5 – 20] ^ 10





Cálculo de los caracteres correctos:
Para v5 de 0 a 5:
a[0] = ‘M’, M ^ 5 = 0x4D ^ 0x05 = 0x48 -> ‘H’
a[1] = ‘d’, d ^ 5 = 0x64 ^ 0x05 = 0x61 -> ‘a’
a[2] = ‘f’, f ^ 5 = 0x66 ^ 0x05 = 0x63 -> ‘c’
a[3] = ‘n’, n ^ 5 = 0x6E ^ 0x05 = 0x6B -> ‘k’
a[4] = ‘J’, J ^ 5 = 0x4A ^ 0x05 = 0x4F -> ‘O’
a[5] = ‘k’, k ^ 5 = 0x6B ^ 0x05 = 0x6E -> ‘n’
Resulta en la cadena: HackOn





Para v5 de 6 a 9:
b[0] = ‘j’, j ^ 17 = 0x6A ^ 0x11 = 0x7B -> ‘{‘
b[1] = ‘Y’, Y ^ 17 = 0x59 ^ 0x11 = 0x48 -> ‘H’
b[2] = ‘x’, x ^ 17 = 0x78 ^ 0x11 = 0x69 -> ‘i’
b[3] = ‘}’, } ^ 17 = 0x7D ^ 0x11 = 0x6C -> ‘l’
Resulta en la cadena: {Hil





Para v5 de 10 a 14:
c[0] = ‘g’, g ^ 8 = 0x67 ^ 0x08 = 0x6F -> ‘o’
c[1] = ‘W’, W ^ 8 = 0x57 ^ 0x08 = 0x5F -> ‘_’
c[2] = ‘m’, m ^ 8 = 0x6D ^ 0x08 = 0x65 -> ‘e’
c[3] = ‘f’, f ^ 8 = 0x66 ^ 0x08 = 0x6E -> ‘n’
c[4] = ‘k’, k ^ 8 = 0x6B ^ 0x08 = 0x63 -> ‘c’
Resulta en la cadena: o_enc





Para v5 de 15 a 19:
d[0] = ‘m’, m ^ 2 = 0x6D ^ 0x02 = 0x6F -> ‘o’
d[1] = ‘l’, l ^ 2 = 0x6C ^ 0x02 = 0x6E -> ‘n’
d[2] = ‘v’, v ^ 2 = 0x76 ^ 0x02 = 0x74 -> ‘t’
d[3] = ‘p’, p ^ 2 = 0x70 ^ 0x02 = 0x72 -> ‘r’
d[4] = ‘c’, c ^ 2 = 0x63 ^ 0x02 = 0x61 -> ‘a’
Resulta en la cadena: ontra





Para v5 de 20 a 25:
f[0] = ‘n’, n ^ 10 = 0x6E ^ 0x0A = 0x64 -> ‘d’
f[1] = ‘e’, e ^ 10 = 0x65 ^ 0x0A = 0x6F -> ‘o’
f[2] = ‘U’, U ^ 10 = 0x55 ^ 0x0A = 0x5F -> ‘_‘ 
f[3] = ‘+’, + ^ 10 = 0x2B ^ 0x0A = 0x21 -> ‘!’ 
f[4] = ‘+’, + ^ 10 = 0x2B ^ 0x0A = 0x21 -> ‘!’ 
f[5] = ‘w’, w ^ 10 = 0x77 ^ 0x0A = 0x7D -> ‘}’ 
Resulta en la cadena: do_!!}





Uniendo todas las partes, obtenemos la flag completa: HackOn{Hilo_enc_ontrado_!!}

								

			

					

	

		

			
		

							
 por ·Sin comentarios

			

				

							

						


Introducción


Los retos de encriptación son muy variados como hemos comentado anteriormente. Aquí tenemos unos buenos ejemplos de ello.


Cripto 1




En este primer nivel nos encontramos con un método de encriptación muy antíguo.    Sólo diré como pista, que es de los más antiguos que se conocen.


ozhlofxrlmvhxzorulimrz




Lo primero que suelo hacer en este tipo de retos cuando son solamente letras, es comprobar las dos opciones más típicas, que son el cifrado César y Vigenere. En este caso necesitamos ahondar un poco más, aunque enseguida llegamos a la conclusión de que el cifrado usado es el afín. Un ataque por fuerza bruta nos devuelve la solución y los coeficientes utilizados.


Solución: A=25,B=25  – LASOLUCIONESCALIFORNIA


Fuente: http://www.dcode.fr/chiffre-affine




Cripto 2




En este segundo nivel recordaremos a un general romano muy conocido. Lo complicaremos un poco, sólo lo justo para que cueste algo más de cinco minutos encontrar la clave 🙂


oehoeahhjoexhkzqhfsvzhffhwrhotqk




Lo primero que nos viene a la cabeza es el cifrado César pero no va. Probando varios cifrados por sustitución al final damos con el correcto. De nuevo un ataque por fuerza bruta nos da frutos.


Solución: (3,4,5)/1  – LACLAVEDELASEGUNDAPRUEBAESMEKONG


Fuente: https://www.dcode.fr/chiffre-decalages




Cripto 3




Este nivel también va a ser sencillo. Estos caracteres, pertenecientes a un sistema bastante conocido de encriptado, esconden una palabra que, al introducirla (en minúsculas), nos permitirá superar el nivel.






Investigando un poco llegamos a la conclusión de que se trata del cifrado Francmasón o Pig Pen.


Solución: primates


Fuente: https://www.dcode.fr/chiffre-pig-pen-francs-macons




Cripto 4




Esta prueba es tan simple que la he dividido en dos partes que, aunque de apariencia similar, se resuelven de distinta manera. La clave es la unión de las dos palabras resultantes de descifrar las dos líneas de números y que, juntas, forman una tercera palabra.


0111001101110101011100000110010101110010
0001001110011000111110100100110010010001




La primera parte se puede convertir en bloque:


0111001101110101011100000110010101110010 = super


Fuente: https://www.rapidtables.com/convert/number/binary-to-ascii.html


Para la segunda debemos separar en grupos de 5 dígitos y listo:


00010   01110   01100   01111   10100   10011   00100   10001


 C             O          M           P            U          T           E           R


Fuente: www.lindau-nobel.org




Cripto 5




Para descubrir la palabra clave sólo se necesita una mínima capacidad de observación.


31 04 40 23 20 34 33 13 23 22




Se trata del cuadrado de Polibio.






Cripto 6




Aquí hay que hacer un poco de trabajo de investigación: Hay que descubrir la clave que empleó un escritor francés (Una pista: «Lagardère») en una de sus novelas, que es la empleada aquí para formar la palabra clave (en minúsculas) que, por cierto, es alemana.


RI3I2MIL2I2A3




POR RESOLVER




Cripto 7




Seguimos con cosas fáciles. Se trata de descifrar este texto escrito en inglés.


kgw qkoev ol 617 qthpreoz iwjpz sdkg kgw pdeyeplk rwqdjzwe ipezwq spbbdq sgo sgwz goqkdbdkdwq iwjpz spq rwkwecdzwr ko cpmw gdq uweqozpb yozkedihkdoz ko kgw spe wlloek


Una vez descifrado, nos será fácil descubrir la clave:


pzpyozrp




Se trata de  un cifrado de sustitución mono alfabético.


ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZLMIRVHUBGTFJKOASDWQPYEXCN


THE STORY OF 617 SQUADRON BEGAN WITH THE AIRCRAFT DESIGNER BARNES WALLIS WHO WHEN HOSTILITIES BEGAN WAS DETERMINED TO MAJE HIS PERSONAL CONTRIBUTION TO THE WAR EFFORT


Una vez descifrado el alfabeto la solución queda:


pzpyozrp = anaconda


Cripto 8




A veces, las cosas no son lo que parecen. Donde aparecen unos números, en realidad hay otros números distintos.


273664524572348321143738
853442616537643005319627




POR RESOLVER




Cripto 9




Para resolver algunos problemas, hay que tener una buena base. Este es un buen ejemplo de ello:


ZW50ZXJwcmlzZQ0K




¿Os suena base 64?


Solución: enterprise


Fuente: https://www.base64decode.org/




Cripto 10




Esto es más complicado. Para descifrar este texto que contiene la clave para superar el nivel, se necesita otra clave. Para que no sea demasiado difícil, he utilizado una palabra muy sencilla de sólo cuatro letras 🙂


myiemyuvbaeewcxweghkflxw




Mediante fuerza bruta matamos dos pájaros de un tiro.


lapalabraclaveesdiogenes


Fuente: https://www.guballa.de/vigenere-solver




Enlaces