CrackMe5.48 che come il precedente (4.48) dovrebbe allettare gli amanti della matematica applicata in quanto stavolta ci viene proposto un algoritmo risolvibile mediante un EQUAZIONE in pi� incognite costruita a partire da un algoritmo con operazioni floating point e dati prelevati da un keyfile, il tutto condito dalla ricerca di un pulsante nascosto da far apparire per poter verificare che il keyfile sia corretto. In pi� una bellissima routine ricorsiva per il calcolo del FATTORIALE di un numero, in puro assembler.

CrakME 5.48 by Lucifer48

(Pulsante nascosto,Keyfile e Floating Point Operation e una Punta di SMC)
Written by Guzura

L'introduzione di oggi la voglio dedicare a un paio di cose che spesso e volentieri sono trascurate (secondo il mio misero parere) da chi si cimenta sulle varie protezioni di programmi commerciali e non.

L' importanza di conoscere a fondo il target da affrontare: con questo intendo dire che prima di buttarsi sul programma vero e proprio esiste una fonte di informazioni preziosa che spesso se consultata riduce di molto il lavoro di individuazione dello schema e della posizione della protezione cio�: l' HELP in linea e i vari ORDER.TXT e README.TXT omnipresenti nei vari programmi. Spesso in questi file trovate informazioni sul tipo di protezione usata, se il programma � completo o se ha funzioni disabilitate. 

A questo proposito vi pasto due pezzi di due HELP di programmi tipici

ESEMPIO 1

Updates to Windows Commander 3.5x from a previous version
If you have Windows Commander 3.0 or later, you can simply install the new version over your old registered version, and the registration will be preserved. If you have version 2.11 or older, your key is no longer valid. The old key wincmd.key had a size of 128 bytes, the new key 1024 bytes. If you are a registered user of Windows Commander 2.11 or earlier, you can get a new key file for free by e-mailing your name, address and registration number

Bhe che ve ne pare, sono stati carini...Questo nell' Help alla voce Updates

ESEMPIO 2

Astrasoft Bzzz! By Howard Tomlinson (C) August 1997
----------------------------------------------------
Username: Unregistered
Registration Code: NONE
----------------------------------------------------
Do Not Modify This Text File UNLESS YOU ARE ADDING
YOUR REGISTRATION NAME & CODE IN THE SPACE ABOVE !
Don't delete this file again - it REALLY annoys the wasps.

 

Mi sembra significativo anche questo...Da un file README.TXT nella directory del programma

 

I due esempi mi sembrano esplicativi di quello che intendo, altre volte ho trovato addirittura informazioni sul tipo di algoritmo utilizzato nei controlli con tanto di spiegazione del perch� era sicuro (riporto quello che mi ricordo: La password � lunga 15 caratteri quindi non � possibile fare...), oppure il packer utilizzato per packare il programma quindi il consiglio � PERDETE un paio di minuti per spulciare un p� il programma...

Questo sescondo la mia breve (spero per ora) esperienza...

 

Tools usati

 

1. WDasm32 (per il debugging dato che non � necessario scomodare SICE) 

Exescope   (per capire un paio di cose)

Hiew           (per fare il keyfile)

IDA            (Non ne posso pi� fare a meno...)

Una lista delle operazioni floating point e del loro significato (per capire il funzionamento delle operazioni Floating Point mi sono letto il capitolo relativo su Art Of Assembler...)

URL o FTP del programma

http://www.multimania.com/lucifer48

Notizie sul programma

Un'altro Crackme

Essay

Come ho detto nell' introduzione per questo crackme sar� molto importante intuire quali sono i suggerimenti che il buon Lucifer ci da nel TXT allegato al crackme ma prima lanciamo il crackme e vediamo come si presenta.

Vediamo subito che abbiamo dei bottoni di selezione e una editbox con la scritta "Immortal Descedants" ma nessun PushButton per lanciare il check, quindi, il primo passo sar� proprio far spuntar fuori questo bottone.

