While Crackmes.de returns, I leave a couple of files for practice.
Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.
In the folder crackmes.de_mirror you have two files:
En la carpeta crackmes.de_mirror tienes dos archivos:
password of files = deurus.info
Recién rescatados del inframundo que es mi disco duro, os traigo un paquete de seis crackmes facilones para vuestro uso y disfrute. Desgraciadamente ya no está en activo la web de retos de donde los saqué así que os los dejo en descargas.
Los cuatro primero están realizados en Dev-C++ 4.9.9.2 siendo de estilo consola de comandos. Los dos restantes compilados con MingWin32 GCC 3.x carecen de GUI y vamos, que no se han esmerado mucho en darles forma.
No cuesta mucho dar con el código interesante mediante las referencias de texto. En Ollydbg clic derecho sobre el código y Search for > All referenced text strings.
004012E1 |. 8845 E8 MOV BYTE PTR SS:[EBP-18],AL ; |||| 004012E4 |. C70424 11304000 MOV DWORD PTR SS:[ESP],level1.00403011 ; ||||ASCII "Input Serial: " 004012EB |. E8 C0050000 CALL <JMP.&msvcrt.printf> ; |||\printf 004012F0 |. 8D45 C8 LEA EAX,[LOCAL.14] ; ||| 004012F3 |. 894424 04 MOV DWORD PTR SS:[ESP+4],EAX ; ||| 004012F7 |. C70424 20304000 MOV DWORD PTR SS:[ESP],level1.00403020 ; |||ASCII "%s" 004012FE |. E8 9D050000 CALL <JMP.&msvcrt.scanf> ; ||\scanf 00401303 |. 8D45 D8 LEA EAX,[LOCAL.10] ; || 00401306 |. 8D55 C8 LEA EDX,[LOCAL.14] ; || 00401309 |. 894424 04 MOV DWORD PTR SS:[ESP+4],EAX ; || 0040130D |. 891424 MOV DWORD PTR SS:[ESP],EDX ; ||level1.00403022 00401310 |. E8 7B050000 CALL <JMP.&msvcrt.strcmp> ; |\strcmp 00401315 |. 8945 C4 MOV [LOCAL.15],EAX ; | 00401318 |. 837D C4 00 CMP [LOCAL.15],0 ; | 0040131C |. 75 0E JNZ SHORT level1.0040132C ; | 0040131E |. C70424 23304000 MOV DWORD PTR SS:[ESP],level1.00403023 ; |ASCII "Well done. \n" 00401325 |. E8 86050000 CALL <JMP.&msvcrt.printf> ; \printf 0040132A |. EB 0C JMP SHORT level1.00401338 0040132C |> C70424 30304000 MOV DWORD PTR SS:[ESP],level1.00403030 ; |ASCII "Wrong. \n" 00401333 |. E8 78050000 CALL <JMP.&msvcrt.printf> ; \printf 00401338 |> C70424 39304000 MOV DWORD PTR SS:[ESP],level1.00403039 ; |ASCII "PAUSE" 0040133F |. E8 3C050000 CALL <JMP.&msvcrt.system> ; \system 00401344 |. B8 00000000 MOV EAX,0 00401349 |. C9 LEAVE 0040134A \. C3 RETN
La madre del cordero está en la dirección 401310 que es donde se lleva a cabo la función de comparación strcmp.
756296A0 msvcrt.strcmp 8B5424 04 MOV EDX,DWORD PTR SS:[ESP+4] 756296A4 8B4C24 08 MOV ECX,DWORD PTR SS:[ESP+8] 756296A8 F7C2 03000000 TEST EDX,3 ; 0-3 = 4 bucles. Divide la comprobación en 4 bloques 756296AE 75 3C JNZ SHORT msvcrt.756296EC ; salta si hemos terminado los 4 bucles 756296B0 > 8B02 MOV EAX,DWORD PTR DS:[EDX] ; coge 4 caracteres del serial (INICIO BUCLE) 756296B2 3A01 CMP AL,BYTE PTR DS:[ECX] ; compara el 1º/5º/9º/13º dígito en función del bucle 756296B4 75 2E JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296B6 0AC0 OR AL,AL 756296B8 74 26 JE SHORT msvcrt.756296E0 756296BA 3A61 01 CMP AH,BYTE PTR DS:[ECX+1] ; compara el 2º/6º/10º/14º dígito en función del bucle 756296BD 75 25 JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296BF 0AE4 OR AH,AH 756296C1 74 1D JE SHORT msvcrt.756296E0 756296C3 C1E8 10 SHR EAX,10 756296C6 3A41 02 CMP AL,BYTE PTR DS:[ECX+2] ; compara el 3º/7º/11º/15º dígito en función del bucle 756296C9 75 19 JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296CB 0AC0 OR AL,AL 756296CD 74 11 JE SHORT msvcrt.756296E0 756296CF 3A61 03 CMP AH,BYTE PTR DS:[ECX+3] ; compara el 4º/8º/12º/16º dígito en función del bucle 756296D2 75 10 JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296D4 83C1 04 ADD ECX,4 756296D7 83C2 04 ADD EDX,4 756296DA 0AE4 OR AH,AH 756296DC ^ 75 D2 JNZ SHORT msvcrt.756296B0 ; Si no hemos terminado... 756296DE 8BFF MOV EDI,EDI 756296E0 33C0 XOR EAX,EAX ; EAX = 0 que es lo deseado 756296E2 C3 RETN ; salimos de la función superando la comprobación 756296E3 90 NOP 756296E4 1BC0 SBB EAX,EAX ; Zona mala 756296E6 D1E0 SHL EAX,1 756296E8 83C0 01 ADD EAX,1 ; EAX = 1 implica bad boy 756296EB C3 RETN ; salimos de la función
Si atendemos al volcado vemos el serial bueno Kcgcv8LsmV3nizfJ.
0060FEF0 31 32 33 34 35 36 37 38 39 30 00 75 40 19 18 00 1234567890.u@. 0060FF00 4B 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A Kcgcv8LsmV3nizfJ
Curiosamente, si introducimos el serial bueno el crackme no lo acepta. Fijándome en la comprobación veo que al introducir un serial de 16 caracteres inserta un carácter nulo (0x00) alterando el serial correcto y falseando la comprobación.
0060FEF0 4B 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A Kcgcv8LsmV3nizfJ 0060FF00 00 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A .cgcv8LsmV3nizfJ
Ahora ya no podemos comprobarlo pero recuerdo que la web consideraba válido el serial Kcgcv8LsmV3nizfJ, por lo que considero lo anteriormente citado un bug o un intento de despiste del autor.
Es exactamente igual que el anterior cambiando el serial por 6LPw3vDYja9KrT2V.
La comprobación del serial es igual a las dos anteriores pero añade una función intermedia que suma 0xD a cada carácter de nuestro serial
00401355 |. A1 03304000 MOV EAX,DWORD PTR DS:[403003] ; || 0040135A |. 8945 E8 MOV [LOCAL.6],EAX ; || 0040135D |. A1 07304000 MOV EAX,DWORD PTR DS:[403007] ; || 00401362 |. 8945 EC MOV [LOCAL.5],EAX ; || 00401365 |. A1 0B304000 MOV EAX,DWORD PTR DS:[40300B] ; || 0040136A |. 8945 F0 MOV [LOCAL.4],EAX ; || 0040136D |. A1 0F304000 MOV EAX,DWORD PTR DS:[40300F] ; || 00401372 |. 8945 F4 MOV [LOCAL.3],EAX ; || 00401375 |. C70424 13304000 MOV DWORD PTR SS:[ESP],level3.00403013 ; ||ASCII "Input Serial: " 0040137C |. E8 CF050000 CALL <JMP.&msvcrt.printf> ; |\printf 00401381 |. 8D45 D8 LEA EAX,[LOCAL.10] ; | 00401384 |. 894424 04 MOV DWORD PTR SS:[ESP+4],EAX ; | 00401388 |. C70424 00304000 MOV DWORD PTR SS:[ESP],level3.00403000 ; |ASCII "%s" 0040138F |. E8 AC050000 CALL <JMP.&msvcrt.scanf> ; \scanf 00401394 |. 8D5D E8 LEA EBX,[LOCAL.6] 00401397 |. 8D45 D8 LEA EAX,[LOCAL.10] 0040139A |. 890424 MOV DWORD PTR SS:[ESP],EAX 0040139D |. E8 EEFEFFFF CALL level3.00401290 ; NUEVA FUNCIÓN SUMA 004013A2 |. 895C24 04 MOV DWORD PTR SS:[ESP+4],EBX ; || 004013A6 |. 890424 MOV DWORD PTR SS:[ESP],EAX ; || 004013A9 |. E8 82050000 CALL <JMP.&msvcrt.strcmp> ; |\strcmp 004013AE |. 8945 D4 MOV [LOCAL.11],EAX ; | 004013B1 |. 837D D4 00 CMP [LOCAL.11],0 ; | 004013B5 |. 75 0E JNZ SHORT level3.004013C5 ; | 004013B7 |. C70424 22304000 MOV DWORD PTR SS:[ESP],level3.00403022 ; |ASCII "Well done." 004013BE |. E8 8D050000 CALL <JMP.&msvcrt.printf> ; \printf 004013C3 |. EB 0C JMP SHORT level3.004013D1 004013C5 |> C70424 2D304000 MOV DWORD PTR SS:[ESP],level3.0040302D ; |ASCII "Wrong. \n" 004013CC |. E8 7F050000 CALL <JMP.&msvcrt.printf> ; \printf 004013D1 |> C70424 36304000 MOV DWORD PTR SS:[ESP],level3.00403036 ; |ASCII "PAUSE" 004013D8 |. E8 43050000 CALL <JMP.&msvcrt.system> ; \system 004013DD |. B8 00000000 MOV EAX,0 004013E2 |. 8B5D FC MOV EBX,[LOCAL.1] 004013E5 |. C9 LEAVE 004013E6 \. C3 RETN -------- 004012A4 |> /8B45 08 /MOV EAX,[ARG.1] ; | 004012A7 |. |890424 |MOV DWORD PTR SS:[ESP],EAX ; | 004012AA |. |E8 B1060000 |CALL <JMP.&msvcrt.strlen> ; \strlen 004012AF |. |3945 FC |CMP [LOCAL.1],EAX 004012B2 |. |73 1C |JNB SHORT level3.004012D0 004012B4 |. |8B45 08 |MOV EAX,[ARG.1] 004012B7 |. |8B55 FC |MOV EDX,[LOCAL.1] 004012BA |. |01C2 |ADD EDX,EAX 004012BC |. |8B45 08 |MOV EAX,[ARG.1] 004012BF |. |0345 FC |ADD EAX,[LOCAL.1] 004012C2 |. |0FB600 |MOVZX EAX,BYTE PTR DS:[EAX] 004012C5 |. |04 0D |ADD AL,0D ; char + 0xD 004012C7 |. |8802 |MOV BYTE PTR DS:[EDX],AL 004012C9 |. |8D45 FC |LEA EAX,[LOCAL.1] 004012CC |. |FF00 |INC DWORD PTR DS:[EAX] 004012CE |.^\EB D4 \JMP SHORT level3.004012A4 -------- 756296A0 msvcrt.strcmp 8B5424 04 MOV EDX,DWORD PTR SS:[ESP+4] 756296A4 8B4C24 08 MOV ECX,DWORD PTR SS:[ESP+8] 756296A8 F7C2 03000000 TEST EDX,3 756296AE 75 3C JNZ SHORT msvcrt.756296EC 756296B0 8B02 MOV EAX,DWORD PTR DS:[EDX] 756296B2 3A01 CMP AL,BYTE PTR DS:[ECX] 756296B4 75 2E JNZ SHORT msvcrt.756296E4 756296B6 0AC0 OR AL,AL 756296B8 74 26 JE SHORT msvcrt.756296E0 756296BA 3A61 01 CMP AH,BYTE PTR DS:[ECX+1] 756296BD 75 25 JNZ SHORT msvcrt.756296E4 756296BF 0AE4 OR AH,AH 756296C1 74 1D JE SHORT msvcrt.756296E0 756296C3 C1E8 10 SHR EAX,10 756296C6 3A41 02 CMP AL,BYTE PTR DS:[ECX+2] 756296C9 75 19 JNZ SHORT msvcrt.756296E4 756296CB 0AC0 OR AL,AL 756296CD 74 11 JE SHORT msvcrt.756296E0 756296CF 3A61 03 CMP AH,BYTE PTR DS:[ECX+3] 756296D2 75 10 JNZ SHORT msvcrt.756296E4 756296D4 83C1 04 ADD ECX,4 756296D7 83C2 04 ADD EDX,4 756296DA 0AE4 OR AH,AH 756296DC ^ 75 D2 JNZ SHORT msvcrt.756296B0 756296DE 8BFF MOV EDI,EDI 756296E0 33C0 XOR EAX,EAX 756296E2 C3 RETN 756296E3 90 NOP 756296E4 1BC0 SBB EAX,EAX 756296E6 D1E0 SHL EAX,1 756296E8 83C0 01 ADD EAX,1 756296EB C3 RETN
En la comparación vemos que el serial bueno es AvrQQsXjDk25Jrh por lo que si restamos 0xD (13 en decimal) a cada carácter obtendremos el serial bueno.
0060FF10 41 76 72 51 51 73 58 6A 44 6B 32 35 4A 72 68 00 AvrQQsXjDk25Jrh. 41 76 72 51 51 73 58 6A 44 6B 32 35 4A 72 68 - D 34 69 65 44 44 66 4B 5D 37 5E 25 28 3D 65 5B 4 i e D D f K ] 7 ^ % ( = e [ Serial bueno: 4ieDDfK]7^%(=e[
La comprobación del serial es igual que la anterior pero sustituyendo la función que sumaba un valor a cada dígito del serial por una que genera un hash con nuestro serial y después lo compara con otro hash almacenado en memoria. Si no nos viene a la mente el tipo de hash que puede ser PEiD ya nos avisaba de que efectivamente el crackme incorpora la función MD5.
La función MD5 hace tiempo que no se considera segura debido a la existencia de numerosos «diccionarios» de hashes que hacen que encontremos la solución en segundos. Yo he utilizado la web MD5 online pero existen muchas más.
0060FE5C 004013BF RETURN to level4.004013BF from <JMP.&msvcrt.strcmp> 0060FE60 0060FEA0 ASCII "e807f1fcf82d132f9bb018ca6738a19f" 0060FE64 0060FEE0 ASCII "fe01d67a002dfa0f3ac084298142eccd" e807f1fcf82d132f9bb018ca6738a19f == 1234567890 fe01d67a002dfa0f3ac084298142eccd == orange
La carta de presentación de este crackme es la imagen que veis arriba. Al explorarlo unos minutos enseguida nos damos cuenta de que no realiza ninguna comprobación y que nos está haciendo perder el tiempo. Ahí es cuando empezamos a revisar el ejecutable más a fondo y enseguida encontramos la solución con nuestro amigo el editor hexadecimal.
Misma carta de presentación que el anterior y misma ausencia de comprobación del serial. En esta ocasión echando un vistazo a los recursos encontramos la solución rápidamente.
Hoy vamos a desmitificar un poco a Visual Basic. El Crackme reza que acabemos con la nag y hagamos un keygen.
Lo primero que debemos establecer es a que tipo de Nag nos estamos enfrentando, si es una MessageBox, se localiza y se parchea, si es un formulario la cosa ya cambia un poco, ya que encontrar esa parte del código puede resultar tedioso.
Yo voy a utilizar el camino fácil. En VB contamos con una estupenda herramienta como es VBReformer, que nos muestra las entrañas del crackme y nos posibilita cambiar ciertos parametros.
Abrimos el crackme con VBReformer y vemos su contenido. Localizamos rápidamente el formulario que aparece inicialmente (CMSplash) y el temporizador que contiene (Timer1). Inicialmente el timer tiene un interval de 7000, es decir, la nag se muestra durante 7 segundos. Es tan sencillo como cambiarlo por 1 y guardar el ejecutable (File > Save binary as).
Si no disponemos de esta estupenda herramienta, siempre podemos localizar el timer con un editor hexadecimal. Localizamos en Olly el nombre del timer (en las string references lo veréis), y lo buscamos en el editor hexadecimal. La duración de la nag la debemos estimar nosotros y a continuación buscar ese valor hexadecimal. Imaginemos que estimamos que son 7 segundos, lo pasamos a milisegundos y a hexadecimal. 7000 = 0x1B58. Buscamos en el editor hexadecimal «Timer1» y a continuación localizamos el valor 1B58 invertido, es decir, 581B. En las imágenes inferiores se ve claro.
Cambiando el valor ya lo tendriámos.
El algoritmo de este crackme es muy sencillo pero he elegido este en concreto para que veáis las vueltas que da VB para hacer 6 operaciones matemáticas. A continuación tenéis el código íntegro comentado y debajo el resumen.
004081F5 . FF15 F8B04000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>] ; MSVBVM50.__vbaLenBstr 004081FB . 8BF8 MOV EDI,EAX 004081FD . 8B4D E8 MOV ECX,DWORD PTR SS:[EBP-18] 00408200 . 69FF 385B0100 IMUL EDI,EDI,15B38 ; TEMP = Len(nombre) *15B38 00408206 . 51 PUSH ECX 00408207 . 0F80 B7050000 JO CrackmeV.004087C4 0040820D . FF15 0CB14000 CALL DWORD PTR DS:[<&MSVBVM50.#516>] ; MSVBVM50.rtcAnsiValueBstr 00408213 . 0FBFD0 MOVSX EDX,AX ; digito a ax 00408216 . 03FA ADD EDI,EDX ; TEMP +=1digito 00408218 . 0F80 A6050000 JO CrackmeV.004087C4 0040821E . 57 PUSH EDI ; MSVBVM50.__vbaObjSet 0040821F . FF15 F4B04000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrI4>] ; MSVBVM50.__vbaStrI4 00408225 . 8BD0 MOV EDX,EAX 00408227 . 8D4D E0 LEA ECX,DWORD PTR SS:[EBP-20] 0040822A . FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408230 . 8BBD 50FFFFFF MOV EDI,DWORD PTR SS:[EBP-B0] 00408236 . 50 PUSH EAX 00408237 . 57 PUSH EDI ; MSVBVM50.__vbaObjSet 00408238 . FF93 A4000000 CALL DWORD PTR DS:[EBX+A4] ; MSVBVM50.0F050D32 0040823E . 85C0 TEST EAX,EAX 00408240 . 7D 12 JGE SHORT CrackmeV.00408254 00408242 . 68 A4000000 PUSH 0A4 00408247 . 68 AC6F4000 PUSH CrackmeV.00406FAC 0040824C . 57 PUSH EDI ; MSVBVM50.__vbaObjSet 0040824D . 50 PUSH EAX 0040824E . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 00408254 > 8D45 E0 LEA EAX,DWORD PTR SS:[EBP-20] 00408257 . 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 0040825A . 50 PUSH EAX 0040825B . 8D55 E8 LEA EDX,DWORD PTR SS:[EBP-18] 0040825E . 51 PUSH ECX 0040825F . 52 PUSH EDX 00408260 . 6A 03 PUSH 3 00408262 . FF15 80B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>; MSVBVM50.__vbaFreeStrList 00408268 . 83C4 10 ADD ESP,10 0040826B . 8D45 D4 LEA EAX,DWORD PTR SS:[EBP-2C] 0040826E . 8D4D D8 LEA ECX,DWORD PTR SS:[EBP-28] 00408271 . 8D55 DC LEA EDX,DWORD PTR SS:[EBP-24] 00408274 . 50 PUSH EAX 00408275 . 51 PUSH ECX 00408276 . 52 PUSH EDX 00408277 . 6A 03 PUSH 3 00408279 . FF15 08B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>; MSVBVM50.__vbaFreeObjList 0040827F . 8B9D 40FFFFFF MOV EBX,DWORD PTR SS:[EBP-C0] ; CrackmeV.00409A68 00408285 . 83C4 10 ADD ESP,10 00408288 . 8B83 FC020000 MOV EAX,DWORD PTR DS:[EBX+2FC] 0040828E . 56 PUSH ESI 0040828F . 8985 38FFFFFF MOV DWORD PTR SS:[EBP-C8],EAX 00408295 . FFD0 CALL EAX 00408297 . 8B3D 20B14000 MOV EDI,DWORD PTR DS:[<&MSVBVM50.__vbaObjSet>] ; MSVBVM50.__vbaObjSet 0040829D . 50 PUSH EAX 0040829E . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 004082A1 . 50 PUSH EAX 004082A2 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet; <&MSVBVM50.__vbaObjSet> 004082A4 . 56 PUSH ESI 004082A5 . 8985 58FFFFFF MOV DWORD PTR SS:[EBP-A8],EAX 004082AB . FF93 08030000 CALL DWORD PTR DS:[EBX+308] 004082B1 . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 004082B4 . 50 PUSH EAX 004082B5 . 51 PUSH ECX 004082B6 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004082B8 . 8BD8 MOV EBX,EAX 004082BA . 8D45 E8 LEA EAX,DWORD PTR SS:[EBP-18] 004082BD . 50 PUSH EAX 004082BE . 53 PUSH EBX 004082BF . 8B13 MOV EDX,DWORD PTR DS:[EBX] ; MSVBVM50.0F025A95 004082C1 . FF92 A0000000 CALL DWORD PTR DS:[EDX+A0] 004082C7 . 85C0 TEST EAX,EAX 004082C9 . 7D 12 JGE SHORT CrackmeV.004082DD 004082CB . 68 A0000000 PUSH 0A0 004082D0 . 68 AC6F4000 PUSH CrackmeV.00406FAC 004082D5 . 53 PUSH EBX 004082D6 . 50 PUSH EAX 004082D7 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 004082DD > 8B8D 58FFFFFF MOV ECX,DWORD PTR SS:[EBP-A8] 004082E3 . 8B55 E8 MOV EDX,DWORD PTR SS:[EBP-18] 004082E6 . 52 PUSH EDX 004082E7 . 8B19 MOV EBX,DWORD PTR DS:[ECX] 004082E9 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004082EF . D905 08104000 FLD DWORD PTR DS:[401008] 004082F5 . 833D 00904000 00 CMP DWORD PTR DS:[409000],0 004082FC . 75 08 JNZ SHORT CrackmeV.00408306 004082FE . D835 0C104000 FDIV DWORD PTR DS:[40100C] ; 10 / 5 = 2 00408304 . EB 0B JMP SHORT CrackmeV.00408311 00408306 > FF35 0C104000 PUSH DWORD PTR DS:[40100C] 0040830C . E8 578DFFFF CALL <JMP.&MSVBVM50._adj_fdiv_m32> 00408311 > 83EC 08 SUB ESP,8 00408314 . DFE0 FSTSW AX 00408316 . A8 0D TEST AL,0D 00408318 . 0F85 A1040000 JNZ CrackmeV.004087BF 0040831E . DEC1 FADDP ST(1),ST ; TEMP +=2 00408320 . DFE0 FSTSW AX 00408322 . A8 0D TEST AL,0D 00408324 . 0F85 95040000 JNZ CrackmeV.004087BF 0040832A . DD1C24 FSTP QWORD PTR SS:[ESP] 0040832D . FF15 48B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>] ; MSVBVM50.__vbaStrR8 00408333 . 8BD0 MOV EDX,EAX 00408335 . 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 00408338 . FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 0040833E . 899D 34FFFFFF MOV DWORD PTR SS:[EBP-CC],EBX 00408344 . 8B9D 58FFFFFF MOV EBX,DWORD PTR SS:[EBP-A8] 0040834A . 50 PUSH EAX 0040834B . 8B85 34FFFFFF MOV EAX,DWORD PTR SS:[EBP-CC] 00408351 . 53 PUSH EBX 00408352 . FF90 A4000000 CALL DWORD PTR DS:[EAX+A4] 00408358 . 85C0 TEST EAX,EAX 0040835A . 7D 12 JGE SHORT CrackmeV.0040836E 0040835C . 68 A4000000 PUSH 0A4 00408361 . 68 AC6F4000 PUSH CrackmeV.00406FAC 00408366 . 53 PUSH EBX 00408367 . 50 PUSH EAX 00408368 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 0040836E > 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 00408371 . 8D55 E8 LEA EDX,DWORD PTR SS:[EBP-18] 00408374 . 51 PUSH ECX 00408375 . 52 PUSH EDX 00408376 . 6A 02 PUSH 2 00408378 . FF15 80B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>; MSVBVM50.__vbaFreeStrList 0040837E . 83C4 0C ADD ESP,0C 00408381 . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 00408384 . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 00408387 . 50 PUSH EAX 00408388 . 51 PUSH ECX 00408389 . 6A 02 PUSH 2 0040838B . FF15 08B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>; MSVBVM50.__vbaFreeObjList 00408391 . 8B95 40FFFFFF MOV EDX,DWORD PTR SS:[EBP-C0] ; CrackmeV.00409A68 00408397 . 83C4 0C ADD ESP,0C 0040839A . 8B82 00030000 MOV EAX,DWORD PTR DS:[EDX+300] 004083A0 . 56 PUSH ESI 004083A1 . 8985 30FFFFFF MOV DWORD PTR SS:[EBP-D0],EAX 004083A7 . FFD0 CALL EAX 004083A9 . 50 PUSH EAX 004083AA . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 004083AD . 50 PUSH EAX 004083AE . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004083B0 . 56 PUSH ESI 004083B1 . 8985 58FFFFFF MOV DWORD PTR SS:[EBP-A8],EAX 004083B7 . FF95 38FFFFFF CALL DWORD PTR SS:[EBP-C8] ; MSVBVM50.0F10C340 004083BD . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 004083C0 . 50 PUSH EAX 004083C1 . 51 PUSH ECX 004083C2 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004083C4 . 8BD8 MOV EBX,EAX 004083C6 . 8D45 E8 LEA EAX,DWORD PTR SS:[EBP-18] 004083C9 . 50 PUSH EAX 004083CA . 53 PUSH EBX 004083CB . 8B13 MOV EDX,DWORD PTR DS:[EBX] ; MSVBVM50.0F025A95 004083CD . FF92 A0000000 CALL DWORD PTR DS:[EDX+A0] 004083D3 . 85C0 TEST EAX,EAX 004083D5 . 7D 12 JGE SHORT CrackmeV.004083E9 004083D7 . 68 A0000000 PUSH 0A0 004083DC . 68 AC6F4000 PUSH CrackmeV.00406FAC 004083E1 . 53 PUSH EBX 004083E2 . 50 PUSH EAX 004083E3 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 004083E9 > 8B8D 58FFFFFF MOV ECX,DWORD PTR SS:[EBP-A8] 004083EF . 8B55 E8 MOV EDX,DWORD PTR SS:[EBP-18] 004083F2 . 52 PUSH EDX 004083F3 . 8B19 MOV EBX,DWORD PTR DS:[ECX] 004083F5 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004083FB . DC0D 10104000 FMUL QWORD PTR DS:[401010] ; *3 00408401 . 83EC 08 SUB ESP,8 ; -2 00408404 . DC25 18104000 FSUB QWORD PTR DS:[401018] 0040840A . DFE0 FSTSW AX 0040840C . A8 0D TEST AL,0D 0040840E . 0F85 AB030000 JNZ CrackmeV.004087BF 00408414 . DD1C24 FSTP QWORD PTR SS:[ESP] 00408417 . FF15 48B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>] ; MSVBVM50.__vbaStrR8 0040841D . 8BD0 MOV EDX,EAX 0040841F . 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 00408422 . FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408428 . 899D 2CFFFFFF MOV DWORD PTR SS:[EBP-D4],EBX 0040842E . 8B9D 58FFFFFF MOV EBX,DWORD PTR SS:[EBP-A8] 00408434 . 50 PUSH EAX 00408435 . 8B85 2CFFFFFF MOV EAX,DWORD PTR SS:[EBP-D4] 0040843B . 53 PUSH EBX 0040843C . FF90 A4000000 CALL DWORD PTR DS:[EAX+A4] 00408442 . 85C0 TEST EAX,EAX 00408444 . 7D 12 JGE SHORT CrackmeV.00408458 00408446 . 68 A4000000 PUSH 0A4 0040844B . 68 AC6F4000 PUSH CrackmeV.00406FAC 00408450 . 53 PUSH EBX 00408451 . 50 PUSH EAX 00408452 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 00408458 > 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 0040845B . 8D55 E8 LEA EDX,DWORD PTR SS:[EBP-18] 0040845E . 51 PUSH ECX 0040845F . 52 PUSH EDX 00408460 . 6A 02 PUSH 2 00408462 . FF15 80B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>; MSVBVM50.__vbaFreeStrList 00408468 . 83C4 0C ADD ESP,0C 0040846B . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 0040846E . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 00408471 . 50 PUSH EAX 00408472 . 51 PUSH ECX 00408473 . 6A 02 PUSH 2 00408475 . FF15 08B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>; MSVBVM50.__vbaFreeObjList 0040847B . 8B95 40FFFFFF MOV EDX,DWORD PTR SS:[EBP-C0] ; CrackmeV.00409A68 00408481 . 83C4 0C ADD ESP,0C 00408484 . 8B82 04030000 MOV EAX,DWORD PTR DS:[EDX+304] 0040848A . 56 PUSH ESI 0040848B . 8985 28FFFFFF MOV DWORD PTR SS:[EBP-D8],EAX 00408491 . FFD0 CALL EAX 00408493 . 50 PUSH EAX 00408494 . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 00408497 . 50 PUSH EAX 00408498 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 0040849A . 56 PUSH ESI 0040849B . 8985 58FFFFFF MOV DWORD PTR SS:[EBP-A8],EAX 004084A1 . FF95 30FFFFFF CALL DWORD PTR SS:[EBP-D0] ; MSVBVM50.0F10C348 004084A7 . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 004084AA . 50 PUSH EAX 004084AB . 51 PUSH ECX 004084AC . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004084AE . 8BD8 MOV EBX,EAX 004084B0 . 8D45 E8 LEA EAX,DWORD PTR SS:[EBP-18] 004084B3 . 50 PUSH EAX 004084B4 . 53 PUSH EBX 004084B5 . 8B13 MOV EDX,DWORD PTR DS:[EBX] ; MSVBVM50.0F025A95 004084B7 . FF92 A0000000 CALL DWORD PTR DS:[EDX+A0] 004084BD . 85C0 TEST EAX,EAX 004084BF . 7D 12 JGE SHORT CrackmeV.004084D3 004084C1 . 68 A0000000 PUSH 0A0 004084C6 . 68 AC6F4000 PUSH CrackmeV.00406FAC 004084CB . 53 PUSH EBX 004084CC . 50 PUSH EAX 004084CD . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 004084D3 > 8B8D 58FFFFFF MOV ECX,DWORD PTR SS:[EBP-A8] 004084D9 . 8B55 E8 MOV EDX,DWORD PTR SS:[EBP-18] 004084DC . 52 PUSH EDX 004084DD . 8B19 MOV EBX,DWORD PTR DS:[ECX] 004084DF . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004084E5 . DC25 20104000 FSUB QWORD PTR DS:[401020] ; TEMP -= -15 004084EB . 83EC 08 SUB ESP,8 004084EE . DFE0 FSTSW AX 004084F0 . A8 0D TEST AL,0D 004084F2 . 0F85 C7020000 JNZ CrackmeV.004087BF ........ 00408677 . /74 62 JE SHORT CrackmeV.004086DB 00408679 . |8B35 14B14000 MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>] ; MSVBVM50.__vbaStrCat 0040867F . |68 C06F4000 PUSH CrackmeV.00406FC0 ; UNICODE "You Get It" 00408684 . |68 DC6F4000 PUSH CrackmeV.00406FDC ; UNICODE "\r\n" 00408689 . |FFD6 CALL ESI ; <&MSVBVM50.__vbaStrCat> 0040868B . |8BD0 MOV EDX,EAX 0040868D . |8D4D E8 LEA ECX,DWORD PTR SS:[EBP-18] 00408690 . |FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408696 . |50 PUSH EAX 00408697 . |68 E86F4000 PUSH CrackmeV.00406FE8 ; UNICODE "KeyGen It Now"
Que se puede resumir en esto.
004081F5 . FF15 F8B04000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>] ; MSVBVM50.__vbaLenBstr 004081FB . 8BF8 MOV EDI,EAX 004081FD . 8B4D E8 MOV ECX,DWORD PTR SS:[EBP-18] 00408200 . 69FF 385B0100 IMUL EDI,EDI,15B38 ; TEMP = Len(nombre) *15B38 00408206 . 51 PUSH ECX 00408207 . 0F80 B7050000 JO CrackmeV.004087C4 0040820D . FF15 0CB14000 CALL DWORD PTR DS:[<&MSVBVM50.#516>] ; MSVBVM50.rtcAnsiValueBstr 00408213 . 0FBFD0 MOVSX EDX,AX ; digito a ax 00408216 . 03FA ADD EDI,EDX ; TEMP +=1digito 00408218 . 0F80 A6050000 JO CrackmeV.004087C4 ........ 004082E9 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004082EF . D905 08104000 FLD DWORD PTR DS:[401008] 004082F5 . 833D 00904000 00 CMP DWORD PTR DS:[409000],0 004082FC . 75 08 JNZ SHORT CrackmeV.00408306 004082FE . D835 0C104000 FDIV DWORD PTR DS:[40100C] ; 10 / 5 = 2 00408304 . EB 0B JMP SHORT CrackmeV.00408311 00408306 > FF35 0C104000 PUSH DWORD PTR DS:[40100C] 0040830C . E8 578DFFFF CALL <JMP.&MSVBVM50._adj_fdiv_m32> 00408311 > 83EC 08 SUB ESP,8 00408314 . DFE0 FSTSW AX 00408316 . A8 0D TEST AL,0D 00408318 . 0F85 A1040000 JNZ CrackmeV.004087BF 0040831E . DEC1 FADDP ST(1),ST ; TEMP +=2 00408320 . DFE0 FSTSW AX 00408322 . A8 0D TEST AL,0D ........ 004083F5 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004083FB . DC0D 10104000 FMUL QWORD PTR DS:[401010] ; TEMP *=3 00408401 . 83EC 08 SUB ESP,8 ; TEMP -=2 00408404 . DC25 18104000 FSUB QWORD PTR DS:[401018] 0040840A . DFE0 FSTSW AX 0040840C . A8 0D TEST AL,0D ........ 004084DF . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004084E5 . DC25 20104000 FSUB QWORD PTR DS:[401020] ; TEMP -= -15 004084EB . 83EC 08 SUB ESP,8 004084EE . DFE0 FSTSW AX 004084F0 . A8 0D TEST AL,0D 004084F2 . 0F85 C7020000 JNZ CrackmeV.004087BF ........ 00408677 . /74 62 JE SHORT CrackmeV.004086DB 00408679 . |8B35 14B14000 MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>] ; MSVBVM50.__vbaStrCat 0040867F . |68 C06F4000 PUSH CrackmeV.00406FC0 ; UNICODE "You Get It" 00408684 . |68 DC6F4000 PUSH CrackmeV.00406FDC ; UNICODE "\r\n" 00408689 . |FFD6 CALL ESI ; <&MSVBVM50.__vbaStrCat> 0040868B . |8BD0 MOV EDX,EAX 0040868D . |8D4D E8 LEA ECX,DWORD PTR SS:[EBP-18] 00408690 . |FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408696 . |50 PUSH EAX 00408697 . |68 E86F4000 PUSH CrackmeV.00406FE8 ; UNICODE "KeyGen It Now"
Y en esto:
TEMP = Len(nombre) *15B38 TEMP += 1ºdigitoascii TEMP +=2 TEMP *=3 TEMP -=2 TEMP +=15
Y el KeyGen nos ocupa una sola línea
txtserial.Text = (((((Len(txtnombre.Text) * 88888) + Asc(Mid(txtn.Text, 1, 1))) + 2) * 3) - 2) + 15
Si nos fijamos en el VBReformer, en el formulario principal vemos muchas cajas de texto.
Las hacemos visibles, guardamos y ejecutamos haber que pasa.
Lo que pasa es que va guardando el resultado de las operaciones en ellas y en la de arriba concretamente está nuestro serial bueno, lo que nos hace poseedores de un KeyGen encubierto.
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.
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.
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.
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.
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.
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.
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.
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.
Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.
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.
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.
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.
100m de cable UTP categoría 6 viene a costar sobre unos 42€.
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.
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€.
Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.
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€.
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.
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.
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á.
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.
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.
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.
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.
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.
Pulsa Configurar.
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.
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.
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.
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.
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.
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.
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.
Se nos entrega un html con un juego que consiste en hacer clic en un botón tantas veces como podamos para ganar al juego. Acompañando al html tenemos un código javascript ofuscado aparentemente con Obfuscator.io
El código javascript ofuscado tiene el siguiente aspecto.
(function(_0x144932, _0xfc69c5) { var _0x187428 = _0x588c,
_0x3064c6 = _0x144932(); while (!![]) { try { var _0xb96d19 = -parseInt(_0x187428(0x1bd)) / 0x1 + parseInt(_0x187428(0x137)) / 0x2 + -parseInt(_0x187428(0x140)) / 0x3 * (-parseInt(_0x187428(0x13b)) / 0x4) + parseInt(_0x187428(0x15e)) / 0x5 * (parseInt(_0x187428(0x18c)) / 0x6) + -parseInt(_0x187428(0x159)) / 0x7 * (parseInt(_0x187428(0x1c3)) / 0x8) + parseInt(_0x187428(0x129)) / 0x9 * (-parseInt(_0x187428(0x149)) / 0xa) + parseInt(_0x187428(0x16d)) / 0xb; if (_0xb96d19 === _0xfc69c5) break;
else _0x3064c6['push'](_0x3064c6['shift']()); } catch (_0x377a04) { _0x3064c6['push'](_0x3064c6['shift']()); } } }(_0x5be3, 0x6fe59));;
function _0x5be3() { var _0x5a2048 = ['Utf8', 'push', 'createDecryptor', 'Malformed\x20UTF-8\x20data', '_ENC_XFORM_MODE', 'string', '_prevBlock', 'extend', '_doReset', 'AnsiX923', 'error', 'fromCharCode', 'object', '130340XnpiqM', '#res', 'HmacSHA256', 'DES', '4FuuDzS', 'finalize', 'byteLength', 'salt', '_keyPriorReset', '372669TnxSTf', '_xformMode', 'HMAC', 'stringify', 'Latin1', 'cfg', 'start', 'padding', 'show', '47650FNyFfQ', 'parse', 'TripleDES', 'MD5', 'ZeroPadding', 'length', 'Rabbit', 'console', 'Base', 'HmacSHA3', 'kdf', '_doFinalize', 'drop', 'BufferedBlockAlgorithm', 'Cipher', 'HmacSHA1', '7PKTjbP', 'CTR', '_reverseMap', 'clone', 'Encryptor', '43750GcrrDy', 'SHA384', 'byteOffset', 'indexOf', 'Word', '#loader', 'algo', 'apply', 'bind', 'HmacMD5', 'Base64', '_key', 'createEncryptor', 'min', '_counter', '4232173VijiOj', '_lBlock', 'You\x20Lose', 'ECB', 'BlockCipherMode', 'ciphertext', 'floor', 'constructor', 'log', 'search', 'flush', 'Iso10126', 'update', 'NoPadding', 'max', 'HmacSHA384', 'SHA512', 'decrypt', '_des2', '(((.+)+)+)+$', 'high', 'U2FsdGVkX189ylLOlgNSxq/TLeSxBr7cYDcRBgMXXS9VmwusKZx1XFDNdpkwg24v98iYGnUATwQVyWwFnlyoCg==', 'charAt', 'return\x20(function()\x20', 'pow', 'prototype', 'compute', 'reset', 'warn', '_rBlock', 'HmacSHA512', '498WcTnbi', 'join', 'HmacSHA224', 'display', '#trim', 'StreamCipher', 'enc', 'click', '#statistic', 'random', 'keySize', 'SHA1', '_process', 'sigBytes', '$super', '#mybut', 'clamp', 'RC4', '_invSubKeys', 'loader', '_cipher', '#backstart', 'BlockCipher', 'formatter', 'WordArray', 'slice', 'decryptBlock', '_minBufferSize', 'execute', '_iv', '_hash', 'mixIn', '__proto__', 'text', 'concat', 'RabbitLegacy', 'ceil', 'splice', 'Utf16LE', 'array[0]', 'function', 'SHA3', 'charCodeAt', 'EvpKDF', 'toString', 'css', '_state', 'Decryptor', 'Hex', '82275HVLogQ', 'ivSize', 'encrypt', '_des1', '_mode', 'words', '5353976ERfqhe', 'init', '_hasher', '_createHmacHelper', '_oKey', 'lib', 'CipherParams', 'x64', '_keySchedule', 'RC4Drop', 'PBKDF2', '__creator', '_subKeys', '_nDataBytes', '_DEC_XFORM_MODE', 'format', 'substr', '_createHelper', '_data', '_parse', '#cssfilter', '_map', 'create', 'OpenSSL', 'hasher', 'table', 'key', 'hide', 'iterations', '#timecount', 'undefined', 'pad', '_iKey', 'CBC', 'OFB', '#apply', 'SHA224', '_keystream', 'mode', 'exception', 'call', 'hasOwnProperty', 'Utf16', 'encryptBlock', '_invKeySchedule', '#buttons', '_doCryptBlock', 'RIPEMD160', 'blockSize', 'low', '_des3', '{}.constructor(\x22return\x20this\x22)(\x20)', '_nRounds', 'Hasher', 'addClass', 'AES', 'CFB', 'sqrt', '171bibExj'];
_0x5be3 = function() { return _0x5a2048; }; return _0x5be3(); }
...
Deofuscado el código con la web Obfuscator.io llegamos a interpretar la estructura aunque sigue siendo un galimatías en gran parte. Aún así, si nos fijamos al final encontramos una parte interesante con una clave encriptada cuya desencriptación depende de una comparación (línea 13 resaltada). Invirtiendo esa comparación engañamos al código y obtenemos la flag.
$("#mybut").click(function () {
_0x4171cc++;
$("#cssfilter").text(_0x4171cc);
});
$("#statistic").addClass("hide");
_0x35a8b9 = setInterval(function () {
_0x97292c--;
$("#timecount").text(_0x97292c);
if (_0x97292c == 0x0) {
clearInterval(_0x35a8b9);
$("#mybut").hide();
$("#buttons").show(0x64);
if (_0x4171cc > _0x43eef3) {
$('#trim').text(CryptoJS.AES.decrypt("U2FsdGVkX189ylLOlgNSxq/TLeSxBr7cYDcRBgMXXS9VmwusKZx1XFDNdpkwg24v98iYGnUATwQVyWwFnlyoCg==", "array[0]").toString(CryptoJS.enc.Utf8));
} else {
$("#trim").text("You Lose");
}
}
}, 0x3e8);
intervalcomp = setInterval(function () {
_0x43eef3++;
$('#apply').text(_0x43eef3);
if (_0x97292c == 0x0) {
clearInterval(intervalcomp);
}
}, 0x32);
}
});
Este Crackme está basado en la protección de DVD Audio Extractor 4.3. Afrontaremos dos partes, una primera donde desempacaremos PECompact 2.x y otra donde analizaremos la rutina de comprobación del número de serie. Os adelante que la única dificultad reside en desempacar ya que la rutina del serial es bastante floja.
El motivo que me ha llevado a realizar un apartado para Ollydbg 1 y otro para Ollydbg 2 es principalmente por que con Ollydbg 2 lo haremos desde Windows 7 x64 y con Ollydbg 1 desde Windos 7 x32.
Videotutorial disponible: http://youtu.be/-63yEUTqP-c.
Resumen de pasos:
1. Cargamos el Crackme en Olly y aparecemos aquí.
2. Pulsamos una vez F9 y veremos esto:
3. Ponemos un breakpoint de la siguiente manera «bp VirtualFree» con la ayuda del plugin CmdBar.
4. Pulsamos F9 dos veces y aparecemos aquí.
5. A continuación pulsamos Ctrl+F9 y veremos esto.
6. Pulsamos F8 hasta salir del RETN anterior y veremos esto.
7. Al final vemos lo que estábamos buscando. El JMP EAX es el salto que nos lleva al punto de entrada original (OEP). Ponemos un breakpoint en JMP EAX y pulsamos F9, cuando se detenga Ollydbg, pulsamos F8 y aparecemos aquí.
8. Ya tenemos a PECompact contra las cuerdas, ahora mismo tenemos el Crackme desempacado en memoria.
Hacemos click en Plugins > OllyDumpEx > Dump process y veremos esto.
Pulsamos en Dump y esto nos generará un archivo que se llama DAE430_CrackMe_dump.
9. A continuación con Import Reconstructor seleccionamos el crackme y pulsamos IAT AutoSearch y Get Imports.
Veremos unas importaciones NO válidas, pulsamos en Show Invalid y las clickamos con el botón derecho > Delete thunks.
Finalmente pulsamos Fix Dump y elegimos el crackme dumpeado anteriormente. Con esto ya hemos finalizado el desempacado.
Videotutorial disponible: http://youtu.be/mm42HRlPXOE
Resumen de pasos:
1. Cargamos el crackme en Ollydbg y vemos esto.
2. Pulsamos F8 hasta que veamos dos Calls. Pulsamos F8 hasta el segundo Call y cuando estemos situados encima de él pulsamos F7 para entrar en el.
Dentro del segundo call veremos esto.
3. Seguimos con F8 y llegamos aquí.
4. Sin tracear, nos desplazamos por el código hasta encontrar un poco más abajo JMP EAX. Le ponemos un breakpoint y pulsamos F9.
5. Cuando estemos situados en JMP EAX pulsamos F8 y llegamos al punto de entrada original (OEP).
6. Ahora con el plugin OllyDump vamos a dumpear el ejecutable que tenemos desempacado en memoria.
Dumpeamos.
7. Finalmente con Import reconstructor arreglamos las importaciones.
Cargamos en Ollydbg el crackme desempacado y en las referencias de texto encontramos el mensaje «Gracias por registrarte». Pulsamos en él y llegamos a la rutina de comprobación del serial que desgranamos a continuación.
00401B89 . 83F9 03 CMP ECX,3 ; Len(nombre) >=3 00401B8C . 0F8E 46010000 JLE DAE430_C.00401CD8 00401B92 . B2 44 MOV DL,44 ; Dl=44(Letra D) 00401B94 . 31C0 XOR EAX,EAX 00401B96 . 31FF XOR EDI,EDI 00401B98 . 381403 CMP BYTE PTR DS:[EBX+EAX],DL ; Compara 1er digito con la letra D 00401B9B . 74 05 JE SHORT DAE430_C.00401BA2 00401B9D > BF 01000000 MOV EDI,1 00401BA2 > 40 INC EAX 00401BA3 . 83F8 04 CMP EAX,4 00401BA6 . 74 0C JE SHORT DAE430_C.00401BB4 00401BA8 . 8A5404 45 MOV DL,BYTE PTR SS:[ESP+EAX+45] ; Memoria 22FAF5 a 22FAF | Lee los digitos A1X 00401BAC . 381403 CMP BYTE PTR DS:[EBX+EAX],DL ; Los compara 00401BAF .^ 75 EC JNZ SHORT DAE430_C.00401B9D 00401BB1 .^ EB EF JMP SHORT DAE430_C.00401BA2 00401BB3 90 NOP 00401BB4 > 66:0FBE4424 53 MOVSX AX,BYTE PTR SS:[ESP+53] ; EAX = 5ºdígito 00401BBA . 8D1480 LEA EDX,DWORD PTR DS:[EAX+EAX*4] ; EAX*4+EAX = A 00401BBD . 8D04D0 LEA EAX,DWORD PTR DS:[EAX+EDX*8] ; A*8 + 5ºdigito=B 00401BC0 . 66:C1E8 08 SHR AX,8 ; B/100=C 00401BC4 . C0F8 02 SAR AL,2 ; C/4=D 00401BC7 . 8A5424 53 MOV DL,BYTE PTR SS:[ESP+53] ; DL = 5ºdígito 00401BCB . C0FA 07 SAR DL,7 ; 5ºdígito/80=E 00401BCE . 29D0 SUB EAX,EDX ; E-D=F 00401BD0 . 8D0480 LEA EAX,DWORD PTR DS:[EAX+EAX*4] ; F*4*F=G 00401BD3 . 8D0480 LEA EAX,DWORD PTR DS:[EAX+EAX*4] ; G*4+G=H 00401BD6 . 8A5424 53 MOV DL,BYTE PTR SS:[ESP+53] ; DL = 5ºdígito 00401BDA . 29C2 SUB EDX,EAX ; 5ºdigito - H = I 00401BDC . 83C2 41 ADD EDX,41 ; I+41 = J 00401BDF . 885424 4A MOV BYTE PTR SS:[ESP+4A],DL ; GUARDA J EN LA MEMORIA 22FAFA 00401BE3 . 66:0FBE4424 54 MOVSX AX,BYTE PTR SS:[ESP+54] 00401BE9 . 8D3480 LEA ESI,DWORD PTR DS:[EAX+EAX*4] 00401BEC . 8D04F0 LEA EAX,DWORD PTR DS:[EAX+ESI*8] 00401BEF . 66:C1E8 08 SHR AX,8 00401BF3 . C0F8 02 SAR AL,2 00401BF6 . 8A4C24 54 MOV CL,BYTE PTR SS:[ESP+54] 00401BFA . C0F9 07 SAR CL,7 00401BFD . 29C8 SUB EAX,ECX 00401BFF . 89C6 MOV ESI,EAX 00401C01 . 8D34B6 LEA ESI,DWORD PTR DS:[ESI+ESI*4] 00401C04 . 8D34B6 LEA ESI,DWORD PTR DS:[ESI+ESI*4] 00401C07 . 8A4424 54 MOV AL,BYTE PTR SS:[ESP+54] 00401C0B . 89F1 MOV ECX,ESI 00401C0D . 29C8 SUB EAX,ECX 00401C0F . 89C6 MOV ESI,EAX 00401C11 . 8D46 41 LEA EAX,DWORD PTR DS:[ESI+41] 00401C14 . 884424 4B MOV BYTE PTR SS:[ESP+4B],AL ; GUARDA J2 EN LA MEMORIA 22FAFB para el 6ºdígito 00401C18 . 66:0FBE4424 55 MOVSX AX,BYTE PTR SS:[ESP+55] 00401C1E . 8D3480 LEA ESI,DWORD PTR DS:[EAX+EAX*4] 00401C21 . 8D04F0 LEA EAX,DWORD PTR DS:[EAX+ESI*8] 00401C24 . 66:C1E8 08 SHR AX,8 00401C28 . C0F8 02 SAR AL,2 00401C2B . 8A4C24 55 MOV CL,BYTE PTR SS:[ESP+55] 00401C2F . C0F9 07 SAR CL,7 00401C32 . 29C8 SUB EAX,ECX 00401C34 . 89C6 MOV ESI,EAX 00401C36 . 8D34B6 LEA ESI,DWORD PTR DS:[ESI+ESI*4] 00401C39 . 8D34B6 LEA ESI,DWORD PTR DS:[ESI+ESI*4] 00401C3C . 8A4424 55 MOV AL,BYTE PTR SS:[ESP+55] 00401C40 . 89F1 MOV ECX,ESI 00401C42 . 29C8 SUB EAX,ECX 00401C44 . 89C6 MOV ESI,EAX 00401C46 . 8D46 41 LEA EAX,DWORD PTR DS:[ESI+41] 00401C49 . 884424 4C MOV BYTE PTR SS:[ESP+4C],AL ; GUARDA J3 EN LA MEMORIA 22FAFC para el 7ºdígito 00401C4D . 66:0FBE4424 56 MOVSX AX,BYTE PTR SS:[ESP+56] 00401C53 . 8D3480 LEA ESI,DWORD PTR DS:[EAX+EAX*4] 00401C56 . 8D04F0 LEA EAX,DWORD PTR DS:[EAX+ESI*8] 00401C59 . 66:C1E8 08 SHR AX,8 00401C5D . C0F8 02 SAR AL,2 00401C60 . 8A4C24 56 MOV CL,BYTE PTR SS:[ESP+56] 00401C64 . C0F9 07 SAR CL,7 00401C67 . 29C8 SUB EAX,ECX 00401C69 . 89C6 MOV ESI,EAX 00401C6B . 8D34B6 LEA ESI,DWORD PTR DS:[ESI+ESI*4] 00401C6E . 8D34B6 LEA ESI,DWORD PTR DS:[ESI+ESI*4] 00401C71 . 8A4424 56 MOV AL,BYTE PTR SS:[ESP+56] 00401C75 . 89F1 MOV ECX,ESI 00401C77 . 29C8 SUB EAX,ECX 00401C79 . 89C6 MOV ESI,EAX 00401C7B . 8D46 41 LEA EAX,DWORD PTR DS:[ESI+41] 00401C7E . 884424 4D MOV BYTE PTR SS:[ESP+4D],AL ; GUARDA J4 EN LA MEMORIA 22FAFD para el 8ºdígito 00401C82 . B8 08000000 MOV EAX,8 00401C87 . 381403 CMP BYTE PTR DS:[EBX+EAX],DL 00401C8A . 74 05 JE SHORT DAE430_C.00401C91 00401C8C > BF 01000000 MOV EDI,1 00401C91 > 40 INC EAX 00401C92 . 83F8 0C CMP EAX,0C 00401C95 . 74 0D JE SHORT DAE430_C.00401CA4 00401C97 . 8A5404 42 MOV DL,BYTE PTR SS:[ESP+EAX+42] 00401C9B . 381403 CMP BYTE PTR DS:[EBX+EAX],DL ; Compara 22FAFA y siguientes con 9, 10, 11 y 12avo digito 00401C9E .^ 75 EC JNZ SHORT DAE430_C.00401C8C 00401CA0 .^ EB EF JMP SHORT DAE430_C.00401C91 00401CA2 . 66:90 NOP 00401CA4 > 89F8 MOV EAX,EDI ; | 00401CA6 . FEC8 DEC AL ; | 00401CA8 . 74 5C JE SHORT DAE430_C.00401D06 ; | 00401CAA . C74424 0C 40000000 MOV DWORD PTR SS:[ESP+C],40 ; | 00401CB2 . C74424 08 4C004100 MOV DWORD PTR SS:[ESP+8],DAE430_C.0041004>; |ASCII "Info" 00401CBA . C74424 04 51004100 MOV DWORD PTR SS:[ESP+4],DAE430_C.0041005>; |ASCII "Gracias por registrarte." 00401CC2 . C70424 00000000 MOV DWORD PTR SS:[ESP],0 ; | 00401CC9 . E8 EE000000 CALL <JMP.&USER32.MessageBoxA> ; \MessageBoxA 00401CCE . 83EC 10 SUB ESP,10 00401CD1 . 31C0 XOR EAX,EAX 00401CD3 .^ E9 F2FBFFFF JMP DAE430_C.004018CA 00401CD8 > C74424 0C 40000000 MOV DWORD PTR SS:[ESP+C],40 ; | 00401CE0 . C74424 08 4C004100 MOV DWORD PTR SS:[ESP+8],DAE430_C.0041004>; |ASCII "Info" 00401CE8 . C74424 04 6A004100 MOV DWORD PTR SS:[ESP+4],DAE430_C.0041006>; |ASCII "Nombre mínimo 4 caracteres." 00401CF0 . C70424 00000000 MOV DWORD PTR SS:[ESP],0 ; | 00401CF7 . E8 C0000000 CALL <JMP.&USER32.MessageBoxA> ; \MessageBoxA 00401CFC . 83EC 10 SUB ESP,10 00401CFF . 31C0 XOR EAX,EAX 00401D01 .^ E9 C4FBFFFF JMP DAE430_C.004018CA 00401D06 > C74424 0C 10000000 MOV DWORD PTR SS:[ESP+C],10 ; | 00401D0E . C74424 08 34004100 MOV DWORD PTR SS:[ESP+8],DAE430_C.0041003>; |ASCII "Error" 00401D16 . C74424 04 3A004100 MOV DWORD PTR SS:[ESP+4],DAE430_C.0041003>; |ASCII "Registro fallido." 00401D1E . C70424 00000000 MOV DWORD PTR SS:[ESP],0 ; | 00401D25 . E8 92000000 CALL <JMP.&USER32.MessageBoxA> ; \MessageBoxA
Resumen
- El nombre debe tener más de 3 dígitos aunque no lo usa para el número de serie. - El serial tiene 12 dígitos dividiendose en tres partes, 111122223333. - La primera parte 1111 es comparada directamente con DA1X. - Segunda parte (2222), para los dígitos 5º, 6º, 7º y 8º hace lo siguiente: dígito *4 + dígito = A A*8 + dígito=B B/100 = C C/4 = D dígito/80 = E E-D = F F*4*F = G G*4+G = H digito - H = I I+41 = J GUARDA J EN LA MEMORIA 22FAFA **Todo esto se puede resumir en dígito mod 19 + 41 - Tercera parte (3333). Finalmente compara el resultado del 5º, 6º, 7º y 8º dígitos con el 9º, 10º, 11º y 12º dígitos.
Ejemplo:
Serial = DA1X12345678 1 - (31h mod 19h) + 41h = 48h(Y) 2 - (32h mod 19h) + 41h = 41h(A) 3 - (33h mod 19h) + 41h = 42h(B) 4 - (34h mod 19h) + 41h = 43h(C) Compara Y con 5 Compara A con 6 Compara B con 7 Compara C con 8 Luego el serial correcto sería DA1X1234YABC
AVISO: Debido a que este reto está en activo no publicaré a donde pertenece.
El reto en cuestión nos presenta un esquema de puertas lógicas y una secuencia binaria que al pasarla por las puertas nos devolverá la solución al reto.
La secuencia binaria es ésta:
110111000001110010010011101100011000001101111110000001011101110011101100011000001101011011111000011010100110111000001010100111111111000101110001010Lo primero que necesitamos saber es que función realiza cada puerta. Si indagamos un poco enseguida llegamos a la conclusión de que el esquema lo componen 3 puertas NOT, cuatro puertas AND y una puerta OR.
El funcionamiento es muy sencillo, la puerta NOT simplemente invierte el dígito de entrada convirtiendo los unos en ceros y los ceros en unos. La puerta AND siempre dará como resultado cero excepto cuando todos dígitos de entrada sean unos, que dará como resultado uno. La puerta OR es contraria a la AND y siempre dará como resultado uno excepto cuando todos los dígitos de entrada sean ceros, que en este caso dará como resultado cero.
Nota: Aunque lo más normal es encontrarse puertas de dos entradas y una salida, cuando tenemos múltiples entradas el funcionamiento es el mismo pudiendo resolverlo de manera secuencial. Por ejemplo, a la primera puerta AND le entran la pista cuatro, la dos y la tres. La solución es hacer cuatro AND dos y el resultado AND tres -> (cuatro AND dos) AND tres.
Teniendo en cuenta el funcionamiento de las puertas y con la ayuda del esquema anterior podemos automatizar el proceso fácilmente. A continuación os dejo el código en .Net.
Dim encoded As String = "110111000001110010010011101100011000001101111110000001011101110011101100011000001101011011111000011010100110111000001010100111111111000101110001010"
Dim uno, dos, tres, cuatro, cinco, seis As String
Dim w, x, y, z, tmp As Integer
For i = 0 To encoded.Length - 1 Step 3
uno = Mid(encoded, i + 1, 1)
dos = Mid(encoded, i + 2, 1)
tres = Mid(encoded, i + 3, 1)
If uno = "1" Then cuatro = "0"
If uno = "0" Then cuatro = "1"
If dos = "1" Then cinco = "0"
If dos = "0" Then cinco = "1"
If tres = "1" Then seis = "0"
If tres = "0" Then seis = "1"
w = CInt(cuatro And dos) And CInt(tres)
x = CInt(uno And cinco) And CInt(tres)
y = CInt(uno And dos) And CInt(seis)
z = CInt(uno And dos) And CInt(tres)
tmp = (w Or x) Or (y Or z)
txt_s.Text &= tmp.ToString
NextObtenemos como resultado: 1100100110100111001111101001111010011000011101100
Si intentamos decodificar la secuencia resultante en bloque no obtenemos ningún resultado pero si tenemos en cuenta que cada letra en binario ocupa siete dígitos enseguida encontramos la solución.
1100100 1101001 1100111 1101001 1110100 1100001 1101100
d i g i t a l
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.
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>
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:
Como véis simplemente se trata de interpretar correctamente la función charAt() y de fijarse bien en los nombres de las variables.
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";
}
}
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.
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:
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:
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
Se nos proporciona la imagen anterior y se nos invita a resolver la ecuación para el menor entero positivo que representa cada fruta. La solución del reto es concatenar «Flag-» a la suma de los valores de las tres frutas.
El enunciado es breve pero ya nos adelanta que existen varias soluciones y que además sólo quieren los números más pequeños que podamos encontrar.
Las frutas están muy bien y son muy sanas pero a nosotros se nos hace más sencillo plantear la ecuación con letras.
\begin{align}
& \frac{x}{y+z}+\frac{y}{x+z}+\frac{z}{x+y}=4\\
\end{align}Para arrojar algo de luz veamos la representación gráfica en 2D y 3D con la ayuda de Desmos.
Las gráficas más que luz nos traen oscuridad de modo que preguntemos a ChatGPT.
resuelve: (x/y+z)+(y/x+z)+(z/x+y)=4 para enteros positivos
Dado que las variables x, y, z son enteros positivos, podemos intentar encontrar una solución para la ecuación bajo estas condiciones. Sin embargo, encontrar una solución exacta puede ser complejo debido a la naturaleza no lineal de la ecuación. Aun así, podemos intentar algunos enfoques:
Voy a realizar un análisis numérico con un rango limitado de valores para ver si encontramos alguna solución que cumpla con las condiciones. Vamos a probar con valores de 1 a 10 para cada variable.
El análisis numérico para valores de en el rango de 1 a 10 no ha encontrado ninguna solución que satisfaga la ecuación. Esto sugiere que, dentro de este rango, no existen combinaciones de enteros positivos que cumplan con la ecuación.
Dado que la ecuación es bastante compleja y no lineal, es posible que las soluciones, si existen, se encuentren fuera del rango considerado o que requieran un enfoque diferente para ser identificadas. Si tienes un rango específico de valores en mente o si hay alguna otra restricción o contexto relevante, por favor házmelo saber para poder ajustar el análisis en consecuencia.
Básicamente nos está invitando a utilizar prueba y error para encontrar una solución, y el prueba y error de las matemáticas no es más que la fuerza bruta en programación.
Partiendo del problema anterior dame un código en python que realice una comprobación recursiva de todas las variables con un rango de 1 a 999.
soluciones = []
rango_valores_x = range(1, 999)
rango_valores_y = range(1, 999)
rango_valores_z = range(1, 999)
for x in rango_valores_x:
for y in rango_valores_y:
for z in rango_valores_z:
# Calculamos el valor de la expresión para cada combinación de x, y, z
valor = x / (y + z) + y / (x + z) + z / (x + y)
# Comprobamos si el valor es igual a 4 y agregamos la solución a la lista
if abs(valor - 4) < 1e-6: # Usamos una pequeña tolerancia para evitar errores de precisión
soluciones.append((x, y, z))
print(soluciones)Dejo resaltada la línea 12 del código ya que en ella reside el problema. Está comprobando con un margen de tolerancia de 10-6 ya que el resultado de las diferentes fracciones no da como resultado exacto 4. Esto es un problema ya que nosotros necesitamos que de exactamente 4 para validar los valores enteros de x, y y z. Pongo un ejemplo para el que se haya perdido con una solución válida para la tolerancia 10-6 siendo x=2, y=264 y z=993.
\begin{align}
& \frac{2}{264+993}+\frac{264}{2+993}+\frac{993}{2+264}=4.000000429\\
\end{align}En otras palabras, ChatGPT nos ha brindado una solución aproximada que no sirve para nuestro propósito. Seguimos probando con el código anterior quitando la tolerancia y con rangos mayores hasta que en 106 paro. Me acaba de quedar claro que con la fuerza bruta no vamos a ninguna parte, o más bien, no tenemos capacidad de computación para resolverlo de ésta manera.
Lo que pasa es que estamos ante una ecuación algebraica de 3 incógnitas que deben ser enteros positivos cuya solución se alcanza mediante la teoría de curvas elípticas.
Las curvas elípticas son fundamentales en matemáticas avanzadas, representadas por la ecuación y2=x3+Ax+B, donde A y B son constantes. Estas curvas son un punto de encuentro entre la geometría, la teoría de números y el álgebra, ofreciendo un campo rico para la exploración y el análisis. En este CTF, nos enfocaremos en los puntos racionales de las curvas elípticas. Utilizando el método tangente-secante, un procedimiento geométrico iterativo, buscaremos ampliar un conjunto finito de soluciones conocidas a la ecuación de la curva. Este método nos permite indagar en la estructura de las soluciones racionales, que potencialmente pueden ser infinitas. Además, estableceremos una conexión entre las soluciones enteras de las ecuaciones diofánticas y los puntos racionales en las curvas elípticas partiendo de la ecuación (1) especificada en el análisis inicial. A pesar de su aparente simplicidad, esta ecuación es conocida por presentar soluciones mínimas de gran tamaño.
Antes de nada, necesitamos saber el grado de la ecuación, de modo que planteamos la ecuación en forma polinómica estándar deshaciéndonos de los denominadores.
\begin{align}
\begin{split}
n(a+b)(b+c)(c+a)=a(a+b)(c+a)+b(b+c)(a+b)+c(c+a)(b+c)
\end{split}
\end{align}Ahora necesitamos expandir y simplificar para llegar a la conclusión de que estamos ante una ecuación diofántica de grado 3. Este proceso es engorroso por la cantidad de términos a manejar así que vamos a utilizar Mathematica como software de respaldo para finalmente obtener el polinomio en la forma de Weierstrass según la ecuación 4.
\begin{align}
& y^2=x^3+109x^2+224x\\
\end{align}donde:
\begin{align}
x = \frac{−28(a+b+2c)}{(6a+6b−c)}\\
y = \frac{364(a−b)}{(6a+6b−c)}
\end{align}Las relación entre la ecuación 3 y los puntos de la curva elíptica se establecen mediante la ecuación 4. Las transformaciones entre las soluciones (a, b, c) y los puntos (x, y) en la curva elíptica vienen dados por las ecuaciones 5 y 6. Con estas transformaciones, cada solución de la ecuación diofántica se puede representar como un punto en la curva elíptica, y las operaciones de suma de puntos en la curva elíptica pueden usarse para encontrar nuevas soluciones de la ecuación diofántica.
El código que tenéis a continuación pertenece al gran trabajo de Aditi Kulkarni [7], que además nos da el resultado para cualquier valor de n. Ojo porque para n=4 el resultado tiene 81 dígitos, para n=6 tiene 134, para n=10 tiene 190 y para n=12 asciende a 2707 dígitos.
(* Asignar un valor numérico a n *)
n = 4;
(* Definir la ecuación de una curva elíptica en términos de n *)
curve4 = y^2 == x^3 + (4*n^2 + 12*n - 3)*x^2 + 32*(n + 3)*x;
(* Encontrar un punto racional en la curva que no sea (4,0) *)
P4 = {x, y} /. First[FindInstance[curve4 && x != 4 && y != 0, {x, y}, Integers]];
(* Función para calcular la pendiente entre dos puntos en la curva,
o la derivada en el punto si son iguales *)
Slope4[{x1_, y1_}, {x2_, y2_}] :=
If[x1 == x2 && y1 == y2,
ImplicitD[curve4, y, x] /. {x -> x1, y -> y1},
(y2 - y1)/(x2 - x1)];
(* Función para calcular la intersección en y de la línea entre dos puntos
o la tangente en el punto si son iguales *)
Intercept4[{x1_, y1_}, {x2_, y2_}] := y1 - Slope4[{x1, y1}, {x2, y2}]*x1;
(* Función para encontrar el siguiente punto racional en la curva *)
nextRational4[{x1_, y1_}, {x2_, y2_}] :=
{Slope4[{x1, y1}, {x2, y2}]^2 - CoefficientList[curve4[[2]], x][[3]] - x1 - x2,
-Slope4[{x1, y1}, {x2, y2}]^3 + Slope4[{x1, y1}, {x2, y2}]*(CoefficientList[curve4[[2]], x][[3]] + x1 + x2) - Intercept4[{x1, y1}, {x2, y2}]};
(* Función para convertir un punto en la curva elíptica a una solución diofántica *)
ellipticToDiophantine[n_, {x_, y_}] :=
{(8*(n + 3) - x + y)/(2*(4 - x)*(n + 3)),
(8*(n + 3) - x - y)/(2*(4 - x)*(n + 3)),
(-4*(n + 3) - (n + 2)*x)/((4 - x)*(n + 3))};
(* Usar nextRational4 para iterar desde P4 hasta encontrar una solución
válida y positiva para la ecuación diofántica *)
sol4 = ellipticToDiophantine[n,
NestWhile[nextRational4[#, P4] &, P4,
! AllTrue[ellipticToDiophantine[n, #], Function[item, item > 0]] &]];
(* Escalar la solución para obtener enteros mínimos *)
MinSol4 = sol4*(LCM @@ Denominator[sol4])
(* Suma de las tres variables*)
Total[MinSol4]
Concatenando Flag- con el resultado de Mathematica tenemos la ansiada flag.
Flag-195725546580804863527010379187516702463973843196699016314931210363268850137105614
ChatGPT ha demostrado ser eficaz en el análisis y la resolución de problemas, siempre que se le proporcione el contexto adecuado. Sin embargo, es importante ser conscientes de que la respuesta proporcionada puede ser aproximada, especialmente si la solución requiere una gran cantidad de recursos computacionales. Por ejemplo, al trabajar con una ecuación diofántica y valores específicos para (x) e (y), ChatGPT puede ayudar a calcular puntos como (P), (2P), (3P), etc., pero hay que tener en cuenta que los resultados para estos puntos pueden ser estimaciones.
Finalmente, os invito a leer la solución de Mingliang Z. [4], en la que se resuelve el problema por completo y de forma muy detallada.
Hoy tenemos aquí un capitulo del gran David Slade, productor de Series como American Gods o Hannibal y director de películas como Hard Candy o 30 días de oscuridad.
Lo que más me ha gustado del capítulo es el guiño que han hecho a la RaspBerry PI. La escena transcurre al inicio del capítulo cuando uno de los protagonistas se conecta a un vehículo para hackearlo con una Raspi 3 Model B con varios pines del GPIO doblados. Os dejo unas capturas a continuación donde se aprecia el logo.
Ya puestos, la conexión parece micro usb tipo B. Al fondo se ve lo que parece un puerto HDMI.
Lo que no me ha gustado es que al fijarme en el software que corre en el vehículo aparece un flamante OMNIBOOT.EXE con un aspecto parecido al símbolo de sistema, es decir, nos intentan vender que en un futuro el software que gestiona el vehículo es alguna variación de Windows, algo poco probable a día de hoy al menos. Con este tipo de predicciones no se puede escupir hacia arriba pero actualmente es más probable un nucleo tipo Linux u otro propietario al estilo Tesla.
Software del vehículo
Os dejo todas las capturas relevantes a continuación.
