LA BIBLE

DU

CRACKEUR

AVANT PROPOS :

Idée, Creation, Diffusion web : MOVAX1St [DSK],

Participation : Mister X, Dr Julo, Cyberbobjr [DSK], Jordan_jr [DSK], Lucifuges rofocales [STYX], +Alt-F4, Mad Flyer, Kephri [X-IT], Xavax1...

Ces textes sont ecrits et diffusés à but d’etudes & analyses. Toute autre utilisation vous met en violation avec le code de la propriété intellectuelle, également diffusés sur le Web. Ces textes ne sont pas ecrits pour une diffusion sur le Web, ce qui explique la mauvaise presentation du site.

Ces textes sont ecrits avec des fautes d’ortographe, et avec les techniques de parlote du web.

Ainsi " que " peut devenir " ke " etc...

Les symboles du web seront aussi utilisés, sans vous les commenter.

Au format. HTML, lisible sous Netscape.(j'ai abandonné le format Word)

Pour des raisons que vous comprendrez aisément, les fichiers étudiés ne sont pas livrables sur ce site.

Pour des raisons de simplicité, de gestion... les cours se verront annotés comme ceci :

A : Débutant

B : Débutant confirmé

C : Moyen

D : Bon

E : Réservé aux decryptage d’algos, dongles etc...

Je demanderais donc à tous les auteurs d’inscrire leurs notes en fonction de ce shéma.

Merci de votre compréhension.

Assez papoter, a l’action.

Sommaire :

ASM, une definition.

L’assembleur est un langage de programmation de tres bas niveaux. De ce fait, il est un peu plus dur que les autres a apprendre et cerner. Il retransmet au processeur des données qu’il peut comprendre, données-elle meme transformée en langage machine. L’assembleur est en quelque sorte une surcouche du langage machine. Ce dernier langage utilise des chiffres 1 & 0 pour communiquer. Imaginez-vous en tapant un courrier avec des 1 & 0 a la place du bonjour. Temps perdus et risquers de fautes.

L’hexadecimal :

..........................

Ce systeme est basés sur l’utilisation des chiffres et de certaines lettres de l’alphabt (de A a F).

Nous connaissons tous le systeme decimal, base 10. L’hexadecimal lui est sur une base de 16.

Mais comment fait-on pour compter ?

Tres simplement, de meme qu’apres 10 il y a 11 dans notre systeme decimal de tous les jours,

En hexa, 9 s’ecrit 09, et 10 ? Comment le calculer ? Nous utileserons les lettres. 10 = 0A, 11 a 0B

Et ainsi de suite jusqu'à 0F, qui lui represente 15. Donc 10 en hexa = 16. C’est le principe qui est à retenir.

Nous aurons l’occasion de revoir l’hexa au cours de ces chapitres, beaucoup plus en details.

Le Binaire :

...................

Comme on l’a vu plus haut, les ordinateurs calculent en base de 2, de 0 a 1, suivant la valeur désirée.

Chaque 0 ou 1 est appelé un bit, 8bits forment un octets. Pour le nombre 1 nous avons 00000001b (le

B signifie binaire), un nombre binaire se decompose ainsi :

128|64|32|16|8|4|2|1

Pour le nombre 1, la premiere case est remplis, (1=remplis). On se fait le 2 : 00000010, et pour le 3, pendant qu’on y est : 00000011. (1ere case =1, 2eme case =2, 1+2=3). Le nombre 11111111 donnera donc 255, car l’addition de 1+2+4+8+16+32+64+128 = 255. Plus il y a de bits, plus le nombre est grand. J’espere que vous avez saisi, bien que cela n’aie pas une importance majeure pour les petits cracks.

Le processeur : Registres generaux & segments.

.............................................................................

Le processeur est composé de différentes parties dont les registres, elements les plus importants de notre processeur. Il existe plusieurs types de registre, registre generaux, d’etat, de segments...

Nous avons plusieurs registres generaux, qui commencent par A, B, C, D.

Ces quatres registres sont tres important. Nous avons AX (16bits) qui se divise en deux petits registres 8 bits,

AL (L=low=bas) et AH (h=high=haut). Nous avons BX (BL et BH), CX (CL et CH) et DX (DL et DH).

Nous rajoutons un E devant les registres pour obtenir du 32 bits (EAX, EBX, ECX, EDX). Notons que nous ne pouvons avoir de EAH ou ECL. Ces registres peuvent recevoir une valeur correspondante a leur capacité.

AX=65535 au maximum et AL =255 au maximum. La partie haute du registre ne peut pas etre modifiés séparément.

Les registres pointeurs eux sont DI (Destination Index), SI (Source Index), BP (Base Pointer), IP (Isnstruction Pointer) et SP (Stack Pointer). Ces registres n’ont pas de partie 8 bits. Ils peuvent etre etendus a 32 bits, en rajoutant un E. les registres SI et DI sont employés pour les instructions de chaines et le registre SP est utilisé lors d’instructions de la pile. Nous verrons cela si ca s’avere necessaire.

Pour pouvoir chercher et placer des choses dans sa memoire, un ordinateur a besoin de ce qu’on appelle une adresse. Celle ci se compose de deux parties de 32 bits. La premiere est le segment et la deuxieme l’offset.

Un exemple : 0A000H :00000H (adresse de la memoire video). Les registres de segments ne sont lus et ecrits que sur 16 bits. Le 386 utilise un offset de 32 bits, mais cela ne change rien vu que la modification du segment ne se fait que sur 16 bits. Il y a six segments a partir du 386 : CS (Code Segment), SS (Stack Segment), DS (Data Segment), ES (Extra Segment), FS & GS (seulement 386).

Quelques instructions :

.....................................

MOV : instruction qui sert à placer (et non pas a deplacer). Elle necessite deux operandes (variables) qui sont la destination & la source. Ceux ci peuvent etre des registres genereaux ou des emplacements memoire. Cependant,

Les opérandes ne peuvent pas etre des toutes les deux des emplacements memoire. La destination ne peut pas non plus etre ce qu’on appelle une valeur immédiate. (Les nombres sont des valeurs immediates), donc la valeur MOV 30,AX est sans sens. Les operandes doivent etre de la meme taille, donc pas de MOV AX,AL.

Ex d’insntructions MOV :

MOV AL, BL (contenu de bl dans cl) pourrait faire si AL=5 & BL=15, nous avons AL=15, BL=15

MOV CX, ES : [DI] place dans CX le contenu 16bits de l’emplacement ES : [DI]

MOV ECX, ES : [DI] (place le contenu 32bits de ES : [DI] dans ecx)

Etc... a vous de vous exercer...

Retenons que l’instruction MOV est comme le signe =.

ADD : sert à additionner et nécéssite 2 opérandes. Une source, et une destination.

La destination prendra la valeur de sources + destination. Les regles de combinaison sont semblables a celles de MOV si ce n’est que l’utilisation des registres de segments est impossible.

Exemples d’ins :

ADD BX, CX pourrait faire si BX=12 & CX =20, nous avons BX=32 et CX=20...

C’est la meme chose pour le 32bits :

ADD EBX, ECX = prendre le contenu d’ecx pour l’additioner a ebx.

Simple non ?

JMP : Jump.. Ai-je besoin de l’expliquer ? ? oui.. bon..

L’instruction JMP sert à modifier l’ip (eip) en consequence changer d’instruction.

JMP 4000 aura pour effet de passer non pas a l’instruction 4000 mais d’aller à l’adresse memoire 4000.

Souvenons-nous qu’une instruction n’est pas égale à une instruction mémoire...

CMP, JZ, JNZ : Ha, celles la, je ne sais pas vraiment comment les decrirent.. Bien sur, je pourrais ouvrir un bouquin mais, j’ai une preference pour le travail de tete... j’vais essayer..

CMP sert à comparer une valeur, souvent pour les sauts conditionnels, ou inconditionnels.

Ecrivons un petit texte asm pour eclaircir tout ca.

MOV AX, 16

INC AX

CMP AX, 32

JZ xxxx  (les x sont des adresses)

A cette partie du prog, nous avons donc le CMP AX, 32 puis un JZ.

Le cmp va tester ax et modifier en consequences les flags...

Le test se fait grace au JZ (saute si egalité), donc tant que ax n’est pas egale a 32, on est balancé à l’adresse renvoyer par le jz. Si nous avions eu un JNZ, notre programme n’aurait pas soter. (JNZ ne sote pas si valeur egale )

Cela est suffisant sur le moment pour que vous compreniez l’usage des CMP, JZ & JNZ.

Nous aurons certainement l’occasion d’etudier ca de plus pres....

NOP : Supprime l’operation..

Dans notre exemple ci-dessus, si nous remplacons le JZ par 2 NOP, le programme continue.

Il y a bien d’autres instructions, mais sur une base de départ, ces derniers suffisent.

Nous reviendrons aisément sur les instructions toutes au long de ces tutoriaux...

Voilà qui complete ma petite intro.

MOVAX1St [DSK_CREW]