Torniamo al file TXT allegato al crackme e diamogli una letta anche per essere sicuri di risolvere il crackme nella maniera voluta dall'autore, vi riporto due frasi che mi hanno suggerito le vie per risolvere parti del crackme:

 

ABOUT THE PROTECTION

Another keyfile, this time, it is completely different than my previous keyfile (crackme v4.48a).
Rules: Always the same, no patching ! Nothing difficult here, there are dozen and dozen of possible keyfile. But more than ever, use your
brain, leave F10 alone ! Umm, i am too nice with you...

 

Usa il cervello e lascia stare F10 (cio� non impazzare a steppare) ! Umm, sono troppo buono con te...

Questi due consigli saranno fondamentali per velocizzare tutta la soluzione e non perdersi nei meandri dell'algoritmo

 

PASSO UNO: Individuazione del pulsante nascosto

Che c'� un pulsante nascosto dovete immaginarvelo ma sicuramente vi puo aiutare dare un occhiata a quali sono le risorse del programma con un programma tipo Exescope che effettivamente vi rivela che sotto il BMP con la faccia della donnina vi sono 3 Bottoni "Ok" che fanno tutti la stessa cosa, ma il problema � farli saltare fuori...

Una via (molto poco elegante) � cambiare proprio con Exescope gli attributi del Bitmap che copre i bottoni rendendolo invisibile, cos� i bottoni sarano scoperti ma perderemo per� l'immagine e penso non sia questo quello che voleva da noi Lucifer... 

La via che ho usato io � stata quella dell'intuizione; pensando alla frase (nel TXT) sopra ho pensato al senso che poteva avere la frase "Sono stato troppo buono con te" e ho pensato che il tutto fosse legato a qualche combinazione dei tasti funzione (visto che parlava di F10) cos� ho provato a premere F1 ottenendo come risultato che cambia la scritta da "First thing: find the secret key..." con "No,No,No... I won't help you..." e se andate avanti con i tasti funzione arrivate a F12 e tada ottenete 1 bottone (e la scritta "Well done ! Now i wish yuo good luck !"), premete altre due volte per ottenere gli altri due...  

La via logica e usare ancora Exescope ma stavolta dare un'occhiata anche al campo Accellerator dove trovate le combianzioni di tasti sfruttate dal programma tra cui sia F1 che F12

 

PASSO DUE: Analisi del codice e individuazione delle parti

