Welkom

~~~~~~~~~~

 

Dit kon wel eens het moeilijkste zijn wat je ooit geleerd had. We gaan het hebben over Assambler want asambler is namelijk de langst bestaande programeer taal en word nu nog volop gebruikt door programeurs om hun code te debuggen ...

Assembler zul je niet zo maar gebruiken om een source te schrijven voor bijvoorbeeld een computer speletje daar hebben we andere talen voor zo als C en basic.. Maar aangezien dit een

site is om jou te leren werken met assembler en ook andere dingen. Je zult leren hoe je onder andere Linux shellcodes kunt schrijven en je zult leren dat assembler gebruikt wordt om games te kraken, sterker nog ik laat je zelf ook nog even een programma kraken om skills op te doen om je later als een echte cracker op dit project te storten...

 

Ik wil nu nog wel even vertellen dat je goed moet opletten hoe ik het hier in deze tutorial doe, Snap je het niet ? ... Stop dan meteen en stuur een Emailtje naar [email protected] dan gaan we samen stap voor stap verder om een oplossing te zoeken voor je probleem,doe dit ook !! Want houd er rekening mee dat als je wel ongehoord door gaat dat je schade aan je systeem kan veroorzaken omdat je je geheugen gaat herprogrameren ...

 

Het mooie van een Assembly output is dat als je het begrijpt je van alles om je heen inclusief (de meest) geavanceerde apparateur een een Assembler output kan maken om overzichtelijk te zien wat er gebeurd. Je kan Assembly dus zien als een universele taal die nu na het door worstelen van deze lessen mischien ook door jou gesproken word.

Stel je voor zeg dat iedereen deze taal spreekt. Het leren kost even maar als je het door hebt gaat er een wereld voor je open vooral voor het exploiden van Buffer Overflows in Linux of het omzeilen van een password in Windows.

 

Ziro en ik (Ravecool) proberen jullie een beetje in de de programeer richting te duwen en daar kan Assembler een aangename toevoeging voor zijn ...

 

Redactie:

Dit is het eerste deel van deze tutorial (er komen er 2) het zal in het teken staan van de Linux Stack want we zijn op dit moment afhankelijk van ons linux systeem en kunnen nog geen Microsoft Asembler voorbeelden tonen (Nog Niet !)

 

 

 

 

 

 

De stack

~~~~~~~~~~

 

Zo als ik al zei programeer je met Assambler direct op de Stack dus moet je weten hoe deze werkt..

De Stack kan je als een lange buffer of string zien die naar onder groeit het makkelijkste ken je denken aan een DNA string uit Jurassic Park, deze word gebruikt om tijdelijke data op te slaan bijvoorbeeld waardes van variables maar dat is niet het enige, want het slaat ook het Return address van de onderleggende functie op en wat wil dit zeggen ?...

Je moet een beetje hier aan denken je bent in je huis op de begane grond met een wasmand in je handen en je loopt naar zolder. Boven op zolder laat de je de was draaien en kom je met de wasmand terug op de begane grond..De begegane grond is je Return adress en de wasmand zijn de variable die behandeld zijn op zolder die je dus kan zien als een uitvoerende functie.

Nu heb je dus al een basic handeling op de stack gedaan een functie uitgevoerd en terug gekeerd.

Kijk maar naar het tabel

Je kan nu dus zeggen dat de Begane grond je Return address is Laten we van dit voorbeeld een C sourced programma maken en die later in Assembler vertalen ...

DeWas... // was.c //

-------------->8---- Cut Here -------------

 

void zolder(int a,int b,int c,int d){
int x2;
x2=2;
printf("\nIk ben nu op zolder en doe mijn was routine...\n");
printf("Mijn Base Pointer (EBP) staat nu op : %d",x2);
a=4;b=5;c=6;d=7;
printf("\n\nVariable 0,1,2,3 heb ik de Waarde 0=%d 1=%d 2=%d 3=%d Gegeven\n",a,b,c,d);
printf("\nIk ga nu terug keren ...");
}
main(int argc, char *argv[]) {
int x;
x=1;
printf("Ik ben op de begane grond mijn Address Return Address=%d\n",x);
printf("Ik loop nu naar zolder ..... \n");
zolder(0,1,2,3);
printf("\n\nik ben nu weer terug op de begane grond op Mijn \n");
printf("Return Address is : %d\n\n",x);
}

