Allora partiamo, installato il programma lo lanciamo ed ecco apparire una message box che ci informa gentilemente che il programma si bloccherà tra 7 giorni..vabbè...premiamo ok...andiamo a registrarci và...mica vogliamo vedere bloccari stò programma eh!..dunque "Help"-"Register"..nome e serial a caso, premiamo OK, e TAC, si chiude la edit box dove inseire il nome senza dirci niente...vabbè..vediamo che possiamo fare con SoftIce o con IDA =)
Allora, da SoftIce la via che per ora sembra possibile seguire è quella del bpx hmemcpy, ma come si sa, quando si usa questo bp le cose diventatno sempre lunghe, vediamo dunque prima cosa possiamo fare, innanzitutto facciamo disassemblare il file a IDA, ed andiamo a vedere se c'è qualcosa di interessante nei Names, troviamo una stringa che forse può esserci d'aiuto, la stringa "registered", che viene mossa in eax quà :

:0046D700 B8D0D84600              mov eax, 0046D8D0

:0046D460    mov edi, eax
:0046D462    mov eax, dword ptr [ebp-04]
:0046D465    mov edx, 0046D77C
:0046D46A    call 00403F98
:0046D46F    jne 0046D476
:0046D471    mov ebx, 00000013

* Referenced by (C)onditional Jump at Address:
|:0046D46F(C)
|
:0046D476    mov eax, dword ptr [ebp-04]
:0046D479    mov edx, 0046D788
:0046D47E    call 00403F98
:0046D483    jne 0046D48A
:0046D485    mov ebx, 00000026

* Referenced by a (C)onditional Jump at Address:
|:0046D483(C)
|
:0046D48A    mov eax, dword ptr [ebp-04]
:0046D48D    mov edx, 0046D794
....

E si concludono quà :

:0046D64A    call 00403F98
:0046D64F    jne 0046D656
:0046D651    mov ebx, 000002EF

* Referenced by (C)onditional Jump at Address:
|:0046D64F(C)
|
:0046D656    mov eax, dword ptr [ebp-04]
:0046D659    mov edx, 0046D8A8
:0046D65E    call 00403F98
:0046D663    jne 0046D66A
:0046D665    mov ebx, 0000031A

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0046D663(C)
|
:0046D66A    add ebx, dword ptr [esi+34]
:0046D66D    cmp ebx, edi
:0046D66F    jne 0046D70A
:0046D675    lea edx, dword ptr [ebp+FFFFFE20]
:0046D67B    mov eax, esi

:0046D450       mov eax, dword ptr [ebp-0C]<--- Muove in eax il nostro nome  

:0046D453       call 00404090<--- In questa call controlla che il nome esista e ne estrae la penultima lettera  
:0046D458       mov eax, dword ptr [ebp-10]<--- Muove in eax il serial da noi immesso  

:0046D45B       call 00408A98<--- In questa call calcola il corrispettivo esadecimale del serial..  

:0046D460       mov edi, eax<--- ..che viene poi mosso da eax in edi.  

:0046D462       mov eax, dword ptr [ebp-04]<--- Muove in eax la penultima lettera del nostro nome. 

:0046D465       mov edx, 0046D77C<--- Muove in edx il carattere "a"  

CalcolaSeriale      proc  
      push 50			; max caratteri	
      mov ebx,offset mybuffer
      push ebx     		; buffer d testo	
      push [EditHWnd] 		; handle dell'edit
      Call GetWindowTextA  
      cmp eax, 1  ; il nome ha almeno una lettera?
      jl nonvabene ; no? allora non va bene
      mov edi,1236 ; mettiamo in edi il valore 1236 decimale
      xor ecx, ecx ; azzera ecx
      sub eax,2
      mov dl, byte ptr[ebx+eax] ; Muoviamo in dl la penultima lettera del nostro nome, vi ricordo
				; che dopo il getwindowtexta in ebx abbiamo il contenuto dell'edit box
				; ed in eax abbiamo la lunghezza =)
      mov bl,96	      ; muoviamo in bl il valore del carattere ascii "a" meno 1, il programma ( EyeSee )
		      ; reputa infatti che il penultimo carattere del vostro nome sia per forza minuscolo	    
				
ciclo1:
	inc cl			; incrementiamo cl e bl (che la prima volta varrà "a",poi "b",ecc...)
	inc bl
	cmp bl,dl		; è il nostro penultimo carattere? se no...
	jne ciclo1		; ricomincia il ciclo, se si
	cmp cl,1		; guarda se cl è 1, quindi se il penultimo char è "a"
	jne seclno1		; se nn lo è salta,
	add edi,19		; se lo è aggiunge a 4D4, il valore 13h
	mov eax,edi		; muove edi in eax, visto che questo ci servirà come preparazione
	call EsinDec		; alla call di trasformazione da esadecimale in decimale
	jmp msgbox		; al ritorno da questa potremmo mostrare il seriale =)
	
