Normalerweise ist eines der ersten Tools, mit denen sich ein Newbie auseinandersetzt, W32DASM. Dieses Tool ist sowohl leicht zu erlernen als auch einfach zu bedienen.
Etwas später hört man dann von einem Tool namens "IDA Pro", welches viiieeeel besser sein soll als W32DASM.
Fakt ist, daß W32DASM nicht mehr weiterentwickelt wird, während das bei IDA Pro sehrwohl der Fall ist. Fakt ist außerdem, daß IDA Pro etliche Features besitzt, die das Reverse Engineering leichter machen. Aber kommen wir jetzt endlich zum eigentlichen Thema...

IDA Pro (im Weiteren nur noch "IDA" genannt) ist ein Disassembler und wurde von der Firma DataRescue entwickelt.
Wer W32DASM bereits kennt, weiß, was ein Disassembler macht. Für diejenigen unter uns, die es nicht wissen: ein Disassembler ist ein Programm, mit dessen Hilfe man ein existierendes Programm (sei es nun eine EXE, eine DLL o. ä.) disassemblieren, sprich in den ursprünglichen Assemblercode zurückwandeln, kann.
Dies ist kein leichtes Unterfangen, was man schon an der Dauer der Disassemblierung einer normal großen EXE sehen kann. Das Ergebnis der Disassemblierung ist jedenfalls der Assemblercode, welcher mehr oder weniger gut lesbar aufbereitet wurde. IDA (wie auch W32DASM) bietet nun etliche Funktionen, z. B. zum Verfolgen von bedingten Sprüngen, zum Suchen von String Referenzen usw., die die Navigation und die Arbeit im Sourcecode erleichtern.
Darüberhinaus bietet IDA allerdings Features, die man bei W32DASM schmerzlich vermisst, wie z. B. FLIRT (Fast Library Identification and Recognition Technology), welches hilft, Funktionen aus verschiedenen Bibliotheken zu erkennen und entsprechend mit Kommentaren versehen darzustellen.

Eine Demo der aktuellsten IDA-Version (ca. 10,9 MB) erhält man direkt bei DataRescue. Diese hat den Vorteil, daß sie alle aktuellen Features, wie z. B. Automatic Parameter Identification beherrscht. Dafür kann man aber nicht speichern (was bei den teilweise sehr langen Disassemblierungszeiten ein echtes Manko ist) und irgendwann kommt ein Timeout.
Eine etwas ältere Version (4.04, ca. 18,3 MB) erhält man unter den folgenden URLs. Hierbei handelt es sich um eine Vollversion, bei der auch das Speichern möglich ist.
Ich kann nur hoffen, daß bald eine aktuellere Version in Umlauf kommt, da vor allem die Automatic Parameter Identification ein sehr nettes Feature ist!

http://www.8bn.com/hambo/tools.html
http://202.103.100.253/hambo/tools.html
CoSH-Crackme-2.zip

Wenn man sich die Vollversion besorgt hat, muß man nichts installieren. Einfach die ZIP-Dateien entpacken und "Idag.EXE" aufrufen.
Hat man sich die Demoversion runtergeladen, startet man das Setup und beantwortet die üblichen Fragen (wohin die Anwendung installiert werden soll usw.).

Um die ganze Sache anschaulicher zu machen, habe ich ein Crackme von einem Cracker namens "CoSH" beigelegt, welches schön klein ist, so daß man recht gut die Arbeitsweise mit IDA nachvollziehen kann.
Wir starten einfach mal das Crackme:

Wenn wir nun unseren Namen (ich nehme "medardus") und eine beliebige Serial (ich: "123456789") eingeben und auf den "CHECK"-Button klicken, erscheint folgende Meldung:

Wir haben jetzt einen Ansatzpunkt, nämlich einen String, den wir im Sourcecode suchen können. Also starten wir IDA (ich beziehe mich auf die Vollversion 4.04, wobei natürlich alles bis aufs Speichern auch mit der Demo-Version funktioniert), indem wir "IDAG.EXE" aufrufen:

Um ein Programm zu disassemblieren, ziehen wir es einfach in das IDA-Fenster oder öffnen es manuell über das File-Menü. In beiden Fällen erscheint folgendes Fenster:

