-- 1.1 Was ist Assembler ?

Assembler ist Maschienensprache. Assembler ist die niedrigste Programmiersprache überhaupt, da man hier direkt den Prozessor und das OS anspricht. Man kann jeden Assemblerbefehl eins zu eins in Hexcode übersetzen, was für uns der Compiler übernimmt. Ein Beispiel hierfür ist der Befehl NOP = 90h (h für Hexadezimal). Da man hier genau bestimmen kann was für ein Code in der Datei nach dem Compilieren steht, kann man gerade in Assembler die Optimierung des Codes bis ins äuserste treiben. Auch hat man unter Assembler die größte Macht über den Computer.  

*-- 1.2 Warum in Assembler programmieren ?

Es gibt mehrere Gründe dafür warum man in Assembler programmiert, bzw warum man es lernen  möchte. Ein Grund ist zum Beispiel, das man den Code extrem klein halten kann und durch gezielte optimierung einen enormen Geschwindigkeitsvorteil zu Hochsprachen herausarbeiten  kann. Des weiteren ist Assembler natürlich interessant zum Cracken und Viren schreiben.

 *-- 1.3 Anmerkungen zu TASM

Es gibt in Borlands Turbo Assembler keinen Editor, wie man ihn zum Beispiel von Qbasic oder Turbo Pascal kennt. Man schreibt seinen Code per Text-Editor in eine .asm Datei und   übergibt diese auf der DOS-Kommando Ebene dem Compiler und dem Linker. Die Parametereinstellungen kann man natürlich durch eine Batch Datei erleichtern.

---8<------ ( Compile.bat )---------

if not exist %1.asm goto quit

tasm %1 /n/p/t/w/z/m4

if errorlevel 1 goto quit

tlink %1 /d/x/t

del %1.obj

---8<-------------------------------

Diese Batch Datei wird gestartet mit Compile '<Dateiname des sources ohne .asm>' Achtet darauf, das sie in C:\TASM\BIN\ zusammen mit dem Source code liegt. Und startet dann den Compiler (TASM) und den Linker (TLINK) und fertig euch eine COM Datei an. Wie man EXE Dateien mit TASM erstellt erkläre ich später, COM Dateien reichen erstmal und sind viel kleiner als EXE Dateien. In TASM wird die Groß und Kleinschreibung ignoriert, schreibt wie ihr wollt. (jedenfalls solange ihr DOS-Programme schreibt)

*-- 1.4 DOS Assembler

Im ersten Teil dieses Tutorials werde ich euch zeigen, wie man DOS-Programme mit TASM schreibt, da diese immernoch zu verwenden sind und einfach besser in die Assembler Welt einführen. Später werde ich noch auf die Besonderheiten der Windows programmierung hinweisen.

Versucht mal mit euerem Taschenrechner weiterzuzählen ich denke den Dreh bekommt ihr schnell raus. Was machen wir nun, wenn wir eine Binärzahl ins Dezimale umrechnen wollen ? Wir zücken unseren Taschenrechner ;) oder machen es im Kopf nach folgender Methode:
Schauen wir auf die Zahl 10011. Wir fangen bei der letzten stelle an 1, also 1 * 2^0 (das ^ bedeutet hoch, also die erste Potenz von 2), dann addieren wir die 2. Stelle (1 * 2^0)+(1 * 2^1).. die nächsten beiden Stellen sind 0.. ok addieren wir sie zum  Spaß auch mal, damit ihr das Schema erkennt. (1 * 2^0)+(1 * 2^1)+(0 * 2^2)+(0 * 2^3) Also ändert sich die Zahl hier nicht. Nun noch die erste Stelle addieren und wir sind fertig
(1 * 2^0)+(1 * 2^1)+(0 * 2^2)+(0 * 2^3)+(1 * 2^4) = 1 + 2 + 0 + 0 + 16 = 19
In TASM kennzeichnet man Binärzahlen durch ein b am ende der Zahl (10011b).
Ok nun zum Hexadezimalsystem. Dieses beruht auf 16 Grundzahlen: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E. Das A entspricht der 10 im Dezimalsystem, das B der 11, das C der 12 und so weiter. Was passiert, wenn wir zu F noch eine 1 addieren wollen ?
Dann landen wir bei 10. Diese 10 entspricht dann der Dezimalen 17. Auch für Hexzahlen gibt es unter Assembler eine Besondere Kennzeichnung, das h. Allerdings erwartet TASM,   das eine Zahl mit einer Zahl anfängt, also muss man Eh als 0Eh schreiben, da TASM das E nicht als Zahl ansieht. Soviel zur Mathematik ;P