Apriamo IDA nostra musa ispiratrice e andiamo a cercare riferimenti alle API che lavorano sui file tipo CreateFileA (dallo string references di Wdasm32 dovrebbe saltarvi all'occhio la stringa "Key.txt") e approssimativamente dovreste riuscire a individuare l'inizio dello schema di protezione da questo punto:

(Scusate le mie Label ma mi aiutano molto...)

004013DD push 24h
004013DF push 0
004013E1 push 80h
004013E6 push 3
004013E8 push 0
004013EA push 0
004013EC push 0C0000000h
004013F1 push offset aKey_txt ; "KEY.TXT"
004013F6 call j_CreateFileA
004013FB cmp eax, 0FFFFFFFFh
004013FE jz SeiFuori
00401404 mov ds:HandleFile, eax
00401409 push 0
0040140B push eax
0040140C call j_GetFileSize
00401411 cmp eax, [esp+10h+var_10]
00401414 jnz loc_40159E
0040141A mov ds:DimFile_$, eax
0040141F push 4
00401421 push 1000h
00401426 push eax
00401427 push 0
00401429 call j_VirtualAlloc
0040142E test eax, eax
00401430 jz loc_40159E
00401436 mov ds:LocazioneByteLetti, eax
0040143B push eax
0040143C push 0
0040143E push offset unk_403809
00401443 push ds:DimFile_$ ; num byte da leggere
00401449 push eax
0040144A push ds:HandleFile; indirizo che riceve i dati cio� la locazione inizializzata prima
00401450 call j_ReadFile
00401455 mov ecx, ds:DimFile_$ ; ecx=DimFile
0040145B pop eax ; in eax la locazione inizializzata che contiene ci� che � stato letto dal file
0040145C
0040145C CicloByteDiversiDaZero: ; CODE XREF: start+46Aj
0040145C cmp byte ptr [eax+ecx-1], 0
00401461 jz loc_40158C ; tutti i byte letti del file devono essere diversi da zero
00401467 dec ecx
00401468 or ecx, ecx
0040146A jnz short CicloByteDiversiDaZero
0040146C push offset TieneCodice
00401471 push 1Eh
00401473 push 0Dh
00401475 push 6Eh
00401477 push ds:dword_40374E
0040147D call j_SendDlgItemMessageA
00401482 mov esi, offset TieneCodice ; metto in esi il codice inserito
00401487 xor ecx, ecx ; azzero ecx
00401489 xor eax, eax ; azzero eax
0040148B xor ebx, ebx ; azzero ebx
0040148D
0040148D CicloTuttoIlCodice: ; CODE XREF: start+49Cj
0040148D lodsb ; trasferisce il byte puntato da esi in eax cio� al primo ciclo il primo val hex del codice inserito
0040148E test al, al
00401490 jz short SonoQui ; cicla per tutti i char
00401492 mov cl, al ; lo muove in cl
00401494 rol eax, 5 ; rolla per 5
00401497 rol ecx, 6 ; rolla per 6
0040149A xor ecx, eax ; xora
0040149C jmp short CicloTuttoIlCodice
0040149E ; ---------------------------------------------------------------------------
0040149E
0040149E SonoQui: ; CODE XREF: start+490j
0040149E xor eax, ecx
004014A0 xor ecx, eax
004014A2 xor eax, ecx
004014A4 add eax, ecx
004014A6 mov ecx, 4
004014AB xor edx, edx
004014AD div ecx
004014AF mov eax, edx
004014B1 xor edx, edx
004014B3 xor ebx, ebx
004014B5 inc eax
004014B6 dec eax
004014B7 jnz short loc_4014C5
004014B9 mov ecx, 3
004014BE mov esi, offset unk_4036F8
004014C3 jmp short ArrivoQui
004014C5 ; ---------------------------------------------------------------------------
004014C5
004014C5 loc_4014C5: ; CODE XREF: start+4B7j
004014C5 dec eax
004014C6 jnz short loc_4014D4
004014C8 mov ecx, 4
004014CD mov esi, offset unk_403680
004014D2 jmp short ArrivoQui
004014D4 ; ---------------------------------------------------------------------------
004014D4
004014D4 loc_4014D4: ; CODE XREF: start+4C6j
004014D4 dec eax
004014D5 jnz short loc_4014E3
004014D7 mov ecx, 5
004014DC mov esi, offset unk_4033B0
004014E1 jmp short ArrivoQui
004014E3 ; ---------------------------------------------------------------------------
004014E3
004014E3 loc_4014E3: ; CODE XREF: start+4D5j
004014E3 mov ecx, 6
004014E8 mov esi, offset unk_402000
004014ED
004014ED ArrivoQui: ; CODE XREF: start+4C3j
004014ED ; start+4D2j ...
004014ED mov eax, offset loc_4014FA
004014F2 push eax
004014F3 mov eax, ecx
004014F5 jmp sub_40173F
004014FA ; ---------------------------------------------------------------------------
004014FA
004014FA loc_4014FA: ; DATA XREF: start+4EDo
004014FA mov ebx, eax ; in base al valore ottenuto dagli xoring del nome ho un certo valore in ebx con GuZuRa(space space) ebx=6 e esi punta a una certo punto di una tabella di valori
004014FC mov edi, ds:LocazioneByteLetti
00401502 xor eax, eax ; azzero eax
00401504 finit ; initialize fpu
00401507 fldz ; push +0.0
00401509
00401509 INIZIO: ; CODE XREF: CODE:00401534j
00401509 lodsb ; carico il primo val della tabella in al
0040150A mov dl, al ; lo metto in dl
0040150C fld1 ; push +1.0
0040150E push ecx ; salvo ecx con GuZuRa(space space) 3
0040150E start endp
0040150E
0040150F
0040150F Su: ; CODE XREF: CODE:00401523j
0040150F lodsb ; a questo punto al � il valore seguente della tabella
00401510 mov al, [eax+edi] ; metto in al il byte del file dato da edi (inizio file) + eax (offset)
00401513 mov ds:ValDelControllo, eax ; lo metto nella locazione che voglio controllare
00401518 fild ds:ValDelControllo ; push di questo val
0040151E fmulp st(1), st ; moltiplica st(1) con st(0) e sr in st(1) pop
00401520 dec ecx
00401521 or ecx, ecx
00401523 jnz short Su
00401525 pop ecx
00401526 cmp dl, 0FFh
00401529 jz short Gi�
0040152B faddp st(1), st ; aggiunge st(0) a st(1) e sr in st(1) pop
0040152D jmp short Gi�Gi�
0040152F ; ---------------------------------------------------------------------------
0040152F
0040152F Gi�: ; CODE XREF: CODE:00401529j
0040152F fsubp st(1), st ; toglie st(0) da st(1) e sr in st(1)   pop
00401531
00401531 Gi�Gi�: ; CODE XREF: CODE:0040152Dj
00401531 dec ebx
00401532 or ebx, ebx
00401534 jnz short INIZIO
00401536 fistp ds:ValDelControllo ; salva in st(0) e pop
0040153C mov eax, offset TieneCodice
00401541 mov cl, [eax]
00401543 cmp ecx, ds:ValDelControllo
00401549 jnz short DaEvitare
0040154B push 8000h
00401550 push 0
00401552 push ds:LocazioneByteLetti
00401558 call j_VirtualFree
0040155D push offset aThisCrackmeIsR ; "This crackme is REGISTERED

THE KEYFILE AND THE SMC

La prima parte dello schema � abbastanza classica e non fa altro che verificare l'esistenza del keyfile la dimensione e se tutto va bene ne fa una lettura mettendo i dati in una locazione che ha inizializzato con VirtualAlloc. Vediamo qui il primo trick da affrontare cio� quella punta di SMC a cui facevo riferimento nel titolo. Ovviamente la dimensione del keyfile che vogliamo la trovate dal cmp che segue la GetFileSize.

Tornando al SMC ve ne accorgete dai parametri che vengono dati in ingresso alla CreateFileA e cio� il nome del keyfile cercato non � "Key.txt" ma bens� "Clef.ID" cio� il programma ha magicamente mutato. Per noi il tutto si traduce nel cambiare il nome al keyfile che dobbiamo generare quindi non � una grossa fatica ma comunque voglio farvi vedere come IDA ci avverte anche di questa cosa.

Per vedere chi chiama la locazione che contiene la stringa "Key.txt" nel programma basta un doppio click sulla striga stessa e arrivate qui:

 

004037D6 aKey_txt db 'KEY.TXT',0 ; DATA XREF: start+3F1o
                                            ; start+19Do
La stringa � effettivamente manipolata da due locazioni, la prima � la nostra, la seconda porta qui (per arrivarci doppio click):

0040119D mov eax, offset aKey_txt+1
004011A2 dec eax
004011A3 xor dword ptr [eax], 483C2908h
004011A9 xor dword ptr [eax+4], 10117Ah

Queste quattro operazioni che sono eseguite prima del Check sul keyfile (sono banali) vanno a trasformare la stringa in "Clef.ID".

Torniamo al keyfile la sua dimensione � 24h cio� 36 byte (io solitamento creo i keyfile con il notepad e mettendoci degli uno tanti quanti sono i byte della lunghezza del keyfile), proseguendo nel codice vedete che la lunghezza del keyfile � messa in una variabile e usata in un ciclo successivo che non fa altro che verificare che tutti i byte del keyfile siano diversi da zero .

 

IL CODICE DA INSERIRE

Dopo aver effettuato i check sulla presenza del keyfile si apre tutta una serie di operazioni sul codice che va inserito nella EditBox e che incomincia dalla locazione :40146C e finisce alla locazione :4014ED ; il codice � gia spiegato e cmq � piuttosto semplice ma � il caso di dare una idea dei passi fondamentali compiuti smembrando un po in parti questa serie di operazioni :

 

Primo passo: acquisizione del codice tramite l' API SendDlgItemMessageA e codice inserito in un buffer

Secondo passo: ciclo di elaborazione del codice, le istruzioni ROL 5 legano ogni esecuzione del ciclo successivo al precedente (steppateci dentro due volte e capirete) dato che si lavora solo su al e cl mentre le ROL modificano tutto EAX e ECX

Terzo passo: da qui in poi il codice non � commentato e il motivo e semplice; guardate come � strutturata questa parte del CrackMe: tutta questa parte di codice serve solo per ottenere un valore in ECX che tra l'altro pu� essere scelto solo tra 3,4,5,6

 

Insomma tutta la parte di analisi del codice serve solo per mettere un valore in ECX e questa non � una conclusione banale per i seguenti due motivi :

1) posso disenteressarmi di tutto questo pezzo di codice e preoccuparmi solo del valore che finisce in ECX quando arrivo all'istruzione :4014ED