Hier können wir einstellen, um was für eine Art von Datei es sich handelt, welcher Prozessor zugrunde gelegt werden soll usw. Wir können aber alle Einstellungen übernehmen (natürlich stimmt das System DLL directory nicht, falls man unter Win9x arbeitet - aber das versteht sich ja von selbst) und klicken auf "OK". IDA beginnt nun mit der Analyse und dem Disassemblieren der EXE, was - je nach Größe und Komplexität des Programms - eine Weile dauern kann (ich habe schon von Leuten gehört, die IDA über Nacht disassemblieren lassen, was mich sehr an frühere Raytracing-Sessions erinnert :-).
Noch bevor IDA fertig ist, kann man bereits im Sourcecode herumschauen, aber ich empfehle, zu warten, bis IDA im unteren Statusfenster die Meldung "The initial autoanalysis is finished" anzeigt, da erst zu diesem Zeitpunkt der Code komplett analysiert und alle Referenzen aufgelöst sind. Wir sollten also nach kurzer Zeit ein ähnliches Bild vorfinden:

IDA ist hochgradig kontextabhängig, d. h. es sind immer nur die Features möglich, die für diesen Kontext Sinn machen. Aber alles der Reihe nach! In W32DASM würden wir nun in den String References nach unserem String suchen, doch wo sind in IDA die String References? Die Antwort ist, es gibt keine expliziten String References! Der Newbie wird nun die Krise kriegen und sagen, daß IDA einfach schlecht ist usw. Keine Angst, es gibt sowas Ähnliches wie die String References, nämlich die "Names".
Man klicke einfach mal in der Symbolleiste auf bzw. wähle im Menü "View" den Punkt "Names" aus. Es sollte sich folgendes Fenster öffnen:

In diesem Fenster sind alle Referenzen - nicht nur auf Strings sondern auch auf Code usw. - enthalten. Strings wird defaultmäßig ein kleines "a" vorangestellt. Um unseren String "One of the Details you entered was wrong" zu suchen, wechseln wir in das Names-Fenster und tippen "aO" ein (da IDA hier nicht case-sensitive ist, würde auch "ao" funktionieren). Wir sollten nun folgendes sehen:

Aha! Wir sehen den Text "aOneOfTheDetail". Das ist unsere String Referenz! Und was für ein Zufall: direkt darüber finden sich gleich noch zwei interessante Strings: "aYouDidIt" und "aWellDone". Wir wollen nun sehen, wo diese String Referenz benutzt wird, also machen wir einen Doppelklick auf unseren "aOneOfTheDetail"-String.

Doch das ist nicht das, was wir erwartet haben. Wir befinden uns nun korrekterweise dort, wo der String definiert und deklariert wird. IDA macht es uns aber leicht, indem es uns - ganz in W32DASM-Manier - die Stelle(n) anzeigt, wo die Variable "aOneOfTheDetail" (deren Inhalt der String "One of the Details you entered was wrong" ist) verwendet wird (eine sogenannte Crossreferenz, abgekürzt "XREF"):

Wie wir sehen können, wird die Variable nur an einer einzigen Stelle verwendet: in der Section ".text" an Adresse 0040153D, welche sich oberhalb der aktuellen Position befindet, was der Pfeil nach oben andeutet. Das kleine "o" gibt die Verwendung an. Hierbei steht "o" für "offset", "j" für "jump" und "p" für "procedure". Wir möchten nun sehen, wo die Variable verwendet wird, deshalb machen wir einen Doppelklick auf die XREF ".text:0040153D":

IDA ist ähnlich wie ein Browser aufgebaut. Wenn man also zurück zur letzten Position springen möchte, klickt man einfach auf den Button in der Symbolleiste. Vorwärts geht es dementsprechend mit dem anderen Button.
Hier sehen wir nun endlich den Sourcecode. Wir bemerken, daß der Bereich, in dem wir uns gerade befinden (markiert durch den Namen "loc_401536") an mehreren Stellen im Sourcecode durch einen Jump angesprungen wird (was angedeutet wird durch die drei Punkte am Ende der XREF-Liste). Zur Übung können wir ja mal auf die erste XREF doppelklicken, um zu der genannten Stelle zu gelangen. Dann am besten wieder mit dem o. g. Button zurück springen, um an die letzte Position zu gelangen.
Wie schon gesagt, ist IDA sehr kontextabhängig. Um nun alle XREFs für diese Stelle zu sehen, klicken wir mit der rechten Maustaste auf die XREFs und wählen "Jump to cross reference..." aus, woraufhin sich folgende Liste öffnet, in der man nicht nur die Adresse sieht, von wo aus gesprungen wird, sondern auch um welchen Befehl es sich handelt (jle, jnz, ...):