Einfach zu merken oder ? Das kleine l steht für low, das h für high. Dann gibt es noch:

SP - Stack Pointer (wird später erklärt)
BP - Base Pointer (meistens unbenutzt)
SI - Source Index (zeigt auf Quelle, wenn man Daten liest oder verschiebt)
DI - Direction Index (zeigt auf das Ziel der Daten)
IP - Instruction Pointer (zeigt auf den Befehl der gerade ausgeführt wird)

CS - Code Segment (zeigt den Anfang des Codes)
DS - Data Segment (zeigt den Anfang der Daten)
SS - Stack Segment (kommt später)
ES - Extra Segment (könnt ihr frei verwenden)
FS - siehe ES ..
GS - siehe ES ... ;)

Das war es eigentlich schon mit den Registern, wenn euch etwas spanisch vorkommt, lest einfach erstmal weiter, mit dem ersten Programm sollte es euch klar werden.

Die paar reichen für dieses Tutorial aus, sie können gesetzt sein 1 oder auch nicht 0. Was man damit anfangen kann kommt später ich wollte sie mal erwähnen, das ihr wenigstens mal davon gehört habt. :)

--8<---(HelloW.asm)------
.model tiny ;nur ein kleines Programm
.code ;hier steht der code
org 100h ;wir basteln ne COM Datei
START: ;Label zum verzieren
mov ah, 09h ;09h ist die INT21h Funktion zum ausgeben von Text
mov dx, offset HelloWorld ;Wo steht der Text...
INT 21h ;schreib ihn !
ENDE: ;schönes Label oder ?
mov ah,4ch ;4Ch zum Beenden
INT 21h ;Beende !
HelloWorld db 'Hello World !!',10d,13d,'$' ;Unser String..
END START ;hier ist das ganze zuende..
----------ende-----------

HELLOW COM 28 15.09.99 15:23 HELLOW.COM
HELLOW ASM 763 15.09.99 15:23 hellow.asm

Nun könnt ihr das Hallo Welt Programm auch starten... ;) denke mal das könnt ihr auch so.. Und wir werden mit einem Hello World !! begrüßt.. War ganz einfach oder ?

Was kann man nun damit anfangen ? ;) .. Lasst uns unser Hello World etwas ändern.. ;)

Das ganze ist wie ihr seht nur Spielerei und hat keinen Nutzen (ausser euch die Sache zu erklären) Wenn ich bei euch mal solchen Code sehen sollte werde ich euch sofort verbrennen ;P .. Ok was Passiert hier ? Wir schreiben unsere Nachricht, mit der bereits erklärten Funktion 09h des INT 21h. Die 9h erreichen wir über den Umweg, das wir zuerst   8h in AH schreiben und diese 8h dann um eins erhöhen. Danach verwenden wir die für euch neue Funktion 01h des INT 21h. Mit dieser halten wir das Programm an, bis irgendeine Taste gedrückt wird. Der ASCII Code dieser Taste steht dann in AL, aber das ist in diesem Beispiel egal. Es ging nur darum das Programm anzuhalten.Am Schluß setzten wir wieder die 4Ch zum beenden in ah, indem wir AL mit 26h füllen, diese dann mit den 2h aus BX multiplizieren. Und das Ergebnis aus AL nach AH verschieben,  wo es hingehört.

jmp Label - Springe immer !

(die Bezeichnungen größer und kleiner ignorieren das Vorzeichen)
je Label - Springe wenn gleich (JZ)
jne Label - Springe wenn ungleich (JNZ)
ja Label - Springe wenn größer (JNBE)
jna Label - Springe wenn nicht größer (JBE)
jae Label - Springe wenn größer oder gleich (JNB)
jnae Label - Springe wenn nicht größer oder gleich (JB)
jb Label - Springe wenn kleiner (JNAE)
jnb Label - Springe wenn nicht kleiner (JAE)
jbe Label - Springe wenn kleiner oder gleich (JNA)
jnbe Label - Springe wenn nicht kleiner oder gleich (JA)
jz Label - Springe wenn 0 (JE)