-------------->8---- Cut Here -------------

** Note..

Kom je in de text een # tegen is dat commentaar bij een output en $ staat voor een Linux Bash shell Prompt.. Bedankt **

 

$ gcc -o was was.c -static

 

Output:

$./was

 

Ik ben op de begane grond mijn Address Return Address=1
Ik loop nu naar zolder .....

Ik ben nu op zolder en doe mijn was routine...
Mijn Base Pointer (EBP) staat nu op : 2

Variable 0,1,2,3 heb ik de Waarde 0=4 1=5 2=6 3=7 Gegeven

Ik ga nu terug keren ...

ik ben nu weer terug op de begane grond op Mijn
Return Address is : 1

...

...

Dit is vrij logish te begrijpen dacht ik zo als we nog even naar onze C source kijken zien we

dat "0" en "1", "2" "3" de variable in deze functie waren, Die we moesten verwerken en later bewerkt terug te laten keren, Nu als we van dit programma de Assembler output bekijken zien we dat de variables van de routine voor jou ogen verkeert om op de stack worden geduwt.

....

0x80482b0 <main+48>: push $0x3
0x80482b2 <main+50>: push $0x2
0x80482b4 <main+52>: push $0x1
0x80482b6 <main+54>: push $0x0
0x80482b8 <main+56>: call 0x8048200 <zolder>
....

 

*Maar Dit is niet zo dit omdat de stack naar onderen groeit en niet zo als een mens dat logisher wijze naar omhoog zal doen ..

Laten we eens gaan kijken wat er in de functie op lijn 0x80482b8 (Zolder) gebeurd want ook daar heb ik een Assembler output van*

 

$gdb was

 

GNU gdb 20010813 (MI_OUT)
Copyright 2001 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-mandrake-linux"...

(gdb) dissamble zolder

Dump of assembler code for function zolder:
0x8048200 <zolder>: push %ebp
0x8048201 <zolder+1>: mov %esp,%ebp
0x8048203 <zolder+3>: sub $0x8,%esp
0x8048206 <zolder+6>: movl $0x2,0xfffffffc(%ebp)
0x804820d <zolder+13>: sub $0xc,%esp
0x8048210 <zolder+16>: push $0x8091b00
0x8048215 <zolder+21>: call 0x80487a0 <printf>
0x804821a <zolder+26>: add $0x10,%esp
0x804821d <zolder+29>: sub $0x8,%esp
0x8048220 <zolder+32>: pushl 0xfffffffc(%ebp)
0x8048223 <zolder+35>: push $0x8091b40
0x8048228 <zolder+40>: call 0x80487a0 <printf>
0x804822d <zolder+45>: add $0x10,%esp
0x8048230 <zolder+48>: movl $0x4,0x8(%ebp)
0x8048237 <zolder+55>: movl $0x5,0xc(%ebp)
0x804823e <zolder+62>: movl $0x6,0x10(%ebp)
0x8048245 <zolder+69>: movl $0x7,0x14(%ebp)
0x804824c <zolder+76>: sub $0xc,%esp
0x804824f <zolder+79>: pushl 0x14(%ebp)
0x8048252 <zolder+82>: pushl 0x10(%ebp)
0x8048255 <zolder+85>: pushl 0xc(%ebp)
0x8048258 <zolder+88>: pushl 0x8(%ebp)
0x804825b <zolder+91>: push $0x8091b80
0x8048260 <zolder+96>: call 0x80487a0 <printf>
0x8048265 <zolder+101>: add $0x20,%esp
0x8048268 <zolder+104>: sub $0xc,%esp
0x804826b <zolder+107>: push $0x8091bc1
0x8048270 <zolder+112>: call 0x80487a0 <printf>
0x8048275 <zolder+117>: add $0x10,%esp
0x8048278 <zolder+120>: mov %ebp,%esp
0x804827a <zolder+122>: pop %ebp
0x804827b <zolder+123>: ret
0x804827c <zolder+124>: lea 0x0(%esi,1),%esi
End of assembler dump.