Soweit sogut. Lernen wir nun etwas über die Kommentarfunktionen von IDA.
Wie wir im obigen Bild sehen können, wird die API-Funktion "GetWindowTextA" aufgerufen, welche dazu dient, den Inhalt einer Textbox an eine Adresse zu speichern. In diesem Fall befindet sich nach Aufruf der API-Funktion in EDI eine Adresse auf eine Adresse auf den Inhalt der Textbox (also ein Pointer auf einen Pointer, um im C-Slang zu sprechen). Der letzte Pointer wird nun nach EAX kopiert, dann folgen hart codierte Vergleiche.
Da es hier nicht primär um das Cracken des Crackmes geht, verrate ich (falls ihr es nicht sowieso schon gemerkt habt), daß hier eine hart codierte Serial verwendet wird, deren Vergleich wir hier eben entdeckt haben. Der eingegebene Name und die eingegebene Serial müssen mindestens 6stellig sein, da sonst die Fehlermeldung kommt, die wir oben gesehen haben. Anschließend wird jedes Zeichen der eingegebenen Serial mit dem korrespondierenden Zeichen der hart codierten Serial verglichen und sobald ein Unterschied festgestellt wird, zur Fehlermeldung gesprungen. Die hart codierte Serial ist, wie man aus einer ASCII-Tabelle sehen kann, "6287-A" (36h = "6", 32h = "2" usw.). Um es uns aber besser zu veranschaulichen, kommentieren wir den Sourcecode ein bißchen.
Wir klicken mit der rechten Maustaste etwas rechts neben den Vergleich mit 36h und wählen "Enter comment...":

In dem erscheinenden Dialog geben wir einen möglichst sinnvollen Kommentar ein und klicken auf "OK". Der eingegebene Kommentar erscheint nun neben der Zeile.

IDA bietet die Möglichkeit, Daten verschieden anzuzeigen. Hier wird standardmäßig die "6" als "36h" angezeigt. Da wir aber nun wissen, daß es sich hierbei eigentlich um den ASCII-Wert des Zeichens "6" handelt, wäre es schöner, wenn dieses Zeichen dargestellt werden würde. Hierzu klicken wir mit der rechten Maustaste auf "36h" und wählen aus dem erscheinenden Popup-Menü die Zeile aus, in der '6' steht. Alternativ können wir den Cursor auf "36h" setzen und den -Button aus der Symbolleiste oder "r" drücken. Das bewirkt, daß der Wert als ASCII-Zeichen interpretiert und dargestellt wird. Man kann u. a. auch eine Dezimal-, Octal- oder Binärdarstellung wählen.

Das Ergebnis dieser Aktion sieht so aus:

Kommen wir nun zu einem weitern, sehr netten Feature von IDA: das Umbenennen von Referenzen. Wie wir sehen können, wird bei einem fehlgeschlagenen Vergleich zur Stelle "loc_401536" gesprungen, welche nachfolgend die Meldung anzeigt, daß eine Eingabe falsch war (die sogenannte "beggar-off"- oder auch "bad-cracker"-Meldung). Nun ist die Bezeichnung "loc_401536" nicht gerade sehr aussagekräftig. Viel schöner wäre es, wenn da etwas wie "bad_cracker" stehen würde. Klar könnte man einen Kommentar einfügen, aber der wäre ja nur lokal für diese Zeile sichtbar. Was wir bräuchten, wäre eine Möglichkeit, alle Referenzen von "loc_401536" umzubenennen. Hierzu machen wir einen Doppelklick auf "loc_401536" (egal auf welche Referenz), worauf wir uns hier wiederfinden sollten:

Wir klicken nun mit der rechten Maustaste auf die Adresse "00401536" so daß folgendes Popup-Menü erscheint:

Hier wählen wir "Rename" aus was uns zu folgendem Dialog führt (alternativ hätten wir auch einfach mit dem Cursor auf die Adresse "00401536" gehen und "n" drücken oder den -Button aus der Symbolleiste anklicken können):