2) se andiamo a vedere le label possiamo notare se il codice inserito e utilizzato in altre situazioni e si vede la seguente cosa: il buffer che contiene il codice inserito viene utilizzato solo nel controllo finale :401543 e a ben guardare solo il primo byte del Codice inserito serve al controllo, cio� abbiamo tutta una serie di codici equivalenti che possiamo utilizzare per il nostro algoritmo a patto che incomincino con lo stesso carattere e arrivino a mettere in ecx lo stesso valore

 

CALCOLO DEL NUMERO DI CICLI DA EFFETTUARE NELL'ALGORITMO

Vi riporto il pezzo di codice dal quale dobbiamo proseguire:

 

004014ED mov eax, offset loc_4014FA
004014F2 push eax
004014F3 mov eax, ecx
004014F5 jmp sub_40173F
004014FA ; ---------------------------------------------------------------------------
004014FA
004014FA loc_4014FA: ; DATA XREF: start+4EDo

 

Dobbiamo eseguire quel jump in :4024F5 e viene salvata la locazione 4014FA che ci servir� per avere un punto di ritorno, poi in EAX viene messo quel famoso valore ECX ottenuto precedentemente; andiamo a vedere dove saltiamo:

 

0040173F ; ��������������� S U B R O U T I N E ���������������������������������������
0040173F
0040173F
0040173F sub_40173F proc near ; CODE XREF: start+4F5j
0040173F ; sub_40173F+15p
0040173F push ecx
00401740 push esi
00401741 push ebx
00401742 mov ebx, eax
00401744 test ebx, ebx
00401746 jnz short Qui
00401748 mov eax, 1
0040174D pop ebx
0040174E pop esi
0040174F pop ecx
00401750 retn
00401751 ; ---------------------------------------------------------------------------
00401751
00401751 Qui: ; CODE XREF: sub_40173F+7j
00401751 mov eax, ebx
00401753 dec eax
00401754 call sub_40173F
00401759 imul ebx
0040175B pop ebx
0040175C pop esi
0040175D pop ecx
0040175E retn
0040175E sub_40173F endp

