Für Windows · untersucht: PE (x86, x64, ARM, ARM64), DOS (MZ), ARM-Linux (ELF)

Dismonite – Disassembler und Debugger für ausführbare Dateien

Öffnen. Verstehen. Beobachten. Zurückübersetzen.

Dismonite liest ein Programm (x86, x64, ARM32/Thumb-2, ARM64/AArch64), verfolgt seinen Code, benennt Sprungziele, Importe und Texte und zeigt, was darin steht – und es führt das Programm im Debugger aus, ohne dass Quelltext nötig wäre. Der Export als .asm ergibt beim Übersetzen mit dem Assembler von Asmonite wieder dieselbe Datei, Byte für Byte. Ein kleines, portables Programm: entpacken, starten, fertig.

⬇ Herunterladen In 60 Sekunden ausprobieren Dazu: Asmonite, der Editor

Version 0.7.6 (Testversion) · Windows 10/11 · 2.1 MB · keine Installation · kostenlos · kein Tracking · Dismonite liegt im selben ZIP wie Asmonite

Dismonite: code at the entry point with labels — Nach der Analyse: der Code am Einsprungpunkt `start`, Sprungziele und Adressen als Labels.

Was drin ist

Von der fremden EXE bis zu einem Quelltext, der wieder übersetzt werden kann – und dazwischen ein Debugger.

🔍

Analyse ab Einsprung

Verfolgt den Code ab Einsprungpunkt, Exporten und TLS-Callbacks (PE) bzw. CS:IP (MZ) und ab den Relokationszielen; was Code ist, wird als Code gezeigt, der Rest als Daten.

🏷️

Labels statt Adressen

Sprungziele, Funktionen und Daten bekommen Namen, die man umbenennen kann. Strg+Klick springt zum Ziel, Alt+← zurück, Strg+R zeigt alle Verweise.

🧱

Dateistrukturen mit Feldnamen

PE-Header, Sections, Importe, Exporte, Ressourcen, ELF-Program-Header und -Symbole werden Feld für Feld mit Größe und Namen als Kommentar gezeigt.

🗂️

Ressourcen und Meldungstexte

Zeichenketten-Tabellen (RT_STRING) werden Text für Text erkannt, mit Label str_<Nummer>. Eine Konstante vor einem Aufruf, der eine Meldung lädt, zeigt den Text als Hinweis.

🔁

Export mit Rückweg

Der Export als .asm trägt Labels, Kommentare und Markierungen und ergibt mit asmoc wieder dieselbe Datei – für x86, x64, ARM Thumb-2 und ARM64. Bei 32-Bit-Windows-Programmen wahlweise mit if / else / endif statt cmp und Sprung, wo der Assembler dieselben Bytes daraus macht, auch if zero auf den Flags und Schleifen mit do / while (im 32-Bit-dcc32 9.090 if und 1.134 Schleifen).

✍️

Markieren und kommentieren

Elemente als Code, Byte, Word, Dword, Qword, ASCII oder UTF-16 markieren, Kommentare und Kommentarzeilen setzen. Alles liegt in <programm>.dmon neben dem Programm.

🐞

Debugger ohne Quelltext

Haltepunkte, Step Over/Into, Run to Cursor, Pause. Register, Stack und Speicher sind immer sichtbar; geänderte Werte werden rot. Wo das Programm anhält, wird Code – die Analyse wächst mit.

➡️

Sprunghinweis

Steht das Programm vor einem Sprung, den es gleich nimmt (bei einem bedingten nur, wenn die Bedingung erfüllt ist), sagt die Zeile, ob es nach oben oder nach unten geht, und wohin.

💡

Befehlsinfo auf F1

Im Reiter Info erklärt ein Tastendruck den Befehl, die importierte Windows-Funktion mit ihren Parametern oder den DOS-Interrupt. Deutsch und Englisch; die Info folgt dem Cursor.

Was Dismonite öffnet und wie es debuggt

Programm	Disassembler	Debugger
Windows x86 (PE)	✓ mit Export	direkt auf diesem Rechner
Windows x64 (PE32+)	✓ mit Export	auf diesem Rechner, über den Hilfsserver `asmodbgx64` als Kindprozess
Windows on ARM (ARM32/Thumb-2)	✓ mit Export	auf einem Windows-on-ARM-Rechner (Server `asmodbg`, ssh oder direkt im Netz)
Windows ARM64 (PE32+)	✓ mit Export	auf einem Windows-on-ARM64-Rechner (Server `asmodbg64`, ssh, direkt oder lokal)
DOS (MZ, COM)	✓ 16 Bit, Segment:Offset	in QEMU mit FreeDOS, startet von selbst
ARM-Linux (ELF, 32 Bit)	✓	über gdbserver in Raspberry Pi OS unter QEMU

