Mensajes

La api para windows es CreateFile. Como nombre de archivo se usa "COM1".

http://msdn.microsoft.com/en-us/library/windows/desktop/aa363858

excelente pdf que explica el tema muy bien:
http://www.robbayer.com/files/serial-win.pdf

Saludos.

De donde sacaste la idea que te tiene que devolver el mismo handle?

Hiciste un muy trabajo reverseando e invirtiendo el codigo  



Felicitaciones.

pd: tambien mola que el keygenme este hecho con masm
pd2: no me tome la molestia de anotar la secuencia pseudo-aleatoria, simplemente use el mismo rand y envie la secuencia a la pila.

dejo las rutinas originales por si alguien le da curiosidad.

Código (asm) [Seleccionar] Expandir


proc validate, user, serial
locals
s dd ?
endl
mov esi, [user]
mov esi, dword[esi]
mov edi, [serial]
lea eax, [s]
cinvoke sscanf, edi, szFmtHex, eax
mov edi, [s]
mov ebx, 8
.encode:
stdcall Rand, 5
mov ecx, eax
add ecx, 3
stdcall Rand, 64
add eax, 8
xor edx, edx
div ecx
mov ecx, edx
ror esi, cl

stdcall Rand, 5
mov ecx, eax
add ecx, 3
stdcall Rand, 64
add eax, 8
xor edx, edx
div ecx
mov ecx, edx
ror edi, cl

xor edi, esi
dec ebx
jnz .encode
mov eax, edi
ret
endp

proc generate, user, key
locals
s dd ?
endl
mov ebx, 8
mov esi, [user]
mov esi, dword[esi]
.initrand:
stdcall Rand, 5
add eax, 3
push eax
mov ecx, eax
stdcall Rand, 64
add eax, 8
push eax
xor edx, edx
div ecx
mov ecx, edx
ror esi, cl
stdcall Rand, 5
add eax, 3
push eax
stdcall Rand, 64
add eax, 8
push eax

dec ebx
jnz .initrand

mov edi, [key]
lea eax, [s]
cinvoke sscanf, edi, szFmtHex, eax
mov edi, [s]
mov ebx, 8
.decode:
xor edi, esi
pop eax
pop ecx
xor edx, edx
div ecx
mov ecx, edx
rol edi, cl

pop eax
pop ecx
xor edx, edx
div ecx
mov ecx, edx
rol esi, cl
;xor edi, esi
dec ebx
jnz .decode
;xor edi, esi
mov eax, edi
ret
endp

proc Rand, range  
mov eax,[range]
imul edx, [randseed], 0x08088405
inc edx
mov [randseed], edx
mul edx
mov eax, edx
ret
endp


Intentaste comparar las PE mas detalladamente  de la ejecutable desempacada con upx y la ejecutable desempacada manualmente?
(Para ver las diferencias)

Si es una ejecutable de Borland (Delphi, CppBuilder) entonces en el desempacado manual te faltan secciones, o mejor dicho estan unidas.

si la variable realmente es "LOCAL" entonces esta metida en la pila, y no en el segmento .DATA

4146D2 es .CODE segment, es decir, no es la variable, es la direccion de ejecucion del programa, no tiene nada que ver con una variable.. la variable serial LOCAL.78 y no tenemos ni idea de lo que es... como ya te dije, si realmente es local, es una direccion de la pila.

Estas traceando algo mal... y con la screenshot no se ayuda mucho

 C:\WINDOWS\system32\XP-9857209D.EXE

Saludos.

No vi el programa en cuestion, pero estoy seguro que en este momento el problema que estas teniendo es porque no entiendes el concepto de un puntero, y para el caso, hasta puede ser puntero a puntero a putnero etc...

suponte este codigo

Código [Seleccionar] Expandir


int var_a = 5

Que significa eso?
"var_a"  es un entero igual a 5.

pero ese en un lenguaje de programacion. para el cpu no existe tal cosa como "var_a"

Para el cpu existe una direccion de momeria, digamos 40100. El contenido de esa direccion de memoria es 5.

Para que veas la diferencia en pseudo codigo de maquina:

Código [Seleccionar] Expandir


var_a seria equivalente a 40100
[var_a] contenido var_a seria equivalente a 5
[40100] conenido de 40100 es equivalente a 5


Ahora que pasa si el contenido es una direccion de memoria?

Código [Seleccionar] Expandir


[var_a] = 40200
contenido de var_a es equivalente a 40200 que es otra direccion de memoria