Subito da notare che � ricorsiva... Vediamo come funziona

Steppateci dentro un paio di volte per farvi un idea di come funziona: la routine si richiama per un numero di volte uguale al valore che sta in eax (ECX ottenuto dal codice) dopo di che esegue :401748 e esce tornando all'istrozione dopo la sua ultima chiamata cio� :401759 poi arriva alla nuova RET :40175E e esce tornando a :401759 e in pratica esegue l'istruzione IMUL per un numero di volte pari a EAX all'inizio (ECX ottenuto dal codice); eax che la prima volta � 1 viene moltiplicato per ebx che aumenta di uno ad ogni esecuzione (in realta ogni pop ebx mette in ebx il valore che era stato usato nel ciclo precedente che quindi era incrementato di uno rispetto all'attuale) in pratica succede questo.

 

Prima IMUL : eax=1 ebx=1 risultato eax=1

Seconda IMUL : eax=1 ebx=2 risultato eax=2

Terza IMUL : eax=2 ebx=3 risultato eax=6

Quarta IMUL : eax=6 ebx=4 risultato eax=24

...

Questo non � altro che il calcolo del FATTORIALE di EAX che si ha in ingresso (quando si entra con il jump a :4014F5) strutturato con una routine ricorsiva.Alla fine si riesce in :4014FA.