Wir geben einen sinnvollen Namen wie z. B. "bad_cracker" ein und drücken auf "OK" Sofort sehen wir, daß alle Referenzen auf "loc_401536" in unseren neuen Namen geändert wurden:

Zur Übung sollte das Gleiche mit entsprechend anderem Namen (z. B. "good_cracker") mit der Referenz "loc_40154D" gemacht werden.

Als kurzer Einschub behandeln wir jetzt, wie man IDA konfiguriert.
Wir rufen aus dem Menu "Options" den Punkt "General..." auf, worauf folgender Dialog erscheint:

Wer z. B. gerne die Hexopcodes sehen möchte, trägt bei "Number of opcode bytes" die Anzahl der Bytes ein, die angezeigt werden sollen (6 ist hier ein guter Wert). Das ist vor allem zum Patchen sinnvoll, da man gleich die zu patchenden Bytes sehen kann.
Bei "Instructions indention" sollte man dann aber den ursprünglichen Wert von 16 auf 0 reduzieren, damit die Anzeige nicht so verschoben aussieht.
Für Assembler-Anfänger ist die Einstellung "Auto comments" empfehlenswert, da dann IDA automatisch hinter etliche Assemblerbefehle eine kurze Beschreibung als Kommentar anhängt, der beschreibt, was der jeweilige Befehl bewirkt.

Wer gerne mehr als nur zwei Crossreferences angezeigt haben möchte, kann dies unter "Cross-references" beim Punkt "Number of displayed xrefs" einstellen.

Wenn man möchte, daß IDA längere Variablennamen generiert, muß direkt die Datei "ida.cfg" editieren. Der Eintrag hierfür lautet:
MAX_NAMES_LENGTH = 30 // Maximal length of new names (you may specify values up to 511)

Wer den File-Offset des aktuellen Befehls wissen möchte (zum Patchen beispielsweise), schaue in die Info-Zeile ganz unten am IDA-Fenster:

Der gelbe Kringel zeigt den File Offset und der rote Kringel die RVA (relative virtual address).

Weiter oben habe ich erwähnt, daß man mit dem Button, ähnlich wie bei einem Webbrowser, zur zuletzt besuchten Position springen kann. Man kann sich aber bei einem umfangreichen Programm leicht verzetteln. Was wir bräuchten, wäre ein Feature ähnlich den Bookmarks. Natürlich bietet IDA etwas Vergleichbares an.
Um eine sogenannte Marke zu setzen, wählt man aus dem Menu "Jump" den Eintrag "Mark position...", worauf folgender Dialog erscheint:

Hier muß man eine Bezeichnung für die zu setzende Marke angeben. Ich habe als Beispiel "patch_1" eingegeben, um zu kennzeichnen, daß hier zu patchen ist.
Möchte man nun zu einer solchen Marke springen, wählt man aus dem Menu "Jump" den Eintrag "Jump to marked position...". In dem erscheinenden Dialog stehen alle bisher definierten Marken. Aus diesen wählt man die gewünschte Marke aus und macht einen Doppelklick darauf.

Es kann vorkommen, daß IDA nicht die Sprache erkennt, in der das zu analysierende Programm geschrieben wurde, und dadurch nicht die verfügbaren FLIRT-Signaturen einsetzt. Ist das der Fall, kann man die Signaturen manuell einbinden. Angenommen, das zu analysierende Programm wurde in Delphi 4 geschrieben. Wir rufen, nachdem IDA fertig disassembliert hat, aus dem Menu "View" den Punkt "Signatures" auf (alternativ mit dem Button). Es erscheint ein Fenster, in dem normalerweise alle verwendeten FLIRT-Signaturen stehen. Wir können eine neue Signatur verwenden, indem wir mit der rechten Maustaste in das Fenster klicken und "Apply new signature" wählen. IDA zeigt daraufhin in einem neuen Fenster alle verfügbaren Signaturen an. Wir wählen in diesem Beispiel dann die Signatur "Delphi 4 Visual Component Library" aus.

Wer W32DASM kennt und dessen String References (oder auch Imports/Exports) bei IDA schmerzlich vermißt, dem kann geholfen werden. Der Cracker "Amante4" der Gruppe Immortal Descendants hat Plug-Ins für IDA in IDC, der Script-Sprache von IDA, geschrieben, welche genau die genannten Features bietet. Die Plug-Ins können auf der o. g. Homepage unter der Rubrik "The Database/Releases" runtergeladen werden. Die Installation ist relativ leicht und ist gut beschrieben im README.NFO in der ZIP-Datei, ebenso die Bedienung.
Ich möchte hier nicht weiter auf diese Plug-Ins eingehen, da sie a) gut beschrieben sind und b) nicht unbedingt nötig sind, um mit IDA sinnvoll arbeiten zu können (was nicht bedeutet, daß ich die Leistung von Amante4 in irgendeiner Weise schmälern will).

