Disassembler btw. strings aus einem binary ziehen...

[jens]

Ich würde gern Informationen aus den Firmware Dateien für Pentax DSLR ziehen.

Die Firmware Dateien sind verschlüsselt, aber das ist kein Problem. Es existiert ein einfaches Tool dafür: http://www.pentax-hack.info/documents/encrypt.html

Man kann wohl auch "Ida Pro" als Disassembler nutzten: http://www.pentax-hack.info/documents/revers.html

Ich habe auch einen in ANSI-C geschrieben Disassembler gefunden: http://scratchpad.wikia.com/wiki/Disassemblers/DFR und

Die Firmware ist wohl für den "Fujitsu Milbeaut M-5" Prozessor geschrieben. Dabei kommt wohl Softune REALOS/FR Ver. 4.0 zum Einsatz. Viele Informationen unter http://www.pentax-hack.info

In erster Linie geht es mir darum zu untersuchen, was sich wohl zwischen Verschiedenen Firmware Versionen getan hat. Bisher habe ich einfach mal sowas gemacht:

Code: Alles auswählen

cat firmware1.bin | strings > firmware1.txt
cat firmware2.bin | strings > firmware2.txt
diff firmware1.txt firmware2.txt

Raus kommt das z.B. das: http://pastie.org/3495115

Ich kann sowieso nicht wirklich Assembler. Von daher würde mir es erst einmal reichen, das man ein wenig die Struktur sehen kann. Also z.B. alle Variablen/Strings besser extrahieren...

Hat da jemand ein Idee, wie man das umsetzten kann?

[Leonidas]

Das ist doch gar nicht Assembler, das sind doch nur die Differenzen in den ASCII-Strings? Da kannst du ein Diff machen, aber bringen tut das halt nix. Was du machen müsstest, ist es, beide Firmwares zu disassemblieren und dann ein Diff machen und hoffentlich genug MB91680-Assembler verstehen um zu sehen was da anders ist. Ohne relativ umfassende Assembler-Kenntnisse und viel Zeit ist da aber vermutlich nicht viel zu machen.

Bezug zu Python? Uhm, keiner. Habs mal verschoben

[lunar]

@Jens: "strings" wandelt eine Binärdatei nicht in eine lesbare Darstellung um, sondern extrahiert lediglich zusammenhängende Bytefolgen aus dem Bereich druckbarer ASCII-Zeichen aus Binärdaten. Dein "diff" ist mithin vollkommen unbrauchbar, und es überhaupt so zu versuchen, hinterlässt bei mir den Eindruck, als hättest Du so überhaupt gar keine Ahnung, was Du da tust.

Wie Leonidas schon festgestellt hat, musst Du die Firmware erst einmal disassemblieren. Vielleicht hast Du Glück, und die betreffende Architektur wird von den GNU binutils unterstützt, dann reicht ein einfaches "objdump -D". Ansonsten musst Du nach einem Disassembler für diese Architektur suchen, oder im schlimmsten Fall die Referenz der Architektur auftreiben und die OP-Codes anschließend manuell dekodieren. Dann kannst Du den resultierenden Assembler in einen C-Decompiler füttern, und hoffen, dass dabei einigermaßen vernünftiger Quelltext heraus springt.

Ohne zumindest rudimentäre Assembler-Kenntnisse wird das allerdings ziemlich abenteuerlich. Reverse Engineering ohne Assembler-Kenntnisse ist halt nicht. Wenn es Dir ernst ist mit dieser Firmware, dann lerne erst einmal Assembler. Dazu gibt es so viel Literatur, dass das - entsprechendes Interesse vorausgesetzt - keine große Herausforderung sein sollte.

[jens]

Mir ist klar was string raus haut und auch das ein diff nicht viel her gibt. Deswegen sagt es auch nicht viel aus.

Ich will auch nicht wirklich Reverse Engineering betreiben. Dazu hab ich keine Zeit. Ich weiß sehr wenig von Assembler und will auch kein Wissen in diesem Bereich aneignen.

Es geht lediglich darum sich einen Überblick zu verschaffen, ob ein Update viel oder wenig bewirken könnte.

btw. objdump probiert:

Code: Alles auswählen

objdump -D FWDC209B_decrypt.bin 
objdump: FWDC209B_decrypt.bin: File format not recognized

[lunar]

@jens: Wenn Du wissen willst, ob ein Update etwas bringt, dann lies die Release Notes der neuen Version. Ohne Assemblerkenntnisse bringt der auch der disassemblierte Objektcode nichts, weil Du ihn nicht lesen und mithin auch die Bedeutung der Änderungen nicht abschätzen kannst.

[sma]

Damit's was mit Python zu tun hat, könnte er ja einen Disassembler in Python schreiben. So wie dieser "for fun" in 5min zusammengeschraubte Disassembler für den 6502, wo man jetzt nur noch die anderen 150 oder so Instruktionen hinzufügen müsste

Code: Alles auswählen

class Stream:
    def __init__(self, data, index=0):
        self.data, self.index = data, index
    
    def __nonzero__(self):
        return self.index < len(self.data)
    
    def next(self):
        b = self.data[self.index]
        self.index += 1
        return ord(b)
    
    def nexts(self):
        b = self.next()
        if b > 127:
            b -= 256
        return b

class I:
    def __init__(self, mnemonic, mode=None):
        self.mnemonic, self.mode = mnemonic, mode
    
    def disassemble(self, stream):
        return self.mnemonic + (self.mode(self, stream) if self.mode else "")

    # address modes
    
    def A(_, stream): return " A"
    def ABS(_, stream): return " $%02x%02x" % (stream.next(), stream.next())
    def ABSX(_, stream): return _.ABS(stream) + ",X"
    def ABSY(_, stream): return _.ABS(stream) + ",Y"
    def IM(_, stream): return " #$%02x" % stream.next()
    def IND(_, stream): return " ($%02x%02x)" % (stream.next(), stream.next())
    def XIND(_, stream): return " ($%02x,X)" % stream.next()
    def INDY(_, stream): return " ($%02x),Y" % stream.next()
    def REL(_, stream): return " $%04x" % stream.index + stream.nexts()
    def ZPG(_, stream): return " $00%02x" % stream.next()
    def ZPGX(_, stream): return _.ZPG(stream) + ",X"
    def ZPGY(_, stream): return _.ZPG(stream) + ",Y"

instructions = [
    I("BRK"),
    I("BPL", I.REL),
    I("JSR", I.ABS),
    I("BMI", I.REL),
    I("RTI"),
    I("BVC", I.REL),
    I("RTS"),
    # and so on
]

def disassemble(stream):
    while stream:
        print "%04x" % stream.index,
        print instructions[stream.next()].disassemble(stream)

disassemble(Stream("\x02\x48\x12\06"))

Stefan

[Hyperion]

@sma: Nice