seclno1:
	call vediamo		; se la penultima lettera non è "a" ..vediamo =)
	call EsinDec
msgbox:	
mov eax,ebp			; dopo la call EsinDec mettiamo il serial in eax
mov byte ptr[eax+4],00		; poniamo a null in quinto byte d eax, il nostro serial sarà
				; infatti sempre di 4 cifre=) e
; Creiamo l'edit Box invece della solita messagebox =)
        push    0                      ; lpParam
        push    [AppHWnd]              ; hInstance
        push    40h                    ; ID dell'edit
        push    [NewHWnd]              ; parent hwnd
  	push    20                    
        push    260             
        push    85                 ; y
        push    50                    ; x
        push    WS_BORDER OR WS_VISIBLE OR WS_CHILD 
	push    eax                ; il serial =)
        push    offset EditClass     
        push    0                     
        call    CreateWindowExA
jmp  msg_loop
CalcolaSeriale endp

vediamo proc  
push eax		; dunque pushiamo eax ed ebx
push ebx
xor eax, eax		; azzera eax
add edi, 19		; aggiungiamo 13h ad edi che vale 4D4h
dec ecx  		; in ecx c'è la differenza, se ci pensate, tra il valore hex del nostro
			; penultimo carattere e il valore 96dec, e questa prima sottrazione ci serve
			; nel caso che il char nostro sia "b", infatti il prog aggiunge 2 volte 13h,
			; se abbiamo "b", sarebbe stato diverso se avesse fatto semplicemente 13h+14h =)

risottrai: 

dec ecx		; dunque risottraiamo 1 da ecx
mov ebx,19	; mettiamo 13h in ebx
add ebx,ecx	; a questo aggiungiamoci l'attuale valore d cl, vedete che se il nostro char è "b"
		; cl valeva 2 prima, ora vale 0 ed a essere aggiunto a eax è 13h, se il npstro char è "c"
		; invece cl valeva all'inizio 3 e ad esser addizionati ad eax saranno 13h e 14h, e così via.
add eax,ebx
test ecx,ecx    ; questo finche ecx è zero
jnz risottrai
add edi,eax     ; aggiungiamo eax ad edx, che già contiene 4D4h+13h
pop ebx		; ripoppiamo ebx ed eax
pop eax
ret
vediamo endp


EsinDec proc    ; ecco la call che porta da esadecimale in decimale il nostro numero

	   ; pushiamo i registri il cui attuale valore ci servirà anche dopo
	push edx
	push ecx
	mov eax,edi	  ; il numero da convertire in hex lo mettiamo in eax
	mov ecx, 10       ; e muoviamo in ecx 10 (0Ah)
	mov [ebp],eax     ; ed in ebp, il valore di eax, che è poi il numero da mettere in dec.

ciclo3:
	xor edx, edx      ; azzeriamo edx
	div ecx		  ; e dividiamo eax per ecx, con il quoziente che và a finire in eax ed
			  ; il resto che và a finire in edx
	add dl, 48	  ; resto a cui aggiungiamo 48 ( 30h ), e se avete a disposizione una	
			  ; tavola ascii capite il perchè =)
	cmp dl, 58        ; e che poi confrontiamo con 58, ovvero con il valore decimale del primo 
			  ; carattere nn numerico nell'ordine delle tabelle ascii ovviamente.
	jb decrementaEbp  ; Se più piccolo si salta
	add dl, 07	  ; altrimenti se è più grande gli si aggiunge un 07. 
decrementaEbp:
	dec ebp		  ; Decrementiamo ebp
	mov [ebp],dl	  ; ed in ebp decrementato si mette il numero ottenuto.
	or eax, eax       ; Se eax non è ancora zero
        jne ciclo3        ; si ricomincia il ciclo.
	pop ecx           ; Alla fine si poppa tutto stando attenti alla regola del LIFO
	pop edx		  ; (Last In First Out) per quanto riguarda lo stack...
	ret		  ; e si ritorna =)
EsinDec  endp

nonvabene:			; MessageBox di edit vuota=)
push MB_OK OR MB_ICONEXCLAMATION
push offset error	
push offset noname
push NULL
Call MessageBoxA
jmp msg_loop

End Start     ; e fine del programma.