In 60 Sekunden

Vom ZIP zum ersten Haltepunkt in einer ausführbaren Datei – mit dem mitgelieferten Beispiel.

Entpacken und Dismonite.exe starten. Keine Installation; Datei > Öffnen beginnt im Programmordner.
examples\demo.exe öffnen. Ein kleines Programm: zählt von 1 bis 5 und ruft printf auf.
Menü Analyze > Follow code from the entry point and the exports. Der Code ab dem Einsprungpunkt steht mit Labels da; Strg+Klick auf einen Sprung oder Aufruf geht zum Ziel, Alt+← zurück.
F1 auf einer Zeile erklärt sie im Reiter Info – den Befehl oder die importierte Funktion mit ihren Parametern.
F7 drücken. Dismonite startet das Programm und hält am Einsprungpunkt; Register und Stack stehen rechts.
Mit F8 weiter; vor einem Sprung sagt die Zeile, wohin es geht. Geänderte Werte werden rot.
Menü File > Export as .asm: erzeugt ein .asm, das asmoc wieder zur selben Datei übersetzt.

Weitere Beispiele im ZIP: examples\dos\HELLO.EXE (DOS, QEMU), examples\winarm\pe_arm32_hello_world.asm (Windows on ARM) und examples\arm64\a64asm_hello.asm (ARM64), die Asmonite mit F9 zu Programmen baut, die Dismonite öffnet.

Von der EXE zurück zum Quelltext

Der Export ist kein Anhaltspunkt, den man von Hand nacharbeiten muss: er lässt sich übersetzen.

EXEausführbare Datei

→

Dismoniteanalysieren, kommentieren

→

.asmmit Labels

→

asmocAssembler

→

EXEByte für Byte gleich

Zeigt Adressen, Bytes, Befehl und Kommentar – auch bei großen Dateien (getestet bis 64 MB)
Füllbytes werden zu einer Zeile align, Nullbytes zu einem Element

Texte als ASCII und UTF-16 werden erkannt; Strg+F3 springt zum nächsten
Bei x64 und ARM64 enthält der Export Befehle statt db-Zeilen, jede Zeile wird zur Kontrolle zurückübersetzt

Dismonite: the import table with field names — Die Importtabelle: jedes Feld mit Größe und Namen, RVAs als Labels, Füllbytes als eine Zeile `align`.

Der Debugger

Eine ausführbare Datei beobachten – ohne Quelltext, auf Windows, DOS und ARM.

Windows (PE)

Startet das Programm direkt unter Windows. Haltepunkte, Step Over/Into, Run to Cursor, Pause; die Konsole des Programms erscheint in der Ausgabe.

DOS (MZ)

Startet QEMU mit FreeDOS von selbst; 16-Bit-Register, Adressen als Segment:Offset. Ein zweiter Lauf startet im laufenden QEMU.

ARM-Linux (ELF)

Lädt das Programm per ssh in den Raspberry-Pi-Gast und debuggt es über gdbserver. Läuft kein Gast, startet Dismonite ihn nach Rückfrage.

Windows on ARM (PE)

Kopiert das 32-Bit-ARM-Programm auf einen echten Windows-on-ARM-Rechner und debuggt es dort über den kleinen Server asmodbg – entweder über ssh oder direkt im Netz mit einem Kopplungscode. „Search LAN“ findet laufende Server im lokalen Netz.

x64 (PE32+)

Startet das 64-Bit-Programm auf diesem Rechner; das kleine Hilfsprogramm asmodbgx64 läuft als Kindprozess. Register rax…r15, Stack und Speicher mit 64-Bit-Adressen.

ARM64 (PE)

Debuggt auf einem Windows-on-ARM-Rechner über den Server asmodbg64 – ssh, direkt im Netz oder lokal, wenn Dismonite selbst dort läuft. Register x0…x30, sp, pc, Flags.