Als jullie het niet heel erg vinden behandel ik uit deze hele output die je hier boven staat maar maar een paar regels om te laten zien wat er met onze variables gebeurd in de functie Zolder()...

Zo als de output van ons programma ons vertelde veranderde de waarde van "0","1","2","3" in

0=4

1=5

2=6

3=7

 

Maar waar en hoe vinden we dit terug in de assembler output ?.. Nou Hier vind je dat terug kijk maar hier onder:

 

....

0x8048230 <zolder+48>: movl $0x4,0x8(%ebp) #0x8h = 8decimaal
0x8048237 <zolder+55>: movl $0x5,0xc(%ebp) #0xch = 12decimaal
0x804823e <zolder+62>: movl $0x6,0x10(%ebp)#0x10h = 16decimaal
0x8048245 <zolder+69>: movl $0x7,0x14(%ebp)#0x14h = 20decimaal
0x804824c <zolder+76>: sub $0xc,%esp
0x804824f <zolder+79>: pushl 0x14(%ebp)
0x8048252 <zolder+82>: pushl 0x10(%ebp)
0x8048255 <zolder+85>: pushl 0xc(%ebp)
0x8048258 <zolder+88>: pushl 0x8(%ebp)
....

In EBP staan de waardes van de variables zo als ze waren voordat ze naar deze functie gestuurd waren achter elkaar in een lange string ("0=0 1=0 2=0 3=0") want herinner je zelf dat "0","1","2" en "3" op zich lege variables waren..

movl $0x4,0x8(%ebp)

Dit zegt dus stop $0x4h (ook 4decimaal) in pointer %ebp op offset/lijn (hoe je het ook wilt noemen) 0x8h (8 decimaal)...

Dus alles word nu in %ebp geloosd en later op geslagen op de stack door PUSHL

 

0x8048258 <zolder+88>: pushl 0x8(%ebp)

..

Ik ben nu nog iets belangrijks vergeten, Niet alleen het Return address van een onderleggende functie word opgeslagen maar ook de Frame Pointer (EBP) hier in staan de waarde van de variable in een onder leggende functies voor als we later terug keren, Als we naar onse source in C kijken is dat functie Main() als je het van uit Zolder() bekijkt ..

Dit doet assembler op de volgende manier

... __Begin Proloog__ ...

0x8048200 <zolder>: push %ebp
0x8048201 <zolder+1>: mov %esp,%ebp
0x8048203 <zolder+3>: sub $0x8,%esp
... __Begin Proloog__ ...

Wat dit doet is eerst %ebp, op de stack bewaren, Vervolgens krijgt %ebp de waarde van %esp, waardoor dit de nieuwe frame-pointer wordt.

Daarna word er 8 van %esp afgetrokken dit om geheugen vrij te maken voor onse variables "0","1","2","3"

0x8048203 <zolder+3>: sub $0x8,%esp #0x8h is 8decimaal

Dit is logies want er zijn ook 8 aanduiders zijn met hun waarde dat zijn

a=4

b=5

c=6

d=7

Trouwens er word altijd gepusht in een meervoud van 4 bytes Click hier om er meer over te leren.

Bij het verlaten van de functie is er weer die belangrijke proloog die gevolgd moet worden in verband met de Base Pointer die hier boven is besproken Hier onder ziet u hem..

... __Exit Proloog__ ...

0x8048278 <zolder+120>: mov %ebp,%esp
0x804827a <zolder+122>: pop %ebp
0x804827b <zolder+123>: ret
... __Exit Proloog__ ...

 

Ik zal vertellen wat dit hier doet boven in het begin Proloog waar we de functie binnen kwamen werd %esp (de bewaarde Stack Pointer) geplaatst in de pointer %ebp om de waarde van de variables van de onderleggende functie op het stack te bewaren