por ejemplo, se podria dar el caso de
var_b = 6
donde var_b seria equivalente a la direccion de memoria 40200

de esta manera, var_a apuntaria a donde se encuentra var_b


Entonces, para llegar a "6" a partir de var_a tendrias que:

tomar el contenido de var_a
ese contenido seria 40200
luego, tomar el contenido de 40200
y ahi llegarias a  [40200]  == 6

recuerda que puede ser puntero a puntero a puntero a puntero a "tu variable"

Para aquellos que lo han intentado resolver, les dejo el source para que vean lo facil que hubiera sido sin la obfuscacion.
[spoiler]

Código (asm) [Seleccionar] Expandir


format PE Console
entry start

include '%fasminc%\win32a.inc'
include '%fasminc%\macro\if.inc'

random_seed = 4234;

macro random {
random_seed = ((random_seed*214013+2531011) shr 16) and 0xffffffff
mov eax, random
}

macro jmp dest {
    push dest
    retn
    db $74
}


macro call dest {
    local ..ret
    push ..ret
    jmp  dest
    ..ret:
}

macro mov dest,src {
    local .._mov,.._over,.._quit
    jmp  .._over
    db $73
    dd $
  .._mov:
    mov dest,src
    jmp .._quit
  .._over:
    jmp .._mov
    cmp ecx, [$]
    db $74
   
  .._quit:
}
macro add dest,src {
    local .._add,.._over,.._quit
    jmp  .._over
    lea eax, [eax* 2 + $]
    db $75
  .._add:
    add dest,src
    jmp .._quit
    cmp eax, $
  .._over:
    jmp .._add
    cmp eax, $
    db $76
  .._quit:
}


macro xor dest,src {
    local .._add,.._over,.._quit
    jmp  .._over
    lea eax, [ebx + ecx * 2 + $]
    db $79
  .._add:
    xor dest,src
    jmp .._quit
  .._over:
    jmp .._add
    lea eax, [ebx + ecx * 2 + $]
    db $7a
  .._quit:
}

macro lea dest,src {
    local .._add,.._over,.._quit
    jmp  .._over
    db $7b
  .._add:
    lea dest,src
    jmp .._quit
  .._over:
    jmp .._add
    db $7c
  .._quit:
}

macro je dest {
local ..over
    jmp ..over
    db $75
    ..over:
    je dest
}

macro push op {
local ..over
    jmp ..over
    cmp eax, [$]
    db $7d
   
    ..over:
    push op
}


section '.data' data readable writeable
szPause  db 'PAUSE',0
szInt db '%i',0
szStr db '%s',0
szHex db '%X',0
szNewStr db '%s',10,13,0
szValid db 'serial valido',10,13,0
szNotValid db 'serial no valido',10,13,0
szInput db 16 dup ?
iSerial dd ?
_printf dd ?
_scanf dd ?
_sscanf dd ?

     
   
   
section '.code' code readable executable
start:
push ebp
mov ebp, esp

mov eax, [printf]
mov [_printf], eax
mov eax, [scanf]
mov [_scanf], eax
mov eax, [sscanf]
mov [_sscanf], eax

xor ebx, ebx
mov esi, 0xFF
push szInput
xor ebx, ebx
push szStr
call [ebx + _scanf]
add esp, 8


push iSerial
push szHex
push szInput
call [_sscanf]
add esp, 12

inc [iSerial]
lea eax, [ebx + szValid + esi * 2]
cmp [iSerial], 0x45AC34BD + 0x1
je end_validation
lea eax, [ebx + szNotValid + esi * 2]
end_validation:
push eax
sub [esp], esi
push szStr
sub [esp + 4], esi
call [ebx + _printf]
add esp, 8

push szPause
call [system]
add esp, 4

pop ebp
retn





section '.idata' import data readable writeable

library kernel32,'kernel32.dll',\
user32,'user32.dll',\
msvcrt,'msvcrt.dll'

include '%fasminc%\api\kernel32.inc'
include '%fasminc%\api\user32.inc'
include '%fasminc%\api\msvcrt.inc'


[/spoiler]
felicitacion under por resolverlo tambien cosa que no es para nada facil el traceo.

Los Europeos estan contentos, ahora no le tienen que devolver a Gadafi los 200 billones de euros que les presto/invirtio xD... bueno, eso tambien explicaria mucho el apoyo que tuvo EEUU en la campaña anti-autoritarismo

La OTAN acaba de poner a Bin Laden como gobernante de Libia.

No era a Saddam Hussein?