In pratica abbiamo ottenuto il fattoriale dell'ECX che avevamo ottenuto dall'elaborazione del codice.

Tutto questo ha come conseguenza la seguente cosa : osservate che il fattoriale � messo in ebx ed ebx � utilizzato solo prima del check finale dopo essere stato decresciuto cio� � stato usato come contatore per il numero di cicli da effettuare nell' algoritmo finale.

MORALE 1): Dal codice inserito posso avere ECX uguale a 3,4,5,6 che si ripercuote sul fatto che posso eseguire il ciclo finale da un minimo di 6 volte (fattoriale di 3) a un massimo di 720 (fattoriale di 6).

MORALE 2): Scielgo un codice che mi faccia eseguire solo 6 volte il ciclo (MICA SIAMO SCIEMI).Io ho usato GuZuRa(space space) cio� GuZuRa seguito da due spazi bianchi che mi dava ebx=6 (cio� ho iniziato a inserire spazi dietro al nick fino a che non ho ottenuto ebx=6, a riguardo vi cito una frase di +ORC che in un suo tut diceva "The wise use of breakpoint makes life easier..." se volete capire)

L'ALGORITMO

Spero che sappiate come funzionano le istruzioni floating point perch� non ve le spiego, mentre cercher� di spiegarvi bene l'algoritmo.

Prima per� una nota sulla tabella a cui punta ESI che � determinata anche lei da quel famoso valore di ECX, considerando che noi vogliamo ECX=3 (per avere ebx=6) e quindi siamo qui con il codice:

 

004014B9 mov ecx, 3
004014BE mov esi, offset unk_4036F8

 

e IDA vi rimanda qua:

unk_4036F8          ; DATA XREF: start+4BEo

004036F8 db 0FFh ;
004036F9 db 2 ; B
004036FA db 4 ; D
004036FB db 6 ; F
004036FC db 0FEh ; �
004036FD db 1 ; A
004036FE db 5 ; E
004036FF db 6 ; F
00403700 db 0FEh ; �
00403701 db 2 ; B
00403702 db 3 ; C
00403703 db 7 ; G
00403704 db 0FFh ;
00403705 db 0 ; I
00403706 db 5 ; E
00403707 db 7 ; G
00403708 db 0FFh ;
00403709 db 1 ; A
0040370A db 3 ; C
0040370B db 8 ; H
0040370C db 0FEh ; �
0040370D db 0 ; I
0040370E db 4 ; D
0040370F db 8 ; H

Bene possiamo incominciare: il codice � quello sopra ed � commentato ma non � assolutamente esplicativo di qual'� il COMPORTAMENO FINALE DELL' ALGORITMO

Ora vi ricordo le parole dell'autore DIMENTICATEVI DI STEPPARE (soprattutto se avete da eseguire 720 cicli)

Cerchiamo di capire invece qual'� lo scopo dell'algoritmo, dobbiamo veramente capirlo da fuori.

Facciamo l'attribuzione letterale che ho fatto sopra per chiarirci le idee perch� tenersi a mente valori,offset e quant'altro non � facile, e quindi quando carichiamo un valore della tabella pensiamo di aver caricato una lettera

 

Per intenderci sui miei commenti al codice vi faccio l'esempio di una istruzione

0040152B faddp st(1), st ; aggiunge st(0) a st(1) e sr in st(1) pop

Immaginatevi la classica struttura a stack: st(0) sta sopra st(1), li sommo metto il risultato in st(1) e faccio una pop cio� tolgo st(0) quindi il vecchio st(1) e diventato il nuovo st(0)

 