0x8048278 <zolder+120>: mov %ebp,%esp

Hier weer aan het einde word de waarde van %ebp weer terug geplaatst in de %esp (Stack Pointer) zodat de STACK weer weet waar in het programma hij moet terug keren en wat de opgeslagen variables waren uit de onder leggende fucntie..

0x804827a <zolder+122>: pop %ebp

Laad de variables van deze fucnctie voor de onder leggende functie dan weet de functie Main() ook wat de de waarde van de variables van functie Zolder() zijn nu de functie ze heefd veranderd.

0x804827b <zolder+123>: ret

Ret betekend ja je raad het al RETURN en zal als het deze instructie tegen komt terug keren naar de vorige en dus onderliggende Functie ...

 

Dit hebben we tot nu toe goed gedaan kijk maar goed het is wel te begrijpen als je het stukje hier boven goed leest. Pff Neem ff tien minuten rust mensen pak een kop koffie want dit is allemaal moeilijk om te leren ik weet het. Ik heb het zelf ook moeten doen nou ja moeten ik was niet echt geinterseerd maar ik wilde bufferoverflow exploits gaan schrijven en daar heb je kennis van Assembler voor nodig,En dus heb ik net als jullie nu op dit moment doen een aantal dagen op mijn kamer achter mijn buro gezeten te zweten. Weet je trouwens te weten waarom de lijn nummers in de output in hex staan en niet gewoon in decimal? Dat is omdat decimaal 0/9 is een 10 cijferig stelsel en het Hex stelsel telt 16 tekens dat zijn 0/9 + A/F al zou je nu een lijn nummer pakken 0x804827a Dit lijkt op zich al een groot getal maar al zou je het terug zetten in decimaal word het getal helemaal groot het zou dan in de buurt zitten van de 8684154

En is het voor vele mensen onoverzichtelijk ...

 

Ik probeer even een soepele overgang te maken maar dat gaat best wel moeilijk, we gaan door met de output van de functie Zolder().

Dan gaan we nu verder in de Assembler source van de Functie Zolder() waar een '#' zonder tekst er achter hebben we al gehad. Waar echter wel tekst achter staat is een stukje commentaar.

 

0x8048200 <zolder>: push %ebp #
0x8048201 <zolder+1>: mov %esp,%ebp # __ Begin Proloog __
0x8048203 <zolder+3>: sub $0x8,%esp #
0x8048206 <zolder+6>: movl $0x2,0xfffffffc(%ebp)
0x804820d <zolder+13>: sub $0xc,%esp
0x8048210 <zolder+16>: push $0x8091b00
0x8048215 <zolder+21>: call 0x80487a0 <printf>
0x804821a <zolder+26>: add $0x10,%esp
0x804821d <zolder+29>: sub $0x8,%esp
0x8048220 <zolder+32>: pushl 0xfffffffc(%ebp)
0x8048223 <zolder+35>: push $0x8091b40
0x8048228 <zolder+40>: call 0x80487a0 <printf>
0x804822d <zolder+45>: add $0x10,%esp
0x8048230 <zolder+48>: movl $0x4,0x8(%ebp)
0x8048237 <zolder+55>: movl $0x5,0xc(%ebp)
0x804823e <zolder+62>: movl $0x6,0x10(%ebp)
0x8048245 <zolder+69>: movl $0x7,0x14(%ebp)
0x804824c <zolder+76>: sub $0xc,%esp
0x804824f <zolder+79>: pushl 0x14(%ebp)
0x8048252 <zolder+82>: pushl 0x10(%ebp)
0x8048255 <zolder+85>: pushl 0xc(%ebp)
0x8048258 <zolder+88>: pushl 0x8(%ebp)
0x804825b <zolder+91>: push $0x8091b80
0x8048260 <zolder+96>: call 0x80487a0 <printf>
0x8048265 <zolder+101>: add $0x20,%esp
0x8048268 <zolder+104>: sub $0xc,%esp
0x804826b <zolder+107>: push $0x8091bc1
0x8048270 <zolder+112>: call 0x80487a0 <printf>
0x8048275 <zolder+117>: add $0x10,%esp #
0x8048278 <zolder+120>: mov %ebp,%esp # __Exit Proloog__
0x804827a <zolder+122>: pop %ebp #
0x804827b <zolder+123>: ret
0x804827c <zolder+124>: lea 0x0(%esi,1),%esi