Aktuelle IDA-Versionen bieten ein schönes Feature namens "Automatic Parameter Recognition", was bewirkt, daß bei API-Funktionen die Parameter benannt werden (statt "push eax" steht als Kommentar eben noch dahinter, um welchen Parameter es sich handelt, z. B. "hWnd").
Leider verfügt die im Netz verfügbare Version 4.04 von IDA nicht über dieses Feature. Der bekannte Cracker +Spath hat deshalb ein IDC-Skript namens W32param geschrieben, mit dessen Hilfe eine ähnliche Funktion realisiert wird. Erhältlich ist das Skript unter http://frogsprint.cjb.net. In der zugehörigen Datei API32.H, in der die Definitionen der API-Funktionen stehen, fehlen ein paar wichtige API-Funktionen wie etwa GetDlgItemTextA oder GetDlgItemInt. Diese müßte man selbständig einfügen. Bekommen tut man die entsprechenden Definitionen aus der hoffentlich verfügbaren API-Beschreibung oder aus Header-Dateien eines Entwicklungspaketes.
Im Menu "File" ruft man schlißlich den Punkt "IDC file..." auf und wählt das Skript W32param.idc aus. Die Datei API32.H muß sich dabei im IDA-Verzeichnis befinden, nicht etwa im IDC-Unterverzeichnis!

Ich denke, daß die grundlegende Bedienung von IDA Pro hiermit abgehandelt ist. Natürlich gibt es noch Unmengen an Features und Funktionalitäten, die hier unerwähnt geblieben sind, aber schließlich handelt es sich auch "nur" um ein Newbie-Tutorial!
Ich möchte noch etwas zu der Geschwindigkeit von IDA Pro gegenüber der von W32DASM sagen. Es ist unbestritten, daß W32DASM, vor allem bei großen EXE-Dateien, um Längen schneller fertig ist als IDA. Jedoch wird dieser Geschwindigkeitsvorsprung durch fehlende Features, wie z. B. die Möglichkeit, Referenzen umzubenennen usw., erkauft. IDA Pro baut bei der Analyse eine komplette Datenbank auf, in der sich sämtliche Referenzen usw. befinden, wodurch die Features von IDA überhaupt erst möglich werden.
Man darf keines der beiden Werkzeuge vergöttern oder verteufeln, denn jedes hat seine Berechtigung. Möchte man mal eben schnell eine kleine EXE-Datei disassemblieren, um das Programm zu cracken bzw. zu untersuchen, ist W32DASM vollkommen ausreichend. Möchte man eine größere EXE-Datei analysieren oder "richtiges" Reverse Engineering betreiben (worunter ich verstehe, das Programm komplett nachzuvollziehen und nicht nur die paar Zeilen Code, die den Schutz ausmachen), kann IDA Pro mit seinen Features glänzen. Teilweise kommt man um IDA Pro sowieso nicht herum, da es inzwischen etliche Tricks gibt, die das Disassemblieren von Programmen mit W32DASM verhindern, wo IDA Pro aber dennoch Erfolg hat.

Schlußendlich hoffe ich, daß dieses Tutorial dem Newbie die Bedienung von IDA Pro etwas näherbringen konnte. Nehmt doch einfach ein kleines Crackme oder eine kleine EXE-Datei, laßt sie von IDA disassemblieren, spielt dann mit den verschiedenen Knöpfen und Einstellungen herum und schaut, was passiert.
Sollten noch Fragen auftreten oder sollte jemand konstruktive Kritik oder Lob loswerden wollen, so darf er dies gerne an mich schreiben :-).

Bleibt mir nur noch, ein paar Greetings (in unbestimmter Reihenfolge) loszuwerden und zwar an:
Cosmo Connor, Instructor, Folko, figugegl, Ebeneezer, ArturDent, Peacemaker, kUbUs, exa, fakeraol, subZZero, radeOn und an alle Newbiez dieser Welt!