Vediamo la struttura dell'algoritmo (vi racconto il primo ciclo dei 6)

Push di +0.0 (� l'inizzializzazione) --> st(0)=+0.0 FATTA FOURI DAL CICLO

Carico il primo valore della tabella e lo metto in DL (al primo giro � FF)

Push di +1.0 --> st(0)=+1.0 e st(1)=+0.0

Push del secondo valore della tabella B --> st(0)=B st(1)=+1.0 st(2)=+0.0

Moltiplica st(1) con st(0) e sr in st(1) pop --> B*1 e lo metto in st(1) poi una pop --> st(0)=B st(1)=+0.0

E ripeto altre due volte (ecx=3) solo che riparto com st(0)=B e non st(0)=0 e non eseguo l'inizzializzazione

Quindi ottengo B*D*F (pensateci un po s�) --> st(0)=B*D*F e st(1)=+0.0

Si confronta dl con FF se seno uguali si salta come nel nostro caso (solo al primo ciclo) e si esegue

Sottraggo st(0) da st(1) e sr in st(1)   pop --> st(1)-st(0)= -B*D*F --> st(0)= -B*D*F

 

A questo punto riprendo tutto il ciclo dall'inizio rimettendo ecx=3 e ricominciando con st(0)= -B*D*F

 

Per la restante seri di valori, in DL finiranno sia degli FF che degli FE quindi occhio che la seconda volta sommer� e cos� via

Alla fine cosa si � ottenuto:

Tenendo conto dello zero all'inizio il valore finale, che si ottiene alla fine del ciclo, che si trova nella variabile che ho chiamato ValDelControllo � dato da

0-(B*D*F)+(A*E*F)+(B*C*G)-(I*E*G)-(A*C*H)+(I*D*H)=47h (Quel famoso primo carattere del codice: io avevo GuZuRa(space space) e G=47h)

 

Ogni lettera rappresenta un valore della tabella che a sua volta rappresenta una locazione all'interno del keyfile (guardate l'istruzione :401510) quindi possiamo usare le lettere come variabili dell'equazione e poi sosituire nel keyfile i valori trovati con le rispettive posizioni (prendiamo la I che nella tabella � lo zero e quindi corrisponde al primo byte del keyfile)

 

RISOLVERE L'EQUAZIONE

Ricordiamoci l'unica restrizione che abbiamo sul keyfile; cio� tutti i byte diversi da zero

L'idea � ridurre il numero di incognite al minimo.

Possiamo fare in modo che -(B*D*F) sia uguale a (A*E*F) in maniera da eliminare parte dell'equazione per� dobbiamo preoccuparci del fatto che le incognite fanno parte di altre parti dell'equazione; soluzione porre tutti i valori uguali a 01

L'equazione si trasforma in (C*G)-(I*G)-(C*H)+(I*H)=47h

Possiamo ora imporre anche C e G ugualia 01 quindi risulta 1-I-H+(I*H)=47h (ovviamente I=1 � IMPOSSIBILE matematicamente)

Possiamo a scelta dare un valore a I o a H e risolvere l'equazione ad una incognita; io ho posto I=2 e risulta 1-2-H+2*H=47, risolvete e ottenete H=48

Abbiamo tutti i valori che devono essere sostituiti nel keyfile e quindi con Hiew facciamolo ricordandoci che I � il primo byte A il secondo...

 

THE FINAL KEYFILE

02 01 01 01-01 01 01 01- 48 Sono i byte che ci servono (sono i primi 9) gli altri fino a riempire la dimensione del file possono essere quello che vi pare

Se avessimo usato un'altro ecx saremmo andati a lavorare con un'altra tabella e in un'altra posizione del keyfile

 

Anche questa � fatta

 

Byez Guzura

 

 

Note finali

Un ringraziamento particolare ad Alga (che non ho l'onore di conoscere) i cui tutorial mi fanno impazzire per bellezza di scrittura e contenuti.Saluto la UIC tutta e alla prossima.

Disclaimer

Vorrei ricordare che sono qui per imparare.

---