Goed dan gaan we verder met de volgende regels dit zijn de parameters voor printf wat tekst op het beeld scherm projecteert .

....

0x8048206 <zolder+6>: movl $0x2,0xfffffffc(%ebp)
0x804820d <zolder+13>: sub $0xc,%esp
0x8048210 <zolder+16>: push $0x8091b00
0x8048215 <zolder+21>: call 0x80487a0 <printf>
0x804821a <zolder+26>: add $0x10,%esp
0x804821d <zolder+29>: sub $0x8,%esp
0x8048220 <zolder+32>: pushl 0xfffffffc(%ebp)
0x8048223 <zolder+35>: push $0x8091b40
0x8048228 <zolder+40>: call 0x80487a0 <printf>
0x804822d <zolder+45>: add $0x10,%esp
...

..

0x8048206 <zolder+6>: movl $0x2,0xfffffffc(%ebp)

Plaatst 2 in ebp op 0ffset 0xfffffffc als we onze source er nog eens bij pakken zien we dat prarameter X2 eerst gedeclareerd word en daarna krijgt hij de waarde 2

int x2;
x2=2;

Dat gebeurd dus met deze opdracht dus onse x2=2 staat nu in het geheugen om later terug te keren.

0x804820d <zolder+13>: sub $0xc,%esp #0xc Hex = 12 Decimaal

Er word nog tijdelijk 12Bytes (Meervoud van 4)geheugen vrij gemaakt om de tekst de die we op het scherm gaan afdrukken in het geheugen op te slaan ..

0x8048210 <zolder+16>: push $0x8091b00

De tekst is : "Ik ben nu op zolder en doe mijn was routine..." weet je het nog !

Hier word de tekts waar voor we 12Bytes hebben geleend op de stack gepropt voor de functie printf on te gebruiken..

0x8048215 <zolder+21>: call 0x80487a0 <printf>

Hier word dan eindelijk de functie printf aangeroepen met als variable de tekst die we net op de stack gezet hebben..

Als er nu na de aanroep van de functie printf terug komen in de functie Zolder() dan doen we dat op de lijn 0x804821a deze lijn geefd het volgende commando

0x804821a <zolder+26>: add $0x10,%esp

Hmm dat is grappig hier boven hebben we 12Bytes geleend van de Stack Pointer en nu doen we aardig door er 16 terug te geven want 0x10h = 16 Decimaal.

0x804821d <zolder+29>: sub $0x8,%esp

We maken 0x8h = 8 Decimaal Bytes geheugen vrij voor variables

0x8048220 <zolder+32>: pushl 0xfffffffc(%ebp)

Hier word X2=2; Pas echt op de stack gepusht. Hoe kan ik je nu vertellen ?, dat dit wel X2=2; is ? nou kijk eens naar 0xfffffffc dat hebben we eerder gezien op lijn 0x8048206 daar stopte het X2=2; op het offset 0xfffffffc in de ebp pointer maar sloeg ("PUSH") hem nog niet op op de stack en dat gebeurd nu.

Daar komt bij dat we variable x2 nu nodig hebben want we zijn in de source 'C' bij de volgende regel aan gekomen

printf("Mijn Base Pointer (EBP) staat nu op : %d",x2);

Daar hebben we variabele x2 dus voor nodig want het moet bij de uitvoer van ons programma een voorbeel van de BasePointer weergeven (NIET DE ECHTE !!! Het Gaat hier om het C Programma) .

Als je nu logisch na denkt heeft hij de waarde voor x2 in prinf al gepusht in C was het eerst de tekst en toen x2

 

