 Gut, wir kommen zum nächsten Talk, zu dem letzten heute Abend hier im ZKM. Hier auf dieser Bühne. Wir hatten von Florian diverse Geschichten über Reverse Engineering gehört. Und ich denke, die meisten von euch kennen ja Ida Pro oder Ida und das Binary Ninja ist ein Konkurrenzprodukt. Und es geht um die Entwicklung von Plugins und wie man damit umgeht. Und ja, Benedikt macht das privat und beruflich und wird euch darüber einige Dinge erzählen. Hab Spaß. Perfekt. Okay. Hi. So, ich bin Benedikt. Ich hab mit einem Kumpel drüber geredet, dass ich immer noch Infosec mache. Der macht schon längst wieder ganz viele andere Sachen und hat mich so ein bisschen belächelt. Und hat gesagt, eigentlich mache ich ja jetzt mein ganzes Leben nur Mem-Copy. Das stimmt, aber ich fühle mich nicht gelangweilt. Ansonsten kletter ich und mache Musik. Und dieser Talk, wenn ich irgendwas sage, das ist alles meine private Meinung. Das spiegelt nicht unbedingt die Meinung meines Arbeitgebers wieder. Hoffentlich nicht. So, Binary Ninja. Ich hasse das immer bei Vorträgen, wenn man sich melden muss, aber jetzt kann ich ja mal euch melden lassen. Also, wer kennt hier Binary Ninja? Okay. Und wer hat eine Lizenz von Binary Ninja? Okay, ja, vielleicht danach ein paar mehr. Binary Ninja, also das ist, wie schon gesagt, ein Konkurrenzprodukt zu Ida, ein Reversing-Tool. Das ist Cross-Plattform. Das funktioniert eigentlich auf Linux, OS X und Windows überall gleich gut. Die Architekturen, die unterstützt werden, ist halt X86. Und man kann das aber auch, man kann selber quasi CPU Extensions für Binary Ninja schreiben und dann auch irgendwie andere Architekturen unterstützen, aber von Haus aus mal die drei, zumindestens. Es hat eine Intermediate Language, was wir in dem Vortrag schon mal gehört haben, schon integriert beziehungsweise sogar mehrere, momentan Low und Medium. Okay, irgendwas mit dem Mikrofon, das geht manchmal aus. Und vielleicht haben Sie bald noch eine High Intermediate Language, aber bisher sind es nur die zwei. Normalerweise läuft das im GUI-Modus. Wenn man eine Personal-License hat, ist das immer so. Wenn man eine Commercial-License hat, die ein bisschen teurer ist, dann kann man das auch im Headless-Mode laufen lassen und komplett Skripten überpeiten. Und es ist viel billiger als IDA. Was für mich auf jeden Fall ein Grund war, wenn man sich das irgendwie privat kauft. Ich glaube, bis vor ein paar Monaten hat die private Lizenz irgendwie 100 Euro rum gekostet. Jetzt kostet es, glaube ich, 160. Wenn man das mit den paar 1000 Euro IDA vergleicht, das ist immer noch ziemlich günstig und die Commercial weiß ich grad gar nicht, was die kostet. Und was Binary Ninja, finde ich, richtig cool macht, ist, dass es eine sehr gute Python-API hat, wo man Plugins verschreiben kann. Und deswegen auch dieser Vortrag. Ich habe da vor ein paar Monaten schon angefangen, mal so ein bisschen mitzuspielen und Plugins zu schreiben, aber irgendwie fehlte mir so ein bisschen ein Tutorial. Und es gibt sehr viele Blockposts darüber. Also wenn ihr Binary Ninja Block googelt, dann findet ihr ein Haufen Blockposts, wo Leute CTF-Challenges damit lösen oder diverse andere Sachen machen. Aber es fehlt so ein bisschen, wie stelle ich jetzt das mit der API an und wie stelle ich das mit der API an und ich versuche das mit dem Vortrag jetzt zu machen. Ich stelle das auch später, die Code Schnipsel auf geht hab und dann kann man da einfach copy und pasten, wenn man sich was zusammenbauen möchte. Okay, die API, die findet ihr, die ist dokumentiert, also die offizielle Binary Ninja API. Binary.ninja, der Issue Tracker und wo man so ein bisschen gucken kann, wie das Ding sich gerade entwickelt, das auf GitHub, von Vector35, das die Firma, die Binary Ninja macht, slash Binary Ninja API. Und der letzte Link ist eine Sammlung von Community Plugins, die es dafür schon gibt. Da zeige ich nachher vielleicht auch noch ein paar. Das ist einfach nur für später als Referenz, wo man die Plugins, wenn man sie hat, hinschiebt. Binary Ninja hat auch so ein Plug-in Manager, aber der ist noch nicht offiziell in der UI und bisher ist es einfach so, man geht in eines von diesen Verzeichnissen, je nachdem auf welcher Plattform man ist, macht ein Git-Clone von dem Plug-in, was man haben möchte und danach ist das irgendwie dann geladen, wenn man Binary Ninja neu startet. Genau. Ich hab hier noch so ein kleines, so ein kleines Trick irgendwie, wie man so ein, ja ich zeige es am besten einfach mal. Also wenn man Binary Ninja aufmacht, ist er nicht auf, okay. Hey, genau. So, dann ist es erstmal ziemlich unspektakulär. Ich lad da jetzt einfach mal irgendeinen Pfeil rein, man hat halt hier so ein Ding und man kriegt so Grafen wie bei Ida, man kann da durchskrollen. Und wenn ich jetzt was entwickeln möchte, Plug-in-mäßig, da hab ich hier unten halt so eine Python Shell und wenn ich jetzt irgendwas reintippe, dann kriege ich irgendwie was auch zurück. Ist ja schön und gut, aber wenn ich jetzt, wenn man jetzt Python Shells gewöhnt ist, iPython oder sowas, drück ich tap, passiert ja genau gar nichts. Und das ist natürlich ziemlich hässlich, wenn ich mich noch nicht so gut auskenne mit den ganzen Objekten und ich komme da nicht wirklich weit. Und was es halt gibt, ist dieses EPDB, das macht eigentlich nur ein Tainment-Port auf, auf dem man sich mit einer anderen Python Shell hier draufkonekten kann. Und dann hat man sowas wie History und TapCompletion. Das kann ich jetzt einfach mal zeigen, irgendwo hier hab ich das drinnen. Das muss man über PIP, muss man halt EPDB installieren. Dann ruft man hier EPDB-Serve auf, dann macht das Port 8080 auf. Und jetzt kann ich hier einfach eine iPython-Shell machen, import EPDB, EPDB-Connect. So, und jetzt bin ich hier in meinem Binary Ninja drinnen und hab dann gleich auch sowas wie TapCompletion für bestimmte Objekte, da komme ich gleich noch drauf. Aber wenn ihr irgendwie entwickelt, könnt ihr das benutzen, das macht die Sache ein bisschen einfacher. Auf Windows tut es leider noch nicht funktionieren, das wollte ich noch portieren, aber aus Gründen ist, das ist für den Vortrag noch nicht fertig geworden, kommt aber noch. API Basics, also es gibt das hier Kommand, das habt ihr schon gesehen, es gibt einfach die Adresse zurück, wo wir gerade sind. Also wenn wir jetzt hier an die Adresse gehen und ich geb hier ein, das ist jetzt die Ansicht gewechselt, keine Ahnung welcher Shortcut das macht, weil ich benutze nur die API. So, guck mal. Hey, ah, der will nicht, weil der served ja hier, muss ich den zumachen. So, jetzt lüft ich hier, glaube ich. Ich kann gar nichts reinschreiben wegen diesem Ding, man macht es halt hier. Jetzt geht das dir da nicht. Das ist ein Hacky, aber es macht immer noch besser als die, als die Schei sonst. So, so mal hier wieder. Genau, und wenn ich das ganze Hacks ausgebe, dann genau, hier ist gerade halt der Cursor. Das sind einfach die Basics, wie ich da dran komme. Ein zentraler Bestandteil von dieser ganzen Python-APIs, die sogenannten Binary Reviews, und zwar alles, was ihr in dem Binary Ninja quasi öffnet. Das wird in so ein Binary-View rein geladen. Und da seht ihr auch schon, da ist jetzt irgendwie, steht hier drin elf, für einen elf Binary, und Open und einfach der Part von dem Binary, was da aufgemacht wird. Und da könnt ihr aber auch PI-Files für Windows nehmen, oder Macho-Files, und die landen in so einem Binary-View. Und ausgehend von diesem Binary-View könnt ihr dann quasi alles Mögliche in dem, mit der Binary Ninja-API auf diesen Binary machen. Einfach Binary-View.sections, dann seht ihr hier die ganzen elf Sections in der Liste. Wenn ihr dann quasi über den Array-Zugriff den Namen nehmt von dieser Section, dann seht ihr, wo die reingemapped ist, mit der Start-Adresse, der End-Adresse, das könnt ihr auch schön objektorientiert, mit Punkt Start, Punkt End, kriegt man die ganzen Adressen raus. Und genau, zum Beispiel Symbole, kriegt man ganz einfach über die Binary-View-Symbols. Dann gibt es halt Get-Symbol-Add, wenn man eine Adresse hat und wissen möchte, was für ein Symbol da ist, oder wenn man einfach nur einen Namen vom Symbol hat, dann kann man das mit Get-Symbol bei Raw-Name sich holen. Und dann gibt es das Binary-View.arc. Das ist dann jedes Mal anders, je nachdem, was ihr von Binary reinladet. Also da seht ihr jetzt zum Beispiel, ich hatte dafür das Beispiel in 64-Bit, x86-File reingeladen. Dann ist es Little-End, die Adresse ist 8-Bit. Also das ändert sich dann je nachdem, was ihr da reinladet. Das ist ganz cool, weil dann könnt ihr eure Plugins, wenn ihr die schreibt, relativ generell halten und könnt die Spezifika für einzelne CPUs darüber abfragen. Ihr kriegt auch die Calling-Conventions, ihr bekommt halt raus, welche Argumente zum Beispiel hier am Schluss, das ist wie Calling-Convention, in welchen Registern bei x86-64-Bit die Argumente übergeben werden und das Rückgaberesultat nach dem Function-Call, in welchem Register das steht. Solche Sachen stehen da dann drin. Disassembly und Assembly könnt ihr auch direkt über das Binary-View machen. Das ist dann auch von je nachdem, was ihr da für eine Architektur habt, wird das dann halt alles automatisch unter der Haube gehandelt. Glaube, da ist auch Capstone drunter. Functions, bekommt ihr über wat.functions. Ihr könnt, wenn ihr eine Adresse habt, nicht wisst, zu welcher Function das gehört, macht der Functions-Containing die Adresse, dann kriegt ihr das raus. Und wenn ihr so ein Function-Objekt habt, geht es über Punkt Name, könnt ihr den Namen von der Funktion rauskriegen, Punkt Was, welche Variablen das Ding bekommt. Da seht ihr auch schon, da steht jetzt in dem Fall schon Woi-Trinne, das Binary-Ninja versucht, eine Typ-Rekonstruierung zu machen für die Funktionen, also ob das Integer ist oder ob das ein Pointer ist oder was auch immer, der versucht, und wie ihr das macht, da kommen wir später noch drauf, das geht dann über die Intermediate Languages. Dann kriegt man darüber auch die Basic Blocks. Und genau, es gibt eigentlich immer so coole Operatoren, Literatoren, die habe ich jetzt am Schluss drauf. Zum Beispiel, wenn ich jetzt über alle Functions iterieren will, mache ich einfach Vor-Function in Binary-View-Functions und dann kann ich darüber iterieren, kriege halt die ganzen Function-Objekte. Kann ich auch machen, dann kann ich quasi, da gibt es auch Pluckins, die machen dann hier rechts, also ich kann hier einmal hier in die GUI reinmachen, Enter-Comment, dann steht halt hier wie bei Ida rechts ein Kommentar dran und das kann ich auch über die API machen, indem ich einfach die Adresse sage, in dem Fall ist es jetzt hier Function-Start und beginn auf Function tu ich das Kommentar hinschreiben und dann sehe ich das auch später in der GUI und Comments, das ist einfach wieder die Sammlung von Kommentaren für die Funktion. Basic Blocks, was da ganz cool ist, also wenn man ein einzelnes Basic Block Element hat, das geht auch hier über die Function, also ich habe eine Function-Objekt F0 und da sage ich Punkt Basic Blocks und dann habe ich halt ein Array von Basic Blocks, da habe ich jetzt einfach mal eins rausgeholt, das B2 genannt, zweite Basic Block und was man halt sieht ist Outgoing-Edges, Incoming-Edges, und da hat man dann im Prinzip schon die Sachen drinne, wie das in dem Graph aussieht, das heißt man kann ganz cool durch den Basic Block Graph durch navigieren auch über die API und da stehen auch schon jetzt noch so ein paar Meter Informationen drin, zum Beispiel dass es in ein Unconditional Branch reingeht und dass es aus einem False Branch kommt und so weiche Sachen und was man auch natürlich noch machen kann ist es automatisch einfärben, also jeder Pluck ins geschrieben hat, weiß, dass das eigentlich ganz hilfreich ist, dass man so ein Basic Block eine andere Farbe gibt, wenn da irgendwas Wichtiges drin ist dass wenn man so einen riesengroßen Graph hat einem sofort ins Auge sticht, da ist irgendwie was, was ich mir genauer anschauen sollte und genau hier unten sieht man eigentlich auch wieder nur, dass man da drüber iterieren kann dann bekomme ich über den Basic Block natürlich auch den Disassembly nochmal raus, über dieses Disassembly Text das ist auch tokenisiert also wenn ich quasi einfach nur über den Standard Disassembly irgendwelche Abfragen machen will dann kann ich natürlich auch einfach dieses Drinks nehmen und sagen, ist das jetzt ein Push oder was auch immer, es geht aber auch schöner da komme ich dann gleich dazu und man kann auch einzelne Instructions Highlighten, nicht nur Basic Block, sondern auch einzelne Instructions in den Basic Block oder auch immer und genau, da habe ich jetzt nochmal eine andere Sinntags gezeigt, also man kann Standardfarben nehmen, so ein bisschen wie bei Highlight Color, ist einfach so eine Standardfarbe oder ich gebe halt selber Rot-Blau-Grün an und kann mir meine eigenen Farben mischen wenn ich irgendwie eine künstlerische Phase habe genau, Cross References kriegt man über Get Code Refs und da wirft man im Prinzip auch einfach eine Adresse rein, da oben habe ich jetzt einfach mal gesagt, hier gibt mir mal die Adresse von Strick Copy und zeig mir mal alle Funktionen an die das irgendwie referenzieren und da sehe ich jetzt hier unten dann genau, also das sind mehrere gefunden worden und ich habe halt einfach immer exemplarisch einen rausgenommen und geguckt wie die heißt genau, jetzt der coole spannende Teil die Intermediate Languages also Binary Ninja benutzt eigene Intermediate Languages sie haben nicht irgendwie was schon bestehendes genommen und die Gründe die sie dafür anführen ist, sie wollten halt was was man auch selber lesen kann, also die meisten Intermediate Languages die es so gibt die sind dann für den Computer ganz hilfreich aber wenn man die selber liest, da muss man eigentlich noch einen zusätzlichen Assembler-Dialekt lernen die haben das versucht möglichst Menschen lesbar auch zu lassen, aber gleichzeitig für den Computer auch verstehbar das geht auch in Single Assignment Notation rein, damit sie dann gut bei verschiedenen Instructions die ganzen Seiteneffekte auflösen können und genau es muss einfach sein dass sie in eine andere Intermediate Language zu übersetzen, der Grund dafür ist dass sie sich dafür entschieden haben selber mehrere zu machen, also wie am Anfang schon mal gewinnt es gibt Low und Medium und später wahrscheinlich sogar noch High und zwischen denen soll es möglichst einfach sein auch zu übersetzen und es soll natürlich auch möglichst einfach sein aus einem bestehenden Assembler in diese Intermediate Language rein zu übersetzen genau, fangen wir mit der Low Intermediate Language an, die ist noch ziemlich nah am eigentlichen Assembler eliminiert aber schon die Seiteneffekte von einzelnen Instructions, was heißt wenn ich eine einzelne Assembler Instruction habe die Seiteneffekte hat, dann hab ich danach mehrere Low Level Intermediate Language Instructions und Nobs werden eliminiert jetzt mein kurses Beispiel hier oben sind wir einfach einen klassischen X86 64-Bit Assembler und hier unten ist das gleiche in dem Low Level Assembler und man sieht was ich zum Beispiel ändert ist, das Push das sieht so ein bisschen aus wie ein Funktionsaufruf mit den Klammern Zuweisungen hier oben, das sieht man ja Moff Stack Pointer in Base Pointer und hier unten sieht man einfach Base Pointer gleich Stack Pointer, es ist einfach nur so ein bisschen syntaktischer aber dadurch wird es deutlich einfacher zu lesen ohne dass man jetzt genau wissen muss was die Instruktionen da oben bedeuten dann hier unten wird es ein bisschen komplizierter, da wird ein Speicherbereich geschrieben, da steht am Ende Punkt D dahinter, das heißt einfach dass es ein Double Word ist, das sieht man hier oben auch und Punkt Q für den Quad Word sieht so ein bisschen am Anfang ein bisschen kryptisch aus, aber man gewinnt sich eigentlich schnell dran und genau, dann sieht man hier unten noch, dass ein Call einfach mit einer Klammer gemacht wird wie es halt bei C der Fall ist was man jetzt aber hier nicht sieht ist das zeige ich dann im Bindinger selbst haben es denn schon wieder zu na komm ich bin völlig aufgemacht das ist einfach mal weg so lädt ja zum Glück schnell es ist nicht so so ein riesen Ding wie das hier ich kann jetzt einfach hier unten bei Options Umstellen auf Low Level Intermediate Language wenn ich jetzt hier irgendwie mit der Maus drüber gehe, dann sehe ich hier wo sie sich nicht ja machen wir mal hier benutze ich schon mal einen Plugin Explain Instruction und was man zum Beispiel sieht ist der Generator schon der Generator schon noch ein bisschen mehr raus unter der Haube was man irgendwie jetzt in dieser einfachen Umstellung von den Variablen nicht sieht, zum Beispiel hier sieht man jetzt, sagt schon auf welchen Stack Offset das zurückgeht genau wo waren das irgendwo hat noch mehr gesehen ich finde es kann nicht, na gut unter der Haube passiert da noch ein bisschen mehr das sieht man dann auch wenn wir eine Slide weitergehen wie arbeiten wir jetzt damit in der API also einmal was man sehen kann ist das löst dann einem schon auch auf der weiß dann schon genau welche Register von bestimmten Instructions überschrieben werden, zum Beispiel kann ich jetzt sagen in der Function 1 welche diese Instruction 7, das ist ein Call da sieht man die, alle diese Register die hier stehen werden irgendwie vom Call quasi verändert und sind danach nicht mehr wie vor dem Call dann kann man ganz gleich wie bei den Basic Blocks einfach über den Array auf die einzelnen Instructions drauf gehen und jetzt geht eigentlich der ganze Spaß erst an jede Low Level Instruction hat eine sogenannte Operation das ist ein Enum und da gibt es halt verschiedene Typen, zum Beispiel hier Set Register für dieses Ding und diese Dinge sind halt mega hilfreich wenn ich da automatisch iteriere später und gesagt mich interessieren alle möglichen Variablen zu weisen dann filter ich einfach nach diesem Ding und alle anderen Operations brauche ich mir erst mal gar nicht anzugucken dann ist hier unten noch zeigt wie man quasi aus einem normalen Assembler Byte Code direkt den Low Level Code generieren kann, falls das Binary Ninja nicht schon getan hat, also wenn man jetzt irgendwie einfach sagt, oh wie diese Bytes hab ich jetzt in einem Shellcode gefunden, wie sieht das denn in der Low Level Intermediate Language aus, kann man das mit diesem Get Low Level from Bytes Call machen und iterieren kann man da auch drüber dann und genau jede Instruction hat Operands, also halt Operanten da gibt es dann meistens auch noch eine Source and Destination und die Operanten haben dann auch wieder Typen und da kann ich dann wieder gucken, ist das ein Register, wo das hingeschrieben wird oder gelesen wird, ist das ein Speicherbereich, wo das hingeschrieben wird und was auch schon dazu kommt ist, das wollte ich nämlich gerade eigentlich zeigen in der UI, aber das hat es irgendwie nicht gezeigt, manchmal ich weiß nicht wo das dann drin steht, auf jeden Fall was er schon macht ist, er versucht den Typ rauszufinden und dementsprechend was von Typ das ist der auch zu sagen, was für Werte das Register oder der Speicherbereich überhaupt annehmen kann, also wenn das jetzt hier ein Int ist, wie in diesem Fall ein Anzehendint, dann kann es halt von 0 bis fffffff gehen und wenn er aber merkt da sind jetzt Instructions beteiligt, nur auf Byte Größe agieren dann schrumpft das natürlich dementsprechend hier habe ich einfach mal so ein paar Typen die es gibt aufgezählt, es gibt den Call, es gibt die Compares für alle möglichen Sachen, Anzeit Compares Sign Compares, Equal, Non Equal Greater, Lower, Whatever alles Push und Pop es gibt eine riesengroße Liste, wenn man diesen Link hier anklickt, dann kann man sich die ganze Liste anschauen genau, dann gibt es die zweite Stufe quasi, diese Medium Level Intermediate Language die tut gleichzeitig noch hinzufügen was alles auf dem Stack passiert, also da wird das alles noch in so semantische Informationen gepackt und die Typen werden auch noch mal stärker durchdefiniert und genau, hier sehe ich auch ich kann den Typen abfragen und in dem Fall ist es sich genau 0% sicher dass es ein 32-Bit Wert ist, warum auch immer das 0% ist eigentlich sollte es klar sein, weil das Register ist halt nur mal 32-Bit groß, aber gut manchmal ist das noch nicht so ganz ausgereift aber man kann damit schon arbeiten da gibt es dann auch wieder Typen das ist eigentlich ziemlich ähnlich wie die Low Level Intermediate Language gibt es genau wieder so eine riesengroße Liste aber darüber hinaus gibt es halt noch ein paar mehr Sachen und ich zeige jetzt einfach noch mal im Binary Ninja wie sich das ganze Ding verändert wenn ich hier von Low Level Intermediate Language umstelle auf Medium Level, da sieht man schon das schrumpft deutlich zusammen ich kriege jetzt hier vor jedem Ding irgendwie auch ein Typ hier Charpointer ist das ganze Ding was sieht man noch hier oh, warum stützt es da und ab irgendwas ist hier, ich habe es heute aufgesetzt ich keine Ahnung, normalerweise stützt es nicht ab schlecht so was jetzt zu sagen er müsste mir einfach glauben ich weiß nicht was das Problem ist kann das jetzt hier nicht die baggen so, was man noch sieht ist hier Function Call da kommen halt die Argumente rein das wird dann auch schon so eingerückt also es liest sich schon fast ein bisschen c-mäßig und genau eigentlich immer wenn ich Binary Ninja benutze in der UI stelle ich irgendwie auf die Intermediate Language um und liest das erstmal so weil es ist halt deutlich schmaler und was man jetzt hier auch nicht sieht ist wenn ich verschiedene Architekturen oder zum Beispiel Intel 3264 Bit habe das sieht dann in dem Mediate Intermediate Language Ding ziemlich ähnlich aus auch wenn die Assembler Instructions Unterschiede haben oder auch von ARM zu X86, der Graph sieht ziemlich gleich aus ist klar, weil es gleiche tut aber in dieser Intermediate Language liest sich das dann ziemlich gleich im Ende Background Tasks kann man machen in seinen Plugins, das habe ich auch irgendwie durch Zufall rausgefunden indem ich Code von anderen Plugins angeschaut habe war für mich nicht so offensichtlich dokumentiert, da kann ich einfach eine Klasse instanziieren die halt so ein Binary View das Argument und von der Background Task Red Klasse erbt und dann läuft das Ganze irgendwie im Hintergrund und man kann hier noch sagen was im Progressbar stehen soll und so weiter so, jetzt will ich in Plugins schreiben wie funktioniert das also ich habe ja am Anfang schon dieses Plugins Verzeichnis gezeigt da lege ich eigentlich 2 Sachen rein einmal ein Plug in JSON, da ist ein bisschen Metainformation drin wer ist der Autor, was finde Lizenz, was tut das ganze Ding und dann das 2. was ich irgendwie reintun was man reintut, ist eigentlich ein InitPy und das ist dann eigentlich schon der Code und hier unten sieht man was man machen kann, also ich kann ein Plug in registrieren was halt einfach auf einem Knopf ausgeführt wird auf eine Binary View oder ich kann halt sagen es soll da ausgeführt werden wo gerade der Cursor was hat, also wo der gerade hin zeigt und dann muss ich einfach hier oben Funktionen implementieren die eine Binary View bekommen oder in 2. Fall halt eine Adresse noch zusätzlich und dann kann ich damit schöne Dinge tun und konkret sieht es eigentlich ja dann so aus, wenn ich hier im Binary Ninja drinne bin dann sind hier bei Tools meine ganzen Plugins oder per rechter Maustaste hier drinne und dann kann ich hier irgendwie sagen ja mach mal irgendwas so UI kann man ein bisschen spielen also was man hier machen kann ist um so was zu generieren also wenn man möchte, dass das Plug in noch irgendwie konfigurierbar ist in der UI dann kann man es mit diesen Feldern tun oder eine Messagebox bauen genau und dann wird es da irgendwie angezeigt und man kann sich da schon durchklicken da gibt es noch andere Selektoren also wenn ich eine File aufmachen möchte oder wenn ich einfach ein Freitext fällt möchte da gibt es ja verschiedene Sachen auf diese Seite dokumentiert ist aber eigentlich relativ simpel dann genau, jetzt wollte ich mal noch ein kurzes Beispiel zeigen, wie setzt das Ganze in den praktisch ein und ich finde ich habe ein dangerous Functions Plugin gebaut, weil das finde ich ist so das Hello World für eine Reversing API und zwar geht es eigentlich darum Strull Copy zu finden und alle Funktionen zu zeigen die es irgendwie aufrufen damit man da halt guckt ob's Buffer Overflow es gibt völlig klassisch einer für Eleforen wie schaut das Ganze jetzt aus Plugins da ist das Benial Dangerous ich mache das Ganze mal ein bisschen größer weil ihr wollt ihr vielleicht lesen wie schon gesagt, ich hab ja einmal so ein Plugin JSON, da ist einfach nur unspannende Meta-Informationen drin, aber wenn ihr wollt zum Beispiel dass euer Plugin auf der Community Seite wird, dann solltet ihr das schön ausbilden weil da steht das dann alles drauf dann habe ich einmal hier so ein bisschen Widget Code den habe ich mir geklaut von irgendeinem anderen Plugin die fangt von Nob Developments vielen lieben Dank für diesen coolen Trick damit kann man irgendwie über QT, also die ganze GUI von Benial Dangerous in QT damit kann man in der QT quasi seine Resultate schöne Tabelle anzeigen und so was aber jetzt der eigentlich spannende Teil ist der Initcode hier so Dangerous Functions das kann man hoffentlich lesen gehen wir erst mal ganz zum Schluss also erstmal registriere ich das Ding hier ich registriere 2 Sachen und zwar einmal vor Function und einmal das habe ich vergessen in der Liste mit aufzunehmen ich kann natürlich auch nicht nur Register aber auch vor Function machen also dann wird die aktuelle Funktion noch mit rein übergeben und dann hier Register das eine ist halt, finde mir alle Dangerous Functions und zeigt mir eine Tabelle an und das zweite ist, wenn ich jetzt irgendwie reversed habe und gefunden habe dass es irgendwie eine Funktion hat die My Own Written Copy heißt, die aber auch irgendwie eigentlich das Gleiche ist wie Strick Copy und ich möchte nach der checken kann ich halt mit diesem unteren Call die hinzufügen auch mal auswerten lassen und das ist jetzt ja eigentlich ziemlich unspannend, aber was ganz cool ist ist da Binary Ninja schon einige Sachen rausfindet über diese Intermediate Language, unter anderem auch die Parameter von den Funktionen kann der mir auch noch ein bisschen mehr sagen, zum Beispiel ich kann hier über die Function dann die einzelnen Parameter mir geben lassen und ich kann sogar auch sagen ist das eine Funktion, wo der Zielbuffer von Strick Copy auf dem Stack liegt wenn ich nach Stack Overflow suche oder liegt er auf dem Hip oder irgendwo anders oder geht zum Beispiel ein Argument für Strick Copy kommt es direkt aus einem Argument von der Funktion oder kommt es irgendwo anders her und genau ansonsten ist einfach hier für alle Dangerous Functions gibt mir das, such mir das Symbol von der Dangerous Function raus ob das in dem Binary vorhanden ist und wenn nicht, dann mach einfach weiter und falls ja, dann suche dir alle Cross References für dieses Symbol und gib mir hier die Funktionsparameter zurück und tüte das in die Tabelle rein und wie man sieht, das ist jetzt komplett plattformunabhängig, also das würde jetzt bei ARM funktionieren, das würde bei X680 funktionieren, bei MIPS funktionieren ich schreibe das Placken nur einmal und danach kann ich da überall nachsuchen da ist jetzt nichts Architekturspezifisches drin enthalten und wenn ich das Ganze jetzt in meinem schon wieder abgestürzten Binary Ninja mache Dangerous Functions, dann sehe ich jetzt hier ich kriege so ein schönes Doglet hier das kann ich auch verschieben und ich habe jetzt in dem Fall also kann ich mir das hier runter verschieben wenn ich irgendwie an der Seite mehr Platz will und was ich jetzt hier sehe ist, es gibt einen Struccopy in der Funktion vulnerable und die Destination von Struccopy ist ein Stack Buffer und die Source ist RDI und die Size kommt auch aus RDI genau also dass man nur so als kleines Beispielen dann genau ansonsten diese Blockpost sind alle sehr empfehlenswert es gibt ein Haufen, aber die sind noch relativ wie soll man es sagen nicht ganz so speziell außer das letzte ich habe hier abgefahren, da finden sie Hard Bleed mit Static Analyzes Only also da wird nichts ausgeführt einfach nur mit Binary Ninja Pluckins und Z3, das ist ziemlich cool sollte man auf jeden Fall mal sehen haben und genau, das war es jetzt eigentlich von mir, ich kann nochmal vielleicht ein paar Pluckins zeigen wie viel Uhr ist denn eigentlich halbe Stunde also ich kann, wenn ihr wollt, noch ein paar Pluckins zeigen und ansonsten könnt ihr Fragen stellen dann könnt ihr sich nicht so beeilen müssen ok, war überraschend Fragen? du hast sie anscheinend geplettet vielleicht, also es ist ja tatsächlich auch so ein bisschen ein Tutorial gedacht also wenn ihr jetzt Lust bekommt da irgendwie das mal zu benutzen oder so, ich tue das irgendwie auf mein Github drauf und dann könnt ihr da wenn ihr irgendwie was haben wollt oder so schickt mir einfach eine Mail oder was auch immer und schickt die mir genau, ansonsten vielen Dank so, was können wir denn noch zeigen ja, ich zeig jetzt einfach mal Dinge bis alle weg sind oder ich keine Lust mehr hab also was können wir denn zeigen Community Pluckins hab ich einfach nochmal ausgecheckt was ist denn nett den Benilgraft zum Beispiel das ist ganz cool, also was nett ist wenn man sich mit diesen Intermediate Languages rumschlägt und noch keine Ahnung hat wie die strukturiert sind da gibt es dieses Benil Instruction Crafting, das hat eine Graphis Dependency, aber das ist alles dokumentiert dann draufklickt, dann kriegst du so ein Graph by Call, das ist jetzt vielleicht ein bisschen dumm ich nehme erst mal was einfaches xorairxairx, wie sieht das Ganze hier aus und dann kann ich mir hier das schön angucken welche Objekte da bei Binary Ninja unter der Haube drin stecken und genau also das ist hilfreich wenn man damit irgendwie rumspielen möchte, aber einfach noch keine Ahnung hat wie das Ganze denn so zusammenhängt syscaller Annotator vielleicht noch, genau, ein Annotator nehmt mir irgendwas anderes auf was kann man denn nehmen sagt mir mal Binary was irgendwas mit der Lippsee macht, egal welches okay so, wir brauchen irgendwas also hier sehe ich auch irgendwie in der UI die Cross Referenz ist und jetzt gucken wir mal ob der Annotator funktioniert Annotate Functions macht da nichts welcher Function also es gibt so ein Programm Tool, das heißt irgendwie Annotator das ist ja auch so eines der erste Sachen die man irgendwie haben will wenn man Reversing anfängt man hat irgendwie Funktionen und man möchte irgendwie die Argumente klarer sehen zum Beispiel hier aus OpenSSL, hier diese komische Paddingfunktion die kriegt halt diese Argumente und ich möchte irgendwie Binary Ninja die als Kommentar halt sehen also wenn dann Register steht was in diese Funktion reinkommt dann soll da hinten dran stehen aha, das ist jetzt hier das anzahend pointer to argument Interplugin, das funktioniert eigentlich ganz simpel es registriert halt hier das das Kommando und danach so ein Plugin danach findet es raus welche Plattformen das ist das unterstützt scheinbar nur x86 und dann geht es halt hier über alle Funktions Blocket über alle Instructions guckt ob das eine Call Instruction ist und wenn es eine Call Instruction ist dann guckt es wo der Call hingeht und ob das ein Symbol ist was in dieser JSON-Datei irgendwie verwendet wird und falls das der Fall ist dann holt er sich diese ganzen Argumente und läuft irgendwie in der Funktion über alles Deckargumente und setzt halt die richtigen Kommentare mit Z comment in die UI rein so, was können wir noch machen das gleiche gibt es dann noch für SysCalls vielleicht SysCaller SysCaller so, linken wir das mal rein SysCaller das müssen wir einmal neu starten vielleicht mal Netcat öffnen oder so das müsste irgendwie ein SysCaller haben ein SysCaller anwerfen take away SysCalls und jetzt müssen wir mal gucken ob irgendwo was hinten was ein SysCall macht also das wäre eigentlich das gleiche wie Annotate Functions ist dann für SysCalls und dann werden halt die SysCalls annotiert da kann ich hier irgendwo ich hätte mich vielleicht auf die Sachen vorbereiten sollen könnte das selber ausprobieren klaut mir einfach, das funktioniert oh man, die Demos so was gibt es noch es gibt NEMPA das kann dann so Flirt Signaturen benutzen um Funktionen so identifizieren genau, da könnte quasi die Symbole von der IDA einfach rein importieren und dann geht es über die ganzen Funktionen und guckt halt über die Signaturen ob es die kennt und nennt sie halt dementsprechend um und da gibt es auch glaube ich ich dachte ich hätte da mal irgendwie schon Standard Signaturen gesehen für irgendwie so Windows Sachen habe ich mich wohl geirrt oder irgendwo anders die gefunden dann gibt es noch ein ganz abgefahrenes Plug-in das ist irgendwie der Ripper das ist irgendwie hauptsächlich, kommt das glaube ich von so CTF Leuten da ist die Unicorn Emulation Engine noch mitbeteiligt da kann man dann in der UI Funktionen markieren und sagen die möchte ich irgendwie extrahiert haben also wenn man zum Beispiel einen Key Generator Funktionen gefunden hat und das Binary aber riesig groß ist man ist eigentlich nur in dieser einen Funktionen interessiert dann benutzt dieses Plug-in irgendwie dann die Unicorn Engine um das durchzulimulieren und zu gucken ob es irgendwelche Seiteneffekte gibt die noch beteiligt sind und extrahiert das alles raus in ein extra Binary was man dann irgendwie benutzen kann also ziemlich abgefahrenes Zeug habe ich aber selber noch nie benutzt dann gibt es irgendwie den Red Deck Decompiler da gab es am Anfang der wurde ja auch erwähnt dieser Open-Gesource Decompiler da gab es irgendwie am Anfang auch mal so ein Online Plug-in wo man Account für brauchte das geht jetzt auch offline also man kann sich den Decompiler runterladen und dann im Binary Ninja sagen ok ich möchte diese Funktion Decompilen und dann kriegt man halt das Decompilte-Ding halt drauf Kryptoscan das kennt man auch von Ida man versucht kryptografische Funktionen zu finden weil sie irgendwas mit Krypto machen und die zu identifizieren was das für ein Algorithmus ist ja also da gibt es einen ganzen Haufen Zeug zum Spielen Bookmarks also da in der Community-Dinger sind auch viele so Einsteiger Plugins drin also das ist auch ganz interessant wenn man irgendwie damit anfängt zum Lesen Biniatron ist auch ganz cool da kann man dann den Link zum oder zum GDB machen und da gibt es noch ein anderes Plug-in dann bohrt es den Binary Ninja auf zum Debugger also Binary Ninja selber hat keinen integrierten die Bugger so wie Ida das kann man damit dann nachrüsten genau da meine Demos alle nicht funktionieren würde ich jetzt an der Stelle einfach Schluss machen und euch wenn ihr irgendwie das anschauen wollt kriegt ihr das sicher auch hin ansonsten wie gesagt meldet euch bei mir gebe ich euch auch First Level Support am Anfang ok dann nochmal vielen Dank fürs Zuhören und eine schöne GPN noch