hola amigos aqui les traigo un codigo de como genera el serial un programa ahora mi duda es como interpretarlo para generar el keygen:
00404E82 . 52 push edx
00404E83 . 56 push esi
00404E84 . C746 34 0DF0D1BA mov dword ptr ds:[esi+34],BAD1F00D
00404E8B . C746 38 01ADDE10 mov dword ptr ds:[esi+38],10DEAD01
00404E92 . C746 3C EFBE1010 mov dword ptr ds:[esi+3C],1010BEEF
00404E99 . C746 40 D0BA0110 mov dword ptr ds:[esi+40],1001BAD0
00404EA0 . FF91 2C070000 call ds:[ecx+72C]
00404EA6 . 3BC7 cmp eax,edi
00404EA8 . DBE2 fclex
00404EAA . 7D 12 jge short T0RNAD0'.00404EBE
00404EAC . 68 2C070000 push 72C
00404EB1 . 68 14404000 push T0RNAD0'.00404014
00404EB6 . 56 push esi
00404EB7 . 50 push eax
00404EB8 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
00404EBE > 8B45 B4 mov eax,ss:[ebp-4C]
00404EC1 . 8D55 E0 lea edx,ss:[ebp-20]
00404EC4 . 52 push edx
00404EC5 . 50 push eax
00404EC6 . 8B08 mov ecx,ds:[eax]
00404EC8 . 8985 48FFFFFF mov ss:[ebp-B8],eax
00404ECE . FF91 A0000000 call ds:[ecx+A0]
00404ED4 . 3BC7 cmp eax,edi
00404ED6 . DBE2 fclex
00404ED8 . 7D 18 jge short T0RNAD0'.00404EF2
00404EDA . 8B8D 48FFFFFF mov ecx,ss:[ebp-B8]
00404EE0 . 68 A0000000 push 0A0
00404EE5 . 68 7C414000 push T0RNAD0'.0040417C
00404EEA . 51 push ecx
00404EEB . 50 push eax
00404EEC . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
00404EF2 > 8B45 E0 mov eax,ss:[ebp-20]
00404EF5 . 8D55 A0 lea edx,ss:[ebp-60]
00404EF8 . 8945 A8 mov ss:[ebp-58],eax
00404EFB . 6A 01 push 1
00404EFD . 8D45 90 lea eax,ss:[ebp-70]
00404F00 . 52 push edx
00404F01 . 50 push eax
00404F02 . 897D E0 mov ss:[ebp-20],edi
00404F05 . C745 A0 08000000 mov dword ptr ss:[ebp-60],8
00404F0C . FF15 40114000 call ds:[<&MSVBVM60.#619>] ; MSVBVM60.rtcRightCharVar
00404F12 . 8B3D D0104000 mov edi,ds:[<&MSVBVM60.__vbaStrVarVal>] ; MSVBVM60.__vbaStrVarVal
00404F18 . 8D4D 90 lea ecx,ss:[ebp-70]
00404F1B . 8D55 DC lea edx,ss:[ebp-24]
00404F1E . 51 push ecx
00404F1F . 52 push edx
00404F20 . FFD7 call edi ; <&MSVBVM60.__vbaStrVarVal>
00404F22 . 50 push eax
00404F23 . FF15 30104000 call ds:[<&MSVBVM60.#516>] ; MSVBVM60.rtcAnsiValueBstr
00404F29 . 66:6BC0 7B imul ax,ax,7B
00404F2D . 8B4E 34 mov ecx,ds:[esi+34]
00404F30 . 0F80 05070000 jo T0RNAD0'.0040563B
00404F36 . 0FBFC0 movsx eax,ax
00404F39 . 33C8 xor ecx,eax
00404F3B . 894E 34 mov ds:[esi+34],ecx
00404F3E . 8D4D DC lea ecx,ss:[ebp-24]
00404F41 . FF15 5C114000 call ds:[<&MSVBVM60.__vbaFreeStr>] ; MSVBVM60.__vbaFreeStr
00404F47 . 8D4D B4 lea ecx,ss:[ebp-4C]
00404F4A . FF15 60114000 call ds:[<&MSVBVM60.__vbaFreeObj>] ; MSVBVM60.__vbaFreeObj
00404F50 . 8D4D 90 lea ecx,ss:[ebp-70]
00404F53 . 8D55 A0 lea edx,ss:[ebp-60]
00404F56 . 51 push ecx
00404F57 . 52 push edx
00404F58 . 6A 02 push 2
00404F5A . FF15 20104000 call ds:[<&MSVBVM60.__vbaFreeVarList>] ; MSVBVM60.__vbaFreeVarList
00404F60 . 8B06 mov eax,ds:[esi]
00404F62 . 83C4 0C add esp,0C
00404F65 . 8D4D B4 lea ecx,ss:[ebp-4C]
00404F68 . 51 push ecx
00404F69 . 56 push esi
00404F6A . FF90 2C070000 call ds:[eax+72C]
00404F70 . 85C0 test eax,eax
00404F72 . DBE2 fclex
00404F74 . 7D 12 jge short T0RNAD0'.00404F88
00404F76 . 68 2C070000 push 72C
00404F7B . 68 14404000 push T0RNAD0'.00404014
00404F80 . 56 push esi
00404F81 . 50 push eax
00404F82 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
00404F88 > 8B45 B4 mov eax,ss:[ebp-4C]
00404F8B . 8D4D E0 lea ecx,ss:[ebp-20]
00404F8E . 51 push ecx
00404F8F . 50 push eax
00404F90 . 8B10 mov edx,ds:[eax]
00404F92 . 8985 48FFFFFF mov ss:[ebp-B8],eax
00404F98 . FF92 A0000000 call ds:[edx+A0]
00404F9E . 85C0 test eax,eax
00404FA0 . DBE2 fclex
00404FA2 . 7D 18 jge short T0RNAD0'.00404FBC
00404FA4 . 8B95 48FFFFFF mov edx,ss:[ebp-B8]
00404FAA . 68 A0000000 push 0A0
00404FAF . 68 7C414000 push T0RNAD0'.0040417C
00404FB4 . 52 push edx
00404FB5 . 50 push eax
00404FB6 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
00404FBC > 8B45 E0 mov eax,ss:[ebp-20]
00404FBF . 6A 01 push 1
00404FC1 . 8945 A8 mov ss:[ebp-58],eax
00404FC4 . 8D45 A0 lea eax,ss:[ebp-60]
00404FC7 . 8D4D 90 lea ecx,ss:[ebp-70]
00404FCA . 50 push eax
00404FCB . 51 push ecx
00404FCC . C745 E0 00000000 mov dword ptr ss:[ebp-20],0
00404FD3 . C745 A0 08000000 mov dword ptr ss:[ebp-60],8
00404FDA . FF15 2C114000 call ds:[<&MSVBVM60.#617>] ; MSVBVM60.rtcLeftCharVar
00404FE0 . 8D55 90 lea edx,ss:[ebp-70]
00404FE3 . 8D45 DC lea eax,ss:[ebp-24]
00404FE6 . 52 push edx
00404FE7 . 50 push eax
00404FE8 . FFD7 call edi
00404FEA . 50 push eax
00404FEB . FF15 30104000 call ds:[<&MSVBVM60.#516>] ; MSVBVM60.rtcAnsiValueBstr
00404FF1 . 66:6BC0 7B imul ax,ax,7B
00404FF5 . 8B56 3C mov edx,ds:[esi+3C]
00404FF8 . 0F80 3D060000 jo T0RNAD0'.0040563B
00404FFE . 0FBFC8 movsx ecx,ax
00405001 . 33D1 xor edx,ecx
00405003 . 8D4D DC lea ecx,ss:[ebp-24]
00405006 . 8956 3C mov ds:[esi+3C],edx
00405009 . FF15 5C114000 call ds:[<&MSVBVM60.__vbaFreeStr>] ; MSVBVM60.__vbaFreeStr
0040500F . 8D4D B4 lea ecx,ss:[ebp-4C]
00405012 . FF15 60114000 call ds:[<&MSVBVM60.__vbaFreeObj>] ; MSVBVM60.__vbaFreeObj
00405018 . 8D55 90 lea edx,ss:[ebp-70]
0040501B . 8D45 A0 lea eax,ss:[ebp-60]
0040501E . 52 push edx
0040501F . 50 push eax
00405020 . 6A 02 push 2
00405022 . FF15 20104000 call ds:[<&MSVBVM60.__vbaFreeVarList>] ; MSVBVM60.__vbaFreeVarList
00405028 . 66:8BCB mov cx,bx
0040502B . 83C4 0C add esp,0C
0040502E . 66:69C9 4101 imul cx,cx,141
00405033 . 8B46 3C mov eax,ds:[esi+3C]
00405036 . 0F80 FF050000 jo T0RNAD0'.0040563B
0040503C . 0FBFD1 movsx edx,cx
0040503F . 8B4E 38 mov ecx,ds:[esi+38]
00405042 . 33D0 xor edx,eax
00405044 . 33CA xor ecx,edx
00405046 . 66:8BD3 mov dx,bx
00405049 . 66:69D2 4101 imul dx,dx,141
0040504E . 0F80 E7050000 jo T0RNAD0'.0040563B
00405054 . 894E 38 mov ds:[esi+38],ecx
00405057 . 81F1 01010101 xor ecx,1010101
0040505D . 0FBFD2 movsx edx,dx
00405060 . 3356 34 xor edx,ds:[esi+34]
00405063 . 894E 38 mov ds:[esi+38],ecx
00405066 . 35 10101010 xor eax,10101010
0040506B . 8D4D B4 lea ecx,ss:[ebp-4C]
0040506E . 3156 40 xor ds:[esi+40],edx
00405071 . 8946 3C mov ds:[esi+3C],eax
00405074 . 8B06 mov eax,ds:[esi]
00405076 . 51 push ecx
00405077 . 56 push esi
00405078 . FF90 2C070000 call ds:[eax+72C]
0040507E . 85C0 test eax,eax
00405080 . DBE2 fclex
00405082 . 7D 12 jge short T0RNAD0'.00405096
00405084 . 68 2C070000 push 72C
00405089 . 68 14404000 push T0RNAD0'.00404014
0040508E . 56 push esi
0040508F . 50 push eax
00405090 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
00405096 > 8B45 B4 mov eax,ss:[ebp-4C]
00405099 . 8D4D DC lea ecx,ss:[ebp-24]
0040509C . 51 push ecx
0040509D . 50 push eax
0040509E . 8B10 mov edx,ds:[eax]
004050A0 . 8985 48FFFFFF mov ss:[ebp-B8],eax
004050A6 . FF92 A0000000 call ds:[edx+A0]
004050AC . 85C0 test eax,eax
004050AE . DBE2 fclex
004050B0 . 7D 18 jge short T0RNAD0'.004050CA
004050B2 . 8B95 48FFFFFF mov edx,ss:[ebp-B8]
004050B8 . 68 A0000000 push 0A0
004050BD . 68 7C414000 push T0RNAD0'.0040417C
004050C2 . 52 push edx
004050C3 . 50 push eax
004050C4 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
004050CA > 8B06 mov eax,ds:[esi]
004050CC . 8D4D B0 lea ecx,ss:[ebp-50]
004050CF . 51 push ecx
004050D0 . 56 push esi
004050D1 . FF90 2C070000 call ds:[eax+72C]
004050D7 . 85C0 test eax,eax
004050D9 . DBE2 fclex
004050DB . 7D 12 jge short T0RNAD0'.004050EF
004050DD . 68 2C070000 push 72C
004050E2 . 68 14404000 push T0RNAD0'.00404014
004050E7 . 56 push esi
004050E8 . 50 push eax
004050E9 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
004050EF > 8B45 B0 mov eax,ss:[ebp-50]
004050F2 . 8D4D D0 lea ecx,ss:[ebp-30]
004050F5 . 51 push ecx
004050F6 . 50 push eax
004050F7 . 8B10 mov edx,ds:[eax]
004050F9 . 8985 3CFFFFFF mov ss:[ebp-C4],eax
004050FF . FF92 A0000000 call ds:[edx+A0]
00405105 . 85C0 test eax,eax
00405107 . DBE2 fclex
00405109 . 7D 18 jge short T0RNAD0'.00405123
0040510B . 8B95 3CFFFFFF mov edx,ss:[ebp-C4]
00405111 . 68 A0000000 push 0A0
00405116 . 68 7C414000 push T0RNAD0'.0040417C
0040511B . 52 push edx
0040511C . 50 push eax
0040511D . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj
00405123 > 8B45 D0 mov eax,ss:[ebp-30]
00405126 . 6A 01 push 1
00405128 . 8945 98 mov ss:[ebp-68],eax
0040512B . 8D45 90 lea eax,ss:[ebp-70]
0040512E . 8D4D 80 lea ecx,ss:[ebp-80]
00405131 . 50 push eax
00405132 . 51 push ecx
00405133 . C745 A8 06000000 mov dword ptr ss:[ebp-58],6
0040513A . C745 A0 02000000 mov dword ptr ss:[ebp-60],2
00405141 . C745 D0 00000000 mov dword ptr ss:[ebp-30],0
00405148 . C745 90 08000000 mov dword ptr ss:[ebp-70],8
0040514F . FF15 40114000 call ds:[<&MSVBVM60.#619>] ; MSVBVM60.rtcRightCharVar
00405155 . 8D55 80 lea edx,ss:[ebp-80]
00405158 . 8D45 CC lea eax,ss:[ebp-34]
0040515B . 52 push edx
0040515C . 50 push eax
0040515D . FFD7 call edi
0040515F . 50 push eax
00405160 . FF15 30104000 call ds:[<&MSVBVM60.#516>] ; MSVBVM60.rtcAnsiValueBstr
00405166 . 8B56 40 mov edx,ds:[esi+40]
00405169 . 68 90414000 push T0RNAD0'.00404190 ; UNICODE "L-"
0040516E . 0FBFC8 movsx ecx,ax
00405171 . 8B46 38 mov eax,ds:[esi+38]
00405174 . 53 push ebx
00405175 . 03D0 add edx,eax
00405177 . C785 70FFFFFF 0300000>mov dword ptr ss:[ebp-90],3
00405181 . 0F80 B4040000 jo T0RNAD0'.0040563B
00405187 . 03CA add ecx,edx
00405189 . 0F80 AC040000 jo T0RNAD0'.0040563B
0040518F . 898D 78FFFFFF mov ss:[ebp-88],ecx
00405195 . FF15 04104000 call ds:[<&MSVBVM60.__vbaStrI2>] ; MSVBVM60.__vbaStrI2
0040519B . 8B3D 38114000 mov edi,ds:[<&MSVBVM60.__vbaStrMove>] ; MSVBVM60.__vbaStrMove
004051A1 . 8BD0 mov edx,eax
004051A3 . 8D4D E0 lea ecx,ss:[ebp-20]
004051A6 . FFD7 call edi ; <&MSVBVM60.__vbaStrMove>
004051A8 . 50 push eax
004051A9 . FF15 38104000 call ds:[<&MSVBVM60.__vbaStrCat>] ; MSVBVM60.__vbaStrCat
004051AF . 8BD0 mov edx,eax
004051B1 . 8D4D BC lea ecx,ss:[ebp-44]
004051B4 . FFD7 call edi
004051B6 . 66:83EB 06 sub bx,6
004051BA . 50 push eax
004051BB . 0F80 7A040000 jo T0RNAD0'.0040563B
004051C1 . 0FBFCB movsx ecx,bx
004051C4 . 898D 08FFFFFF mov ss:[ebp-F8],ecx
004051CA . 8D45 A0 lea eax,ss:[ebp-60]
004051CD . DB85 08FFFFFF fild dword ptr ss:[ebp-F8]
004051D3 . 68 9C414000 push T0RNAD0'.0040419C
004051D8 . 50 push eax
004051D9 . DD9D 00FFFFFF fstp qword ptr ss:[ebp-100]
004051DF . DD85 00FFFFFF fld qword ptr ss:[ebp-100]
004051E5 . 833D 00A04000 00 cmp dword ptr ds:[40A000],0
004051EC . 75 08 jnz short T0RNAD0'.004051F6
004051EE . DC35 78114000 fdiv qword ptr ds:[401178]
004051F4 . EB 11 jmp short T0RNAD0'.00405207
004051F6 > FF35 7C114000 push dword ptr ds:[40117C]
004051FC . FF35 78114000 push dword ptr ds:[401178]
00405202 . E8 3DC0FFFF call <jmp.&MSVBVM60._adj_fdiv_m64>
00405207 > DFE0 fstsw ax
00405209 . A8 0D test al,0D
0040520B . 0F85 25040000 jnz T0RNAD0'.00405636
00405211 . FF15 44114000 call ds:[<&MSVBVM60.__vbaR8IntI4>] ; MSVBVM60.__vbaR8IntI4
00405217 . 8B55 DC mov edx,ss:[ebp-24]
0040521A . 50 push eax
0040521B . 52 push edx
0040521C . FF15 6C104000 call ds:[<&MSVBVM60.#631>] ; MSVBVM60.rtcMidCharBstr
00405222 . 8BD0 mov edx,eax
00405224 . 8D4D D8 lea ecx,ss:[ebp-28]
00405227 . FFD7 call edi
00405229 . 8B1D 38104000 mov ebx,ds:[<&MSVBVM60.__vbaStrCat>] ; MSVBVM60.__vbaStrCat
0040522F . 50 push eax
00405230 . FFD3 call ebx ; <&MSVBVM60.__vbaStrCat>
00405232 . 8BD0 mov edx,eax
00405234 . 8D4D D4 lea ecx,ss:[ebp-2C]
00405237 . FFD7 call edi
00405239 . 50 push eax
0040523A . 68 9C414000 push T0RNAD0'.0040419C
0040523F . FFD3 call ebx
00405241 . 8BD0 mov edx,eax
00405243 . 8D4D C4 lea ecx,ss:[ebp-3C]
00405246 . FFD7 call edi
00405248 . 50 push eax
00405249 . 8D85 70FFFFFF lea eax,ss:[ebp-90]
0040524F . 50 push eax
00405250 . FF15 F0104000 call ds:[<&MSVBVM60.#572>] ; MSVBVM60.rtcHexBstrFromVar
00405256 . 8BD0 mov edx,eax
00405258 . 8D4D C8 lea ecx,ss:[ebp-38]
0040525B . FFD7 call edi
0040525D . 50 push eax
0040525E . FF15 B4104000 call ds:[<&MSVBVM60.#713>] ; MSVBVM60.rtcStrReverse
00405264 . 8BD0 mov edx,eax
00405266 . 8D4D C0 lea ecx,ss:[ebp-40]
00405269 . FFD7 call edi
0040526B . 50 push eax
0040526C . FFD3 call ebx
0040526E . 8BD0 mov edx,eax
00405270 . 8D4D B8 lea ecx,ss:[ebp-48]
00405273 . FFD7 call edi
00405275 . 50 push eax
00405276 . FFD3 call ebx
...
00405334 . FF15 80104000 call ds:[<&MSVBVM60.__vbaStrCmp>] ; MSVBVM60.__vbaStrCmp
muchas gracias de antemano.
nunca he hecho esto para ensamblador (no me llevo con ASM), pero si en otros lenguajes
armas en papel el algoritmo, analizas como se comporta y empiezas a buscar cuales son los pasos que sigue para llegar al true, en base a eso, buscas cuales son las características que poseen los valores de entrada que llegan a ello...
esto no es mecanico, esto no es lineal, esto es hacerlo poco a poco... te recomiendo empezar con validaciones simples...
por ejemplo generar una tarjeta de credito valida:
el primer digito indica la marca de la tarjeta (visa, amex, etc)
los otros 3 hacen referencia al banco
para revisar si un numero es valido cada impar se multiplica por 2 (con modulo 10)
luego se suman todos los numeros, si el resultado modulo 10 es 0, el numero es valido
has un algoritmo que genere numeros validos sabiendo que los 4 iniciales son 5052
en serio, te reto, arma un generador de algo tan simple como esto, puedes usar cualquier lenguaje... la unica regla es que no debes usar fuerza bruta, debes generar un numero y este debe ser valido de buenas a primeras
Cita de: engel lex en 8 Abril 2017, 15:17 PM
nunca he hecho esto para ensamblador (no me llevo con ASM), pero si en otros lenguajes
armas en papel el algoritmo, analizas como se comporta y empiezas a buscar cuales son los pasos que sigue para llegar al true, en base a eso, buscas cuales son las características que poseen los valores de entrada que llegan a ello...
esto no es mecanico, esto no es lineal, esto es hacerlo poco a poco... te recomiendo empezar con validaciones simples...
por ejemplo generar una tarjeta de credito valida:
el primer digito indica la marca de la tarjeta (visa, amex, etc)
los otros 3 hacen referencia al banco
para revisar si un numero es valido cada impar se multiplica por 2 (con modulo 10)
luego se suman todos los numeros, si el resultado modulo 10 es 0, el numero es valido
has un algoritmo que genere numeros validos sabiendo que los 4 iniciales son 5052
en serio, te reto, arma un generador de algo tan simple como esto, puedes usar cualquier lenguaje... la unica regla es que no debes usar fuerza bruta, debes generar un numero y este debe ser valido de buenas a primeras
el codigo que coloque es del programa en ollydbg en la parte cuando el genera el serial, no es el codigo de mi keygen, ando buscando es como interpretar el codigo para poder hacer mi keygen...
Citararmas en papel el algoritmo, analizas como se comporta y empiezas a buscar cuales son los pasos que sigue para llegar al true, en base a eso, buscas cuales son las características que poseen los valores de entrada que llegan a ello...
eso te respondí... con todo y ejemplo...
Citarhas un algoritmo que genere numeros validos sabiendo que los 4 iniciales son 5052
te di un algoritmo de validación y te recomendé hacer un keygen (has un algoritmo que generer numeros validos) que lo rompiera, para que tuvieras una primera experiencia simple
a juzgar por las repetidas llamadas a MSVBVM60 se trata de un código programado en visual basic 6.0, bastante dificil analizarlo en assembler.
es preferible trazarlo desde un debbuger para para visual basic.
por la red se consiguen varios desensambladores para vb
Como han dicho, es código VB6.
Por lo que veo, entender lo que hace es programa es relativamente sencillo si lo debugeas con olly. No debería ser mayor problema el interpretar lo que hace y menos reversearlo para hacer un keygen.
Te recomiendo leer tutoriales sobre crackmes de vb6, asi te aclaras sobre cómo debes trabajar con este lenguaje.
Por ej., un tip sería que te centres en las funciones "raras" (__vbaStrVarVal, __vbaStrI2, __vbaStrCat, etc, etc.) y no le des importancia a las funciones "propias" de vb6 (__vbaHresultCheckObj, __vbaFreeObj, __vbaFreeStr, __vbaFreeVarList).
Debes saber que vb6 maneja todas las variables como variant, por lo que no verás los valores directamente en los registros a menos que esté trabajando con ellos directamente (como en la zona donde hace los XORs y donde saca el valor ANSI del string).
En fin, tracea con olly. Analiza. Tómate el tiempo de entender lo que hace el programa.
Saludos!
Cita de: MCKSys Argentina en 8 Abril 2017, 18:31 PM
Como han dicho, es código VB6.
Por lo que veo, entender lo que hace es programa es relativamente sencillo si lo debugeas con olly. No debería ser mayor problema el interpretar lo que hace y menos reversearlo para hacer un keygen.
Te recomiendo leer tutoriales sobre crackmes de vb6, asi te aclaras sobre cómo debes trabajar con este lenguaje.
Por ej., un tip sería que te centres en las funciones "raras" (__vbaStrVarVal, __vbaStrI2, __vbaStrCat, etc, etc.) y no le des importancia a las funciones "propias" de vb6 (__vbaHresultCheckObj, __vbaFreeObj, __vbaFreeStr, __vbaFreeVarList).
Debes saber que vb6 maneja todas las variables como variant, por lo que no verás los valores directamente en los registros a menos que esté trabajando con ellos directamente (como en la zona donde hace los XORs y donde saca el valor ANSI del string).
En fin, tracea con olly. Analiza. Tómate el tiempo de entender lo que hace el programa.
Saludos!
lo veo complicado, hasta ahora lo que se es que estos son los codigos que utiliza para hacer el calculo del serial, pero hasta ahi no se mas nada
C746 34 0DF0D1BA mov dword ptr ds:[esi+34],
BAD1F00D 00404E8B . C746 38 01ADDE10 mov dword ptr ds:[esi+38],
10DEAD01 00404E92 . C746 3C EFBE1010 mov dword ptr ds:[esi+3C],
1010BEEF 00404E99 . C746 40 D0BA0110 mov dword ptr ds:[esi+40],
1001BAD0
te estás trancando en algo complejo sin conocimientos... así no, vas a avanzar muy lento (si logras avanzar en lo absoluto), busca cosas más simples y luego sube el nivel...
a menos que estés acostumbrado a hacer esto, estás tratando de mater un elefante con salvas...
insisto... primero acostúmbrate a reversar algoritmos, (y ahora veo) tambien a entender el lenguaje que estás manejando y tus herramientas (olly)
todavía te estoy dando ejemplos e ignoras y sigues de largo
tambien te lo dice
MCKSys Argentina que en este ámbito es uno de los mejores aquí.
CitarTe recomiendo leer tutoriales sobre crackmes de vb6, asi te aclaras sobre cómo debes trabajar con este lenguaje.
pero tu sigues ignorando y de largo
todavia si sacas el algoritmo en claro, te podría a ayudar a ver que los pasos a seguir para armar un keygen
como ya te han dicho deberías entender más del uso de olly y en este caso de las funciones propias de vb en esta parte que supongo es la que te referís:
52 push edx
00404E83 . 56 push esi
00404E84 . C746 34 0DF0D1BA mov dword ptr ds:[esi+34],BAD1F00D
00404E8B . C746 38 01ADDE10 mov dword ptr ds:[esi+38],10DEAD01
00404E92 . C746 3C EFBE1010 mov dword ptr ds:[esi+3C],1010BEEF
00404E99 . C746 40 D0BA0110 mov dword ptr ds:[esi+40],1001BAD0
00404EA0 . FF91 2C070000 call ds:[ecx+72C] hace un llamado a lo que haya en esa dirección
00404EA6 . 3BC7 cmp eax,edi compara el valor de los registros
00404EA8 . DBE2 fclex basicamente limpia las excepciones
00404EAA . 7D 12 jge short T0RNAD0'.00404EBE salta si es más grande
etc...
usando olly, sabiendo lo mínimo de asm y de vb6 podrías entender que hace.
Cita de: doctorman en 9 Abril 2017, 19:43 PM
lo veo complicado, hasta ahora lo que se es que estos son los codigos que utiliza para hacer el calculo del serial, pero hasta ahi no se mas nada
C746 34 0DF0D1BA mov dword ptr ds:[esi+34],BAD1F00D
00404E8B . C746 38 01ADDE10 mov dword ptr ds:[esi+38],10DEAD01
00404E92 . C746 3C EFBE1010 mov dword ptr ds:[esi+3C],1010BEEF
00404E99 . C746 40 D0BA0110 mov dword ptr ds:[esi+40],1001BAD0
Mira bro ,si intentas hacer un keygen sin estudiar o leer sobre Cracking ,no lo podrás hacer .te recomiendo que leas el curso de ollydbg desde cero de Ricardo Narvaja ,es excelente