printf("Mijn Base Pointer (EBP) staat nu op : %d",x2);

| |

| |

 

Tekst

x2

We weten inmiddels dat de stack anders dan logish en verkeert om zij data op de stack drukt kijk klik maar een hier want hier boven hebben we nog zo'n situatie al eens mee gemaakt.

Okey luitjes we we gaan verder ..

0x8048223 <zolder+35>: push $0x8091b40

De tekst is : "Mijn Base Pointer (EBP) staat nu op :"

Ahh hier word dan eindelijk weer de (2e) tekst op de stack geduwd weer voor de functie printf die de tekst en de x2 variabele op scherm projecteert maar zo ver is het nog niet want ,

0x8048228 <zolder+40>: call 0x80487a0 <printf>

Eest moet printf nog aangeroepen worden en dat gebeurt hier op de volgende waar door (met alles wat we >>tot nu toe !!<< verwerkt hebben) we de volgende output krijgen

..

Ik ben nu op zolder en doe mijn was routine... # van 1e prinf routine
Mijn Base Pointer (EBP) staat nu op : 2 #van 2e printf routine
..

We zijn de functie Zolder() al bijna weer uit maar er zijn nog een paar dingen die het programma moet doen want er zijn nog 3 lijnen tekst die op het scherm moeten komen

1. Variable 0,1,2,3 heb ik de Waarde 0=4 1=5 2=6 3=7 Gegeven
2. Ik ga nu terug keren ...

 

Het behandelen van deze tekst door prinf hoef ik niet meer te laten zien als je goed naar de Assembler output krijkt weet je ook wel hoe het zit.

We gaan naar een lijn na de __Exit Proloog__ dat is lijn 0x804827b

0x804827b <zolder+123>: ret

We hebben het al gehad over RET dus dat behoefd niet geen uitleg meer we gaan op de glijbaan naar de onder leggende functie Main() en gaan daar kijken wat er verder gebeurt in het programma.

 

GNU gdb 20010813 (MI_OUT)
Copyright 2001 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-mandrake-linux"...
Dump of assembler code for function main:
0x8048280 <main>: push %ebp
0x8048281 <main+1>: mov %esp,%ebp
0x8048283 <main+3>: sub $0x8,%esp
0x8048286 <main+6>: movl $0x1,0xfffffffc(%ebp)
0x804828d <main+13>: sub $0x8,%esp
0x8048290 <main+16>: pushl 0xfffffffc(%ebp)
0x8048293 <main+19>: push $0x8091be0
0x8048298 <main+24>: call 0x80487a0 <printf>
0x804829d <main+29>: add $0x10,%esp
0x80482a0 <main+32>: sub $0xc,%esp
0x80482a3 <main+35>: push $0x8091c20
0x80482a8 <main+40>: call 0x80487a0 <printf>
0x80482ad <main+45>: add $0x10,%esp
0x80482b0 <main+48>: push $0x3
0x80482b2 <main+50>: push $0x2
0x80482b4 <main+52>: push $0x1
0x80482b6 <main+54>: push $0x0
0x80482b8 <main+56>: call 0x8048200 <zolder>
0x80482bd <main+61>: add $0x10,%esp
0x80482c0 <main+64>: sub $0xc,%esp
0x80482c3 <main+67>: push $0x8091c40
0x80482c8 <main+72>: call 0x80487a0 <printf>
0x80482cd <main+77>: add $0x10,%esp
0x80482d0 <main+80>: sub $0x8,%esp
0x80482d3 <main+83>: pushl 0xfffffffc(%ebp)
0x80482d6 <main+86>: push $0x8091c74
0x80482db <main+91>: call 0x80487a0 <printf>
0x80482e0 <main+96>: add $0x10,%esp
0x80482e3 <main+99>: mov %ebp,%esp
0x80482e5 <main+101>: pop %ebp
0x80482e6 <main+102>: ret
0x80482e7 <main+103>: mov %esi,%esi
0x80482e9 <main+105>: lea 0x0(%edi,1),%edi
End of assembler dump.