(nun wird auf die Vorzeichen geachtet)
jg Label - Springe wenn größer (JNLE)
jng Label - Springe wenn nicht größer (JLE)
jge Label - Springe wenn größer oder gleich (JNL)
jnge Label - Springe wenn nicht größer oder gleich (JL)
jl Label - Springe wenn kleiner (JNGE)
jnl Label - Springe wenn nicht kleiner (JGE)
jle Label - Springe wenn kleiner oder gleich (JNG)
jnle Label - Springe wenn nicht kleiner oder gleich (jg)
jcxz Label - Springe wenn ex = 0

js Label - Springe, wenn die letzte Operation ein negatives Ergebnis hatte
jp Label - Springe wenn das Parity Flag gesetzt ist
jnp Label - Springe wenn das Parity Flag nicht gesetzt ist
jo Label - Springe wenn Overflow Flag gesetzt ist
jno Label - Springe wenn Overflow Flag nicht gesetzt ist
jc Label - Springe wenn Carriage Flag gesetzt ist
jnc Label - Springe wenn Carriage Flag Flag nicht gesetzt ist

Nein ihr müsst jetzt nicht alle Auswendig lernen.. Ihr dürft diese Tutorial auch etwas länger behalten, dann könnt ihr auch mal nachschlagen ;P Neben dem CMP Befehl gibt es noch einen weiteren Befehl, der 2 Register/Konstanten mit einander vergleicht. Dies ist der test-befehl, mit dem man allerdings nur auf Gleichheit bzw Ungleichheit überprüfen kann.  Nun wieder ein kleines, sinnloses Programm zum Verstehen:

Ok in diesem Beispiel verwenden wir nur die Interrupt Funktionen, die wir bereits kennen, 09h um etwas auf den Bildschirm auszugeben, 01h um eine Taste einzulesen und 4Ch um das Programm zu beenden. Das Programm arbeitet so, das es erst die Taste einliest (in al) und dann al nacheinander mit den verschiedenen erwünschten Tasten (1,2,3,4) vergleicht.  Wenn al mit einer der Tasten übereinstimmt, springt man zu dem jeweiligen Unterprogramm. Stimmt al mit keiner der Tasten überein, wird eine Fehlermeldung gezeigt, und das Programm beendet. So nun könnt ihr schon ein kleines Text-Adventure in Assembler schreiben ;)

Das Programm gibt uns auch wieder ein Hello World !!! aus, diesmal aber haben wir um dies zu erreichen einige Umwege über den Stack gemacht, die eigentlich recht verständlich sind. Was genau passiert mit dem Stack Pointer, wenn wir etwas in den Stack legen, vom Namen her muss er doch was damit zu tun haben oder ? ;)  Also der Stack Pointer zeigt auf die Stelle im Speicher, an der die nächste Zahl in den Stack gelegt wird. Also an die Spitze des Stapels. Wenn man nun eine weitere 16Bit-Zahl pusht, werden 2 Bytes vom SP (Stack Pointer) abgezogen. Wenn man etwas poppt, werden 2 Bytes dazugezählt. Versuchen wir doch einmal folgende Spielerei mit diesem Pointer: wir Pushen eine Zahl, dann Poppen wir sie wieder. Dann vermindern wir den SP um 2, so das er wieder auf unsere Zahl zeigen müsste. Dann poppen wir auch diese Zahl und vergleichen sie mit der ersten. Wenn beide Zahlen stimmen ist unsere Experiment geglückt.

Was ein Zufall, unsere Überlegungen waren richtig.. ;) es klappt, wenn man das Programm compilert und ausführt... *g*

Schätze mal das ist soweit verständlich ;) Nun wissen wir wie ein Call funktioniert, doch uns fällt auf, das man die ganze Aktion auch anders hätte starten können (nur zur Information es bringt nicht viel *g* ) Das ist nur um nochmal zu verdeutlichen, was genau bei einem CALL passiert.. ;)

Hiermit zeigen wir den Text 3 mal.. Man kann Schleifen auch ineinander Verschachteln, man muss dann allerdings darauf achten, das man CX speichert (push/pop)

Eine der Sachen, die mir an Assembler am Besten gefallen, ist, das man nicht nur die Daten verändern kann, sondern auch das Programm an sich, während es läuft. Und dies nicht nur auf der Festplatte, sondern auch im Speicher, wodurch sich zum Beispiel das gesamte Programm verschlüsseln lässt, oder man auf 'etwas' andere Art und Weise den Programmablauf ändern kann. Im folgenden Beispiel ändern wir einen JE in einen JNE, so das sich das Programm anders verhält.