Alles auf einen Blick: Register und Stack rechts neben dem Code, Speicher und Ausgabe des Programms darunter – ohne Umschalten; geänderte Werte sind rot
Stack mit den Labels, auf die die Werte zeigen (Doppelklick springt hin); Speicher ab einer Adresse, einem Label, einem Register oder unter DOS ab Segment:Offset
Wo das Programm anhält, wird Code – so wächst die Analyse beim Debuggen mit
Sprunghinweis: vor einem Sprung, den das Programm gleich nimmt, steht, ob es nach oben oder nach unten geht, und wohin
Parameter für das Programm (Debug > Parameters), in der .dmon gespeichert

Dismonite: debugging demo.exe with registers, stack, memory and output — Windows: `demo.exe` ohne Quelltext im Debugger – angehalten nach dem ersten `printf`: rechts Register und Stack, unten der Speicher der Daten-Section und die Ausgabe „Number 1“.

Dismonite: a DOS program stopped at a breakpoint, QEMU window with its output — DOS: ein Turbo-Pascal-Programm am Haltepunkt in seiner Schleife; QEMU mit FreeDOS, die Zahlen auch in der Ausgabe.

Dismonite: an ARM Linux program after a step over printf, ARM registers and stack — ARM-Linux: `hello-arm` im Raspberry-Pi-Gast, nach Step Over über `printf` – ARM-Register, Stack ab `sp` und der Speicher dort.

Taste	Debuggen und Hilfe
`F1`	Befehlsinfo: Befehl, Funktion, Interrupt
`F5`	Haltepunkt umschalten
`F9`	Starten / Fortsetzen
`F8` / `F7`	Step Over / Step Into
`F4`	Run to Cursor
`Strg`+`F2`	Debug-Sitzung beenden
`Strg`+`F` · `F3`	Suchen · weitersuchen
`Strg`+`G`	Gehe zu Adresse

Taste	Analyse
`C`	als Code markieren
`B` `W` `D` `Q`	Byte, Word, Dword, Qword
`A` / `U`	ASCII- / UTF-16-Text
`;` / `Enter`	Kommentar / Kommentarzeile davor
`N`	Label umbenennen
`Strg`+`R`	Verweise auf diese Stelle
`Strg`+`F3`	nächster Text
`Alt`+`←` / `Alt`+`→`	zurück / vor

Download

Dismonite liegt zusammen mit Asmonite in einem ZIP-Archiv – entpacken und starten, ohne Installation. Das ZIP liegt auf asmonite.com.

Testversion – Rückmeldungen willkommen

Asmonite 0.7.6

Dismonite (Disassembler und Debugger) und Asmonite (Editor, Assembler, Debugger), asmoc (Assembler auf der Kommandozeile), die QEMU-Skripte für FreeDOS und Raspberry Pi OS, die Debug-Server asmodbg, asmodbg64 und asmodbgx64 (Windows on ARM, ARM64, x64), die Befehlsinfo (Deutsch und Englisch) und Beispiele für Windows (x86, x64), DOS und ARM (Thumb-2, ARM64).

Windows 10 (ab 1809) / 11 Programm: Englisch · Dokumentation: Deutsch / Englisch 2.1 MB Stand: 2026-10-31

SHA-256: 2484d078507abefc2c0b2cd27c8bddaeb464dd6b329ee617369b41c22c10ef90

Lizenz (Freeware) Asmonite – der Editor und Assembler Prüfung bei VirusTotal ↗

⬇ Herunterladen

Was die Programme tun – und was nicht

Keine Installation, keine Einträge in der Registry: Dismonite merkt sich seine Markierungen in <programm>.dmon neben dem untersuchten Programm.
Keine Telemetrie, keine Werbung, kein Kontakt nach Hause.
Ins Netz gehen nur die QEMU-Skripte – und nur nach Rückfrage: QEMU (winget), die FreeDOS-Diskette, Raspberry Pi OS. Dismonite spricht per ssh nur mit dem eigenen Gast auf 127.0.0.1. Zum Debuggen auf Windows on ARM verbindet es sich nur mit dem Rechner, den du angibst; „Search LAN“ fragt dafür einmalig per UDP im lokalen Netz.
Zum Löschen genügt es, den Ordner zu löschen.

Den Download prüfen

Die Prüfsumme in der Eingabeaufforderung: certutil -hashfile Asmonite-0.7.6.zip SHA256 – sie muss mit dem Wert oben übereinstimmen.
Die Programme sind nicht signiert. Windows fragt deshalb beim ersten Start evtl. nach („Der Computer wurde durch Windows geschützt“ → „Weitere Informationen“ → „Trotzdem ausführen“).
Doku, Beispiele und alle Versionen auch auf GitHub.
Fragen, Fehler, Wünsche: mail@asmonite.com