Das deutsche Python-Forum

Hallo liebe Leute

Ich habe vor ein paar Tagen angefangen etwas mit OllyDebugger bzw. ImmunityDebugger zu spielen.
Und habe ganz simpel den Windows Taschenrechner so gepatcht dass er mit WinExec einen Befehl ausführt.
Jetzt meine Frage: Wäre es möglich mit Python einen Patcher zu schreiben?
Damit meine ich ein Programm, welches genau das gleiche macht wie ich vorher mit dem Debugger.

@cruzz: Ja das wäre möglich.

Oh da war meine Fragestellung nicht bedacht.
Ich möchte natürlich gerne wissen wie es möglich wäre.
Oder ein Stichwort wonach ich da suchen muss.

Ich verstehe die Frage nicht ganz, du möchtest anstatt mit einem Debugger mit Python z.B. calc.exe "patchen"?

Wenn ich mich richtig erinnere hat ImmunityDbg ein Python-Interface für Plugins (kurze Suche bestätigt das: https://www.corelan.be/index.php/2010/0 ... heatsheet/), eventuell ist ja das was du suchst.

Nein, das meine ich nicht.
Ich meine dass ich mit einem Script ein anderes Programm patche und nicht mit einem Debugger.

bsp: Ich nehme mit meine calc.exe und brauche dann nur eine .py-Datei anzuklicken die diese calc.exe dann patcht (in meinem Fall mit einem WinExec command).

Man braucht doch eigentlich nur Dateioperationen um die Daten in die EXE-Datei zu schreiben.

bitte um ein eindeutiges Beispiel.

Na ungefähr so:

Code: Alles auswählen

with open('.exe Deiner Wahl', 'wb') as f:
    f.seek(offset)        # offset ist Dein Sprungziel in der Datei (hier Bytes vom Anfang her)
    f.write('pöse Bytes') # was auch immer Du da reinschreiben willst

also wenn ich " jmp 0x012345 " auf addresse 0x543210 schreiben möchte müsste das so aus sehen:

Code: Alles auswählen

    with open('.exe Deiner Wahl', 'wb') as f:
        f.seek(0x543210)
        f.write('jmp 0x012345')

@cruzz: Nein natürlich kann man nicht einfach Assembler-Anweisungen als *Quelltext* in eine Binärdatei schreiben. Du musst da schon die Bytewerte schreiben die diesen Befehl in Maschinensprache kodiert für den Prozessor beschreiben.

ja stimmt ist logisch

hier mal alles was sich im Taschenrechner geändert hat:

01012475 > E9 36120000 JMP calc.010136B0
0101247A 90 NOP
0101247B 90 NOP
010136B0 > 6A 05 PUSH 5
010136B2 . 68 CF360101 PUSH calc.010136CF
010136B7 . E8 75FB847B CALL kernel32.WinExec
010136BC . 6A 70 PUSH 70
010136BE . 68 E0150001 PUSH calc.010015E0
010136C3 .^E9 B3EDFFFF JMP calc.0101247B
010136CF . 68 65 6C 6C...>ASCII "helloworld.bat",0 (68 65 6C 6C 6F 77 6F 72 6C 64 2E 62 61 74 00)

also müsste die erste Zeile so aussehen?:

Code: Alles auswählen

with open('calc.exe', 'wb') as f:
    f.seek(01012475)
    f.write('E9 36120000')

@cruzz: Strings mit Hex-Zahlen sind keine Maschinenbefehle und Speicheraddressen in Hex sind keine dezimalen Dateioffsets.

uiuiuiuiui jetzt bin ich ganz verwirrt... kann mit jetzt bitte endlich jemand auf die sprünge helfen?

EDIT:
Habe jetzt schon etwas gefunden was mir etwas weiterhilft.

Zitat aus Wikipedia:

Hex-Editoren sind in der Regel folgendermaßen aufgebaut (Erläuterung anhand des oben gezeigten Beispiels):

Ganz links wird ein Offset angezeigt. Dieser gibt die Anzahl der vorausgegangenen Bytes in Hexadezimalschreibweise an. In der ersten Zeile ist der Offset 0, was dem Dateianfang entspricht; in der zweiten Zeile beträgt er 1016, d.h. es sind 1016 = 1610 Bytes vorangegangen. Einige Hex-Editoren zeigen Offset-, Cluster- und Sektornummern auch dezimal an (die beiden letztgenannten sind für Bearbeitung der Daten auf Dateisystemebene wichtig).
In der Mitte sind die Bytes (genauer Oktette) der Datei hexadezimal dargestellt, z.B. 4816 für das erste Byte in der ersten Zeile.
Ganz rechts schließlich stehen die Bytes der aktuellen Zeile als Text (in einem bestimmten Zeichensatz) dargestellt. Im Beispiel werden die Bytes als ASCII interpretiert, dem gebräuchlichsten 1-Byte-Code (das erste Byte 4816 entspricht dem Buchstaben H). Diese Darstellung ist nur dann brauchbar, wenn es sich bei den Daten tatsächlich um Text handelt. So werden z. B. Bilder wie eine zufällige Aneinanderreihung von Zeichen dargestellt, manchmal sind jedoch Muster zu erkennen (besonders in unkomprimierten Bildern wie z. B. in Bitmaps).

und Link für Verständnis von Maschinensprache:
http://www.informatik.fh-nuernberg.de/p ... efehle.pdf

Da Du mit .exe unter Windows rumhantierst, gehe ich mal davon aus, dass Du eher x86 Opcodes brauchst: http://www.read.seas.harvard.edu/~kohle ... sref/i386/

Okay danke für die opcodes... aber wie finde ich offset?

Ich würde mich sehr über eine klare Antwort freuen wie ich das ganze anstellen muss!

cruzz hat geschrieben:Okay danke für die opcodes... aber wie finde ich offset?

Durch Zerlegen/Deassemblieren des Binaries: https://en.wikibooks.org/wiki/X86_Disas ... able_Files

Ich bin mit Google auf das Programm "IDA Pro Free" gestoßen.
Finde aber nichts dass mir weiter hilft. Möchte mich jetzt aber nicht geschlagen geben.
Kann mir noch jemand Tipps geben wie ich Offsets finde?

Finde nur sowas wie "push offset byte_10136CF" ... Kann aber mit sowas nichts anfangen.

@cruzz:
Wenn Du das händisch machen möchtest, musst Du die Binärformate und deren Implikation auf das Speicherlayout beim Laden von Executables nachvollziehen (und rückwärtig anwenden). Links zum Einlesen habe ich Dir gegeben. Wenn Du diesen Aufwand scheust, gehts nur mit fertigen Tools wie OllyDbg und Konsorten. Ein Grundverständnis dessen, was da eigentlich passiert, ist damit aber auch nötig.

okay...
Hab es jetzt soweit geschafft dass das Richtige an der richtigen Stelle steht -
aber leider sonst gar nichts

Liegt wahrscheinlich daran dass ich nicht mit den offsets klar komme.
Aber eine richtige Anleitung dafür gibt es ja irgendwie nicht.

Code: Alles auswählen

with open('calc.exe', 'wb') as f:
        f.seek(71796)
        f.write('jp')

Oder kann es sein dass noch ein Write-Befehl fehlt der alles andere auch noch rein haut?

@cruzz: Ich habe ja den Eindruck das Dir mehr als das mit den Offsets fehlt und Du nicht wirklich weisst was Du da machst. Wenn man den Programmteil eines Binärprogramms für eine bestimmte Prozessorarchitektur patchen möchte, dann sollte man Ahnung von Maschinensprache im Allgemeinen, dem Befehlssatz für die Prozessorarchitektur für die man ein Programm patchen möchte im besonderen, und natürlich vom Datenlayout der Datei für das Betriebssystem oder das Ladeprogramm haben. Und die Schnittstelle für Systemaufrufe muss man auch kennen wenn man solche aufrufen möchte. Also wissen wie die Argumente übergeben werden und wie der Aufruf selbst passieren muss. Das sind alles Sachen die man nicht mal eben so in ein paar Tagen lernt wenn man mit so etwas vorher noch nie etwas zu tun hatte. Normalerweise fängt man bei so etwas mit dem lernen von Assembler an.

Das deutsche Python-Forum

Mit python .exe patchen?

Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?

Re: Mit python .exe patchen?