XCHG AX,BX : Mit diesem Befehl tauscht man die Daten zweier Register
NEG AX : Hier wird AX negiert aus 00000020h wird FFFFFFE0h
NOT AX : Addiert 1 und multipliziert mit -1 ( 5 = -6)
XOR AX,BX : Bitweise Verknüpfung mit einem exclusiven oder:

16h XOR 20h = 36h
            10110b
XOR 100000b
=        110110b

Im Klartext taucht im Ergebnis immer dort eine 1 auf, wo entweder im 1. oder 2. Operant eine 1 war. Dort wo an beiden Operanten eine 0 oder eine 1 war steht im Ergebnis eine 0.

Hier enthält das Ergebnis dort eine 1, wo in einem der beiden Operanten eine 1 stand. Aber es kommt nur dort eine 0 vor, wo in beiden Operanten eine 0 stand.
NOR AX,BX : Verknüpfung über NOT und OR
Diese Verknüpfungen kann man entweder dazu verwenden, irgendwelche Mathematischen Rechnungen auszuführen ( igitt ) oder um Texte oder ähnliches zu verschlüsseln damit nicht jeder Lamer seinen Namen in euer Programm mit nem Hexeditor schreiben kann... 
Dazu eignen sich besonders gut NEG, NOT und XOR. Wenn mal eine Zahl nämlich zweimal negiert oder zweimal ein NOT mit ihr durchführt erhält man die Ursprungszahl. Genauso ist es mit XOR, wodurch sich bei einer Byte-weisen Verschlüsselung FFh Möglichkeiten bieten, bei einer Word Verschlüsselung sogar FFFFh Möglichkeiten. Das Beispiel ist das gleiche wie vorher, nur statt dem dec benutzen wir diesmal XOR, NEG und NOR

In ah befand sich der Wert 149, der durch das verschieben zu 10 geändert wird. Mit SHR verschieben wir die Bits von links nach rechts (sh_R_ wie rechts), dabei Fallen am rechten Ende die Bits heraus und von Links rücken immer nur Nullen nach. Genauso verhält es sich mit SHL, nur das hier von Rechts die Nullen nachrücken und die Bits am Linken Ende herausfallen.
[1|0|0|1|0|1|0|1] SHL AH,1 = [0|0|1|0|1|0|1|0]

Aus 149 wird in diesem Fall also 42. Was ist nun ROR und ROL ? Mit den beiden Befehlen rotieren die Register ;) Sie werden verwendet wie SHR und SHL aber bei ihnen fallen die Bits nicht am Ende weg, sondern werden am anderen Ende wieder drangefügt.
[1|0|0|1|0|1|0|1] ROR AH,1 = [1|0|0|0|1|0|1|0]
149 --> 138

[1|0|0|1|0|1|0|1] ROL AH,1 = [0|0|1|0|1|0|1|1]
149 --> 43

So hier ein kleines Programm, das eine Dezimalzahl in Binärcode ausgibt. Der Befehl mov byte ptr cs:[si] einfach nicht beachten *g* er wird im nächsten Kapitel erklärt.. ;) Wenn ihr eine andere Zahl testen wollt (0-255) einfach unter dezimalzahl eintragen..

--8<---(~~~~~~~~)------
code segment
assume cs:code,ds:data       ;Definiert die einzelnen Segmente
;euer code hierher..
code ends
data segment
;hier kommen die daten rein..
data ends
end
----------ende-----------

Genauso könnt ihr auch das Stack Segment, oder ES, FS und GS definieren.  Ein Segment beginnt immer mit <Name> segment und endet mit <Name> ends. Wenn wir vom Code Segment auf ein anderes zugreifen wollen müssen wir dies dem Programm mitteilen. Dies geschieht durch Angabe des Segmentes

mov ah, byte ptr ds:[offset value]
mov ax, word ptr ds:[offset value2]

Im ersten Beispiel wird der Wert des Bytes an Stelle value in ah geschoben in   Beispiel 2 der Wert des Words (2 bytes) an Offset value2 in ax.  Hier ein wirklich simples Beispiel, das mit 2 Segmenten arbeitet. Dies ist allerdings eine EXE-Datei (in COM Dateien ist alles ein Segment) und wird deshalb anders kompiliert. (Siehe dafür nächstes Kapitel)

Das wars dann auch..