De lijn na 'call 0x8048200 <zolder>' is 0x80482bd en dat is gelijk het return adress van functie Zolder() in Main() dat lijkt mij heel simpel toch ?. Verder zien we nog 2 prinf routines die zijn om de tekst

ik ben nu weer terug op de begane grond op Mijn

en

Return Address is : 1

Maar die funnctie kan ik niet meer als voorbeeld gebruiken want die zal je nu wel kunnen dromen. Na deze aanroepen is er weer een oude bekend namelijk de __Exit Proloog en als deze proloog afgerond is betekend het dat voor Linux -/ -[Game Over]- /- Program Terminated of te wel einde programma.

 

Bits & Bytes

Dit is de output van Mandrake Linux, Mandrake gebruikt standaard 32Bits om te rekenen,dit omdat het berijk van de 32bits getallen groot is het gaat van -65535 tot en met 65535.

elke Bit bestaat uit 8 losse bytes

1Bit

[--------]

elke "-" stelt 1Byte voor (er staan er 8)

 

Bit ^ 8

16Bits / 8 = 2

2 * 2 = 4

4 * 2 = 8

8 * 2 = 16

 

32Bits / 8 = 4

16 * 8 = 128

128 * 8 = 1024

1024 * 8 = 8192

8192 * 8 = 65535

 

Als je dit begrijpt zal het stukje tekst wat hier onder staat ook geen probleem meer opleveren maar, ik zet het er even goed nog maar bij om jullie beeld hier over nog even te versterken.

 

__Quote uit Pc Beveiligd Van Sybex

Er bestaan grotere getallen dan 255. Een computer kan hiermee rekenen door bytes te combineren. Een moderene computer met Bijvoorbeeld Mandrake of een andere Linux of windows rekent standaard met 32Bits. Hiermee zijn waardes berijkbaar van -65535 to en met 65535. Voor grotere getalllen kan een 2e blok van 32bits ingeschakelen. Het totaal word dan 64Bits , en kunnen getallen berijkt van -4294967295 tot en met 4294967295. Mochtenn nog grotere getallen nodig zijn,dan kunnen er weer een blok van 64Bits in worden geschakeld.

Het totaal aantal Bits is in feite alleen beperkt door de omvang van het geheugen. Voor iedere 8Bits heeft u steeds steeds één byte nodig.128Bits gebruiken 16Bytes

128Bits / 8Bits = 16Bytes

__Einde Quote uit Pc Beveiligd Van Sybex

 

 

 

 

 

Eind Conclusie

~~~~~~~~~~~~~~~~~~~

Je heb geen praktijk oefeningen kunnen doen ?, ja dat klopt deze tutorial gaat er over om jullie kennis te laten maken met Assembler en is een basis cursus.Ik zal gedurende tijd vele tutorials maken waarvoor je basis kennis van Assembler voor nodig heb. In deze documenten zal ik dan ook een linkje naar deze tutorial plaatsen zodat je kan zien wat er in de basis van Assembler gebeurt. De documenten die hier ook over gaan en 'doen' Tutorials zijn zullen zijn.

 

• Encryptie I
• Buffer overflows I+II
• Game Cracking
• Assembler voor Windows

 

Verder hoop ik dat dit document geslaagd is en dat jullie reacties sturen naar mij (Ravecool je mag we rave zeggen hoor) of Ziro, wij zullen jullie klachten behandelen en jullie dankjes dicht op onze harten dragen ...

Het was me een genoegen Greetzz

 

Einde ....

 

[Rc][2002][TCuH]

-Groetjes aan-

Ziro

r00t

Stty0

SnAke

AssEmblr

Mijn Meisje

NadienTje

Aleph1

Dvorak

Bussy D (Whe Know Him all!![No FOEBAR])

-Gemaakt Door-

Ravecool

They Call us Hackers

[email protected] / [email protected]

http://ziro.tk

 

-Reverenties-

* H4H Magazine #05 Bufferoverflows: "da guide"

* Neworder.box.sk

* Pc Beveilig van sybex

* Alle andere Sites over Assembler