 So, ein Net-Williams-Folk zum Thema Chrome Interprozess-Kommunikation, wie man die angreifen kann, wie man aus der Sandbox ausbrechen kann, ja, geht eben genau um Sandbox Ausbrüche mit einer Fuzzing-Methode, um sich mal die Angriffsoberfläche von Chrome FSC genauer anzuschauen. Wie gesagt, wir werden Interprozess-Kommunikationen mit IPC abkürzen. Net hat sich mit Konsolen und Browser beschäftigt und zuletzt auch mit mobilen Geräten. Hallo zusammen, mein Name ist Net und heute rede ich über Chrome Interprozess-Kommunikation, und als ich diesen Talk geschrieben habe, hatte ich die Idee, dass man den etwas benutzbar für alle macht und die Idee war, dass ich erstmal sehr breit allgemein anfange und dann immer spezieller werde. Also am Ende wird es alles etwas technisch und für die, die das interessiert, dann würde es bestimmt alles noch sehr interessant sein und am Anfang machen wir das aber auch erstmal einfach für Neulänge. Kurzer Überblick zu mir, was mache ich so? Ich habe mich in den letzten Jahren hauptsächlich mit Sicherheitsforschung beschäftigt in Software und da vor allem ja irgendwelche kritischen Bugs in Software und setzlich gilt je kritischer die Software oder je weit verbreiteter die ist, desto interessanter für mich, wie dann noch ein bisschen Methodik, also wie macht man den Prozess zur Suche nach Fehlern effizienter, so dass man diese besonders exklusiven Fehler findet und was ich bisher so gearbeitet habe sind CTF, also Capture the Flag Wetbewerbe, dann 3DS, Chrome und jetzt habe ich auch gerade mit XNU angefangen, also dem OSX könne aber noch nicht so viel und ja bevor wir jetzt anfangen, würde ich vielleicht noch mal gerade zusammenfassen, was ich seit dem 33C3 gemacht habe. Vor zwei Jahren habe ich den Nintendo Hacking Talk auf diesen Kongress vorgestellt und da ging es um die 3DS und ja da gab es dann zwei Exploits, einer hier Sound Hacks, einer hier Fast Hacks und ja was ich da vielleicht noch zu sagen will ist, ja ich war selber ein bisschen überrascht, denn ich habe Google Analytics auf die Sound Hacks Webseite getan, weil ich habe gedacht vielleicht nutzen das so 1000 Leute oder so und ich habe auf die Seite geguckt und es haben tatsächlich 48000 Leute drauf geguckt und als ich dann nochmal YouTube angeschaut habe, wo Kopien da waren und ja was weiß ich, irgendwas mit Copyright, das ist mir egal, ja im Fall gab es ungefähr 1000 Leute oder User die das angeschaut haben und das war tatsächlich mal ein Interprojekt und was ich euch damit sagen will ist, ihr müsst jetzt nicht unbedingt irgendwelche Lücken in Chrome finden, um durchaus Aufmerksamkeit zu bekommen. Ich möchte auch noch kurz über die Spenden reden, ich hatte einen Spendenlink auf der Sound Hacks Webseite und wir haben glücklicherweise 1000 Dollar in Spenden empfangen, davon gegen 500 an die Leute den Emulator geschrieben haben, denn das war das Werkzeug mit dem ich den Exploits Sound Hacks geschrieben habe, das war das zentrale Werkzeug dafür und dann die anderen 500 Dollar sind an die Tourchain Entwickler gegangen, danke an alle die da gespendet haben, also gehen wir jetzt ans Eingemachte im Talk. Ich möchte jetzt vor allem auf den Backsuche Prozess schauen, nicht auf die tatsächliche Ausbeutung, also Exploitation von einem Back, denn ich denke das Thema Exploitation ist eigentlich relativ gut schon durchgespielt, aber das ist auch ganz typisch, also die Leute mit dem CTF Spiel machen, sind sehr gut im Exploiten, aber die Idee ist quasi, dass mehr Leute sich mit der eigentlichen Backsuche beschäftigen. Also die Agenda ist, dass man sich erst mal damit beschäftigt wie man überhaupt irgendein Ziel erreichen kann, dann strategieren zur Fehler Suche, also zur Back Suche, dann Fuzzing und zwar den Spezifischen Stil, den ich mir so ausgedacht habe und dann zuletzt, wie man das alles dann mit Chrome IPC verbindet. Um es auch nochmal zu erwähnen, also den Back, den ich hier zeige, der Back wurde in einem Fullchain-Exploit verwendet, also eine Kette von mehreren Backs, die dann einen Ausbruch ermöglicht und die ganze Kette wird an OffensiveCon besprochen, das ist auch eine Konferenz in Deutschland. Also wie wird man zum Experten in irgendwas eigentlich? Und da habe ich mir eigentlich während der CTF Phase, als ich angefangen habe, habe ich mich damit beschäftigt. Das ist im Prinzip, es ist einfach nur irgendeine Fähigkeit, die ich lernen möchte und ich möchte das jetzt systematisch angehen, schauen, wie kann ich mir das beibringen. Und da gibt es eben die Idee, in der populären Psychologie, dass man irgendwas etwa 10.000 Stunden lang wirklich eigenständig bearbeiten muss, praktisch bearbeiten muss und was bedeutet eigenständig oder deliberate in diesem Fall? Die Idee ist, dass man tatsächlich irgendein Sinn hinter dem Projekt hat, dass man gerade macht und dass es mich besser macht und es das Projekt besser wird. Und dann möchte man, dass man sich quasi immer an der Kante zu dem bringt, was man noch nicht wirklich kann, auch die ganze Zeit was Neues lernen kann. Und um sowas zu machen, dann braucht man eben irgendeine Möglichkeit, Erfolg oder Misserfolgsfeedback zu bekommen und die Problemstellung, die man sich so stellt, sollten halt schwierig sein, aber immer noch möglich. Und da haben die Projekte, die ich mir am Anfang rausgesucht habe, immer ganz gut gepasst, so dass sie zwar noch möglich waren, aber doch schon ziemlich nah an der Grenze. Es gibt diese Typen Ben Franklin, ihr kennt ihn vielleicht aus der amerikanischen Geschichte und er wollte besser lesen lernen und deswegen hat er einen Aufsatz genommen, der für ihn perfekt aussah. Deswegen hat er den Aufsatz gelesen, Notizen genommen, Notizen geschrieben und nach einer Woche den Aufsatz nochmal aufgeschrieben, basierend auf seinen Notizen. Und ja, dabei sind dann die ganzen Probleme in seinem Leseprozess aufgefallen. Und ja, man kann das eigentlich auch auf Backsuche anwenden. Ein anderes Ding war, dass man sich Ziele setzt zur Backsuche. Also, Fehler davon ist psychologisch als, ich glaube tatsächlich, dass das meiste mehr psychologisch ist als dass es irgendwas mit konkreter Intelligenz oder so zu tun hat. Und es geht im Prinzip einfach darum, die Toleranzgrenze für Fehler immer weiter nach oben zu schieben. Und ja, als ich mich mit Chrome beschäftigt habe, habe ich da tatsächlich immer sechs Monate lang mit beschäftigt. Also immer von der Arbeit nach Hause gekommen, dann bis 1.00 Uhr noch dran gearbeitet und natürlich das ganze Wochenende lang. Und ja, ich habe dann lange, lange nichts gefunden und dann irgendwann schon. Und ja, als ich dann eben diesen Back gefunden habe, dann war mir auf einmal klar, dass die notwendigen Fähigkeiten in der Backsuche langsam da sind und ich das jetzt wieder anwenden kann. So, wie wird man dann jetzt ein Experte konkret bei der Backsuche? Wenn man sich die Fähigkeiten anschaut, die man braucht, dann glaube ich, das sind zwei Stück. Einmal, dass man weiß, wo man suchen muss und dann, dass man den Back erkennt, wenn er vor allem ist. Das Erste von meiner Erfahrung her ist relativ einfach. Gerade wenn man Entwickler ist, dann kann man zum Beispiel an die Gitlocks, also an die Versionshistorie schauen, um rauszufinden, wo Fehler sein könnten. Man kann vorherige Backreports anschauen und einfach nach generell der Codequalität schauen. Aber was deutlich schwieriger ist, an den konkreten Fehler zu finden? Ich habe das, ich habe diese Idee vom Training, wo man, wenn man ein Ziel im Kopf hat, wo man dann denkt, dass es machbar ist und man durch alle Backreports durchschaut und dann schaut man sich an, kann man damit was machen? Da wird es viele, da wird ein langer Text sein und sagen, was passiert. Man kann darüber fliegen und schauen, wo der Back eigentlich ist. Und dann schaut man sich den Code an und versucht, sich den Back selber zu finden. Es ist wichtig, dass man den Back selber findet und es wirklich damit kämpft, bis man ihn tatsächlich findet. Durch diesen Kampf kriegt man dann mit, was war das Ding, was mir gefehlt hat, um diesen Back zu finden. Wenn man das immer wieder macht, dann ist das, wie man sich darauf trainiert. So habe ich angefangen Back zu suchen. Ich erinnere mich an diesen Blog-Post von Gerald. Ich habe mir gedacht, wow, wie hat das jemand gemacht? Es hat jemand eider geöffnet und geschaut, was für Sicherheitslücken da drin sind. Und da habe ich mir gefragt, wie könnte ich das getan haben? Wie kann ich das üben? Das waren alles Integer-Overflow-Bugs. Ich wusste, was Integer-Overflow war, aber ich habe nie danach gesucht. Und ich habe nie Funktion geschaut und habe es nicht gesehen. Ich bin schlafen gegangen und habe gedacht, ich werde das nie schaffen. Am nächsten Tag bin ich aufgewacht und habe es gesehen. Das war eigentlich relativ einfach. Dann habe ich beim zweiten Tag noch mehr gesehen und am dritten Tag wusste ich immer, wo ich hinschauen musste. Dann habe ich gedacht, das mache ich einfach weiter und immer schwerere Sachen. Das ist quasi die Strategie, diesbezüglich. Ich denke, ich bin das perfekte Beispiel dafür, dass jemand so ein fortgeschrittener CTF-Spieler war. Aber ich hatte nicht wirklich eine Idee, was ich tun soll. Und ich habe gedacht, wenn ich immer an diesen Prozess glaube, dann klappt er hoffentlich. Und das ist so eine kleine Anleitung, wie man das vielleicht tun könnte, falls ihr das machen möchte. Also am Anfang schaut ihr euch CTF-Bineries an. Das ist perfektes Training. Es gibt meistens ein Write-up, also etwas, was beschreibt, wie man es dann tatsächlich gelöst. Da kriegt man ganz viele Low-Level-Details raus, man weiß, was ein Bug ist. Und von dort aus geht man dann immer zu schwereren Tags, zu schwereren Zielen. Das Problem ist, man kriegt nicht so selber einschätzen, wie gut man daran ist. Es sieht bloß so aus für mich, wo man ... Es ist hier nicht so wie in Schach, wo man Leute hat, die schon seit Jahrzehnten daran arbeiten, seit ihrer Geburt. Es gibt hier definitiv Platz für neue Leute, die auch teilnehmen können. Es gibt immer mal wieder Geschichten über Leute, die unglaublich talentiert sind oder so. Und ich schaue mir häufig an, wo was in diesen Geschichten drin war. Und ich habe immer gesehen, diese Leute haben immer sehr hart gearbeitet. Ich überspringe jetzt mal ein paar Slides, mal gucken, vielleicht schauen wir uns das später nochmal an. Lass uns jetzt über Fuzzing reden. Ich denke, ihr soll wirklich wissen, wie man sich Code anschaut. Und ich denke am Anfang habe ich eigentlich für mich nur die ganze Zeit Code angeschaut. Für Fuzzing gibt es eine schlechte Ruf, weil Leute machen das einfach und kriegen Dinge raus. Sie funktionieren relativ gut zusammen mit ... Fuzzing kann fehlschlagen, aber dann weiß man nicht unbedingt, warum. Bei Auditing kann man Dinge besser herausfinden. In Chrome gibt es so viele verschiedene Dinge, da kriegt man beim Auditing gar nicht durch alles durch. Es gibt so viele Dinge da drin, da es ist vielleicht einfach schneller zu fuzzen, als sich den Code anzuschauen. Ich habe einfach zufällige Code mir angeschaut und es hat tatsächlich funktioniert. Also, wie macht man Fuzzing denn? Das ist ein Prinzip, wie übt man das? Das ist ein Prinzip, das selber wie beim Auditing. Man muss sich halt irgendwie fragen, wie hätte ich denn ein Fuzzer geschrieben, um den Fehler zu finden, den schon mal jemand anders gefunden hat. Wie hätte ich mir das beibringen können? Also, fehlt mir vielleicht noch irgendwie das Wissen über Auditing, dass ich einfach den Fuzzer noch nicht hätte schreiben können. Es fehlen mehr spezifische Fähigkeiten, um den Fuzzercode zu schreiben. Das ist nicht so ganz einfach, aber man sollte da durchaus reflektieren. Es erscheint später nochmal an, aber dieses spezifische Fuzzing war sehr wichtig, um den spezifischen Sandbox-Ausbruch zu finden, den ich gleich vorstelle. Und diejenigen von euch, die das jetzt gar nicht kennen, es gibt so ein Programm, das AFL heißt. Es ist 2014 rausgekommen und das hat, glaube ich, was tatsächlich ein Meilenstein für Fuzzing. Die Idee ist, dass man einen AFL, einen Corpus von Eingaben gibt, den man als Grundlage zum Fuzzen nimmt und dann füttert man AFL konstant mit Coverage Reports, also Code-Abdeckungsreports, also was der Input an Code durchlaufen lassen hat. Und AFL mutiert daraufhin die Eingabe und das funktioniert alles ziemlich gut. Es gibt dann auch noch eine andere Variante davon, nämlich LIP Fuzzer. Das wird vom LVM-Projekt geschrieben und das sind die gleichen Leute, die Address-Sonetizer geschrieben haben. Also es ist ein Feature von LVM. Und ja, die Art und Weise, wie LIP Fuzzer geschrieben wurde, ist so ein bisschen einfacher zu verstehen, zumindest meine Meinung. Also wenn man sich das nochmal klarmachen möchte, was Fuzzing ist, dann repliziert man im Prinzip den normalen Testprozess, aber parametriert, was ein normaler Unitest machen würde. Also in einem Unitest hat man einen ganz spezifischen Testcase und beim Fuzzing schaut man einfach, ob, wenn man ein bisschen an der Eingabe wackelt, das Programm crashed. Und ja, der Fuzzer generiert im Prinzip dann automatisch Unitests, kann man sich so vorstellen. Und ja, die Sache ist halt, dass viele Leute denken, dass Attacken irgendwie sehr systematisch passieren müssen, aber in Wirklichkeit ist es so, dass wenn man einige Komponenten findet, die komisch aussehen, wo man denkt, da könnte ein Lücke sein, dann kann man die tatsächlich mal irgendwie in ein bisschen Kombination betrachten, wie die zusammengesteckt wurden und dann findet man raus, ob da ein Back ist oder nicht. So, die Idee ist dann, dass man generiertes Fuzzing mit automatischem Fuzzing kombiniert, kommen wir gleich nochmal drauf. Ich bin natürlich nicht die einzige Person, die sowohl die Fuzzing macht, sondern ich und noch zwei andere Personen sind mehr oder weniger gleichzeitig auf die Idee gekommen, Chrome anzuschauen und da gibt es Syscaller und Lokihardt. Syscaller ist ein automatischer Linnungskörner Fuzzer, das ist ziemlich cool. Die generieren im Prinzip automatisch Zero Days im Zehnerschritt pro Monat und ihr Konzept ist, dass sie automatisch den Testcase generieren, dann den Backreports abmitteln und im Prinzip können Sie sich so vorstellen wie ein Zero Day Generator, aber es ist tatsächlich so, also die haben mehr als 3000 Bugs gefunden, es gibt sogar eine Web App dafür und ich habe den Linux Talk von dem Autoren von Syscaller angeschaut und das ist definitiv etwas unterschätzt, schaut euch das an. Und dann gibt es auch noch Lokihardt, das ist ein ziemlich bekannter und sehr, ja, also das ist ein sehr, sehr bekannter und sehr, sehr ausgefeilter Fuzzer und er findet damit über 40 Fehler in Chakra, das ist die Edge JavaScript Engine und V8, das ist die Chrome JavaScript Engine und dann geht es noch nicht und ich habe halt auch wieder Fuzzing verwendet und über 30 Bugs in Chrome gefunden, fünf von denen waren tatsächlich sicherheitskritisch und dann gab es noch welche, die zumindest Codexecution gefunden haben. Und ja, das ist tatsächlich halt einfach eine wichtige Technik, wir finden viele wichtige Fehler mit dieser Technik, die wir vorher nicht gefunden haben und ja, also das wird im Chrome Security Team verwendet, um SQLite zu finden und ja, hier noch ein bisschen mehr Beweismaterial von, ja hier sieht man die verschiedenen Bugs, die ich mit dieser Strategie gefunden habe und ja, um vielleicht drei von denen mal genauer anzuschauen, der erste war ein Out of Bones Read, also wo wir außerhalb der Grenzen von Ameri gelesen haben und dieser Bug hat es ermöglicht, dass man aus einem Blob einen Teil gelesen hat, dann war es möglich, dass ein Integer Overflow auftritt und dann im Prinzip zufällig Speicher aus dem Browserprozess gelegt werden konnte. Dann gab es AppCache URF, das war in dem exploit, den ich gleich noch vorstelle, verwendet und dann bei den kritischen Bugs, die rot sind, das waren die ersten beiden, die waren in Quick und der erste ist ein Stack Buffer Overflow mit einem schlechten Paket, das aus dem Internet kommt und das heißt, das kann eine Seite im Internet einfach ausnutzen und damit aus der Sandbox ausbrechen. Und dann gab es noch, also da konnte sogar um die Stack Cookies zum Rum gearbeitet werden und dann war noch der andere, der Block Cache Problems, das auch im privilegierten Prozess war und das ist tatsächlich da draußen schon seit drei Jahren gecrasht und ich weiß nicht, ob die vielleicht einfach nicht die Ressourcen hatten, um das Problem zu behandeln, aber als ich ihnen dann eben den Test Case geschrieben habe, dann konnten sie tatsächlich auch damit drei ziemlich alte Bugs zu diesem Thema schließen und diese Technik, also die Grundmessage hier ist, diese Technik funktioniert wirklich in sehr wichtigen Bereichen, sehr, sehr häufig. Schauen wir uns den langweiligen Teil an. Nun ja, was ist Protobuf? Protobuf ist ein Datenserialisierungsformat. Es ist nicht besonders wichtig, dass Protobuf ist. Es ist einfach nur irgendeine Sprache. Wenn ihr irgendeine Sprache für euch programmieren wollt, dann wenn ihr irgendwas höheres fassen wollt, dann fast einfach Bites. Wenn ihr höhere Abstreichstumsebene fassen möchtet, dann könnt ihr Quick Check zum Beispiel benutzen. Das habe ich in Okamel benutzt. Man baut sich einfach eine Baumstruktur mit grundlegenden Typen wie Bool oder Intention und dann gibt man es dem Fuzzer. Und was diese Bibliothek dann machen würde, ist, dass sie diese Bäume generieren wird und dann generiert es einfach irgendwelche zufälligen Bäume, Sintagsbäume von der gegebenen Sprache. Man kann das sehr gut generieren, dann sehr strukturiertes Input generieren und dadurch viele Bugs finden. Ich möchte nur hoher Beton, dass das benutzt werden kann, um irgendwas zu fassen. Fast die gleiche Idee wird benutzt, um in anderen Dingen zu Bugs zu finden, wie Kernel, Sandbox, Internet, Inter Process Communication, Netzwerkzugriff usw. Was die alle gemeinsam haben, ist eigentlich bloß, wir fassen alle auf die gleiche Art und Weise. Als Auditor würde man einfach sich ein Subsystem anschauen, z.B. ein Caching Mechanismus mit einer einfachen API. Und wenn ich jetzt ein Fuzzer dafür schreiben kann, dann ist das einfach. Sobald man die API ein bisschen versteht, dann kann man einfach diese kleinen Spezifikationen schreiben und man kriegt so einen Fuzzer. Die Idee ist, ich zeige euch jetzt, wie das mit Chrome funktioniert. Nur damit ich wirklich alles hier sage, insbesondere über die Hintergrundinformation. Hoffentlich kann ich euch ein bisschen was über Chrome IPC sagen. Die grundlegende Idee ist für das Chrome Sandboxing. Wenn ich sage, dass ich Bugs in der Sandbox finde, dann sind das Bugs in Browser-Prozess, die wir von der Sandbox aus erreichen können. Die Sandbox selber schränkt uns einfach bloß ein in dem Render-Prozess. Wir können nicht zu viel machen, nicht allzu viel. Und wir wollen gerne von dort zurück in den Browser-Prozess springen, der viel mehr tun kann. Das ist ein relativ einfaches Modell, ich meine ein relativ übliches Modell, das man z.B. auf den DS oder so wieder findet oder im Linux-Körnel. Es gibt halt Syscalls, die man ausführen kann und die man nicht ausführen kann. Es gibt normalerweise eine API von dem weniger privilegierten Kontext, die man benutzen kann und dann bricht man da aus und hat den höher privilegierten Kontext. In Linux gibt es mehrere hundert Syscalls, aber vielleicht können wir uns bloß zehn zusammenhängen Syscalls oder so anschauen, das wäre dann so ein Subsystem. Das ist dann, wie man darüber nachdenkt. Zum Beispiel, wenn ihr einfach loslegen wollt mit Chrome, was ihr, dann ist das, was ihr tun wollt, am besten solche Entry Points, solche Eingangspunkte im Browser anzuschauen. Man braucht nicht genau verstehen, wie IPC, man braucht nicht genau verstehen, wie IPC funktioniert, aber man sieht halt, was man erlaubt ist, von dem Renderer aus aufzurufen. Das Gute ist, der Code ist einigermaßen so organisiert, dass man das sehen kann. Die meisten Bugs, die ich gefunden habe, waren in dem Content Browser-Subsystem, aber man kann eigentlich überall schauen und all die Resultate, die ich bekommen habe, waren eigentlich alle im gleichen Ordner. Es gibt so viele andere Orte, wo es Bugs geben kann, die ich mir nicht mal angeschaut habe. Einfach mal umzuschauen, was ich gemacht habe, also in dem Inhalts-Content-Stuff. Wir schauen uns einfach an, was für APIs, wo die APIs aufgezählt sind, die man vom Renderer aus aufrufen kann. Das C++ hier, ihr müsst euch dran gewöhnen, es gibt hier zwei Wege, die die APIs aufgesetzt werden können. Das ist einmal Create Message Filters, also, und ein anderes. Es hat mich ein bisschen gebraucht, bis ich das verstanden habe, dass ich gerade diese Funktionen mehr anschauen muss. Wir springen hier mal aus, bezüglich IPC, aber das ist relativ einfach, wenn ihr euch das anschaut. Ich möchte noch ein bisschen über Mojo reden. Mojo ist ein neues IPC-Ding, eine Plattform für IPC, welches die Chrome-Leute gebaut haben. Sie wollen diesen Prozess vereinfachen, mit dem sie Dinge, dem Renderer gegenüber offenbaren. Die Idee ist, dass man dieses Mojo Zeug schreibt, und dann wird das Bildsystem für euch den C++ Code generieren. All die technischen Details werden dann von dem Generator gebaut. Das heißt, als Sicherheitsforscher ist mir das eigentlich alles egal. Ich will eigentlich bloß wissen, wo kann ich denn all das sehen, was exposed wird. Und dann schaue ich da durch. Ihr könnt auch einfach durchgreppen. Der AppCache war etwas, was ich dieses Jahr gefunden habe. Hier ist die API, die der Renderer auf die die Renderer zugriff hat. Und das sind all die Nachrichten, die er senden kann mit allen Typen. Das ist relativ klar. Im Browserprozess, welcher der Prozess ist, den wir angreifen wollen, da sieht man hier eine Unterklasse, wo all die virtuellen Methoden überschrieben sind. Ich werde jetzt mal nicht zu detailliert werden, weil es ein bisschen langweilig ist. Aber wie kommt der Renderer zum C++ Code des Browsers? Naja, es geht durch diesen Anfragemechanismus, wo der Renderer fragt, den Browserprozess fragt, ich möchte gerne das und das tun. Und es wird dann das Dispatch Host Implementation Object erstellen. Dort wird dann der Request reingetan. Und das wird dann alles irgendwie zusammengeklebt. Und dann, ihr wisst schon, gibt es irgendwie dieses Zeug, was ein bisschen eklig ist. Man gibt den Leuten die Möglichkeit, so was tatsächlich zu tun. Hier seht ihr so eine Funktion, die so eine Anfrage behandelt. Es ist relativ klar benannt, Request-Händler. Sie fügen die ganze Zeit neue Zeug hinzu. Ich habe eine Weile nicht reingeschaut, und dann gab es schon wieder fünf neue APIs. Also, kurz. Noch ein kleiner Hinweis dazu. Ihr möchtet halt im Prozess Phasen mit dieser LibPhaser und Protopov-Mutator-Strategie nicht überall PC. Das ist alles ein bisschen wackelig und komisch. Also, ihr fasst einfach in dem Prozess selber. Hier ist ein C++-Objekt, instanziert das Ruf-Typ-Funktionen auf. Und dann ist das halt alles ziemlich leichtgewichtig und einfach damit herumzuspielen. Generell gilt, wenn man einen einfachen Reproducer hat, dann macht das Literationszyklen einfacher und Literationszyklen kürzer. Das kann ich euch nur raten. Ihr müsst einfach wissen, der Phaser, den ich open-source habe, ist so, wie man das machen sollte. Aber der Weg, wie ich es tatsächlich gemacht habe, ist immer wieder irgendwelche Sachen auskommentiert, irgendwelche Private-Sachen. Ich habe das Objekt dann erstellt, Sachen aufgerufen und so weiter. Das ist alles ein bisschen anfängermäßig. Aber ja, so war das. Um das jetzt nochmal alles zusammenzufassen, was ich bis jetzt gemacht habe, dieser exploit, den ich gefunden habe, nämlich AppCache über F hat im Prinzip dieses Prinzip von starker Praxis, viel Übung usw. angewendet. Was habe ich so gefunden? Ich habe drei Fehler gefunden, die memory-corruption verursacht haben, also irgendwelche Speichermannpolizeien nicht hätten passieren sollten. Ich hatte diese Fehler tatsächlich schon eine ganze Zeit vorher gefunden. Und das Phasing tatsächlich einfach gut funktioniert und man eigentlich Auditierung gar nicht so sehr braucht. Aber dann habe ich es mir doch nochmal angeschaut. Und was so interessant daran ist, ist, dass es eigentlich ziemlich interessant ist, dass man einfach eine AP definiert von IPC Nachrichten da reintut. Und deswegen habe ich nicht wirklich verstanden, wieso man das nicht machen sollte. Aber dann gibt es eben noch so Geschichten, wie weit entfernt das Server, so wie AppCache, wo man dann eben irgendeine Anfrage an den Server stellt und dann antwortet das Server irgendwann an der Macht AppCache irgendwas. Und da wurde es auf einmal wichtig, wie das Timing bei der ganzen Sache war. Die Sachen bleiben zum Beispiel noch am Leben. Dann wird eine Verbindung gestoßen und dann hat man einen Pointer, der noch am Leben ist und so. Also, es ist einfach, das Timing ist da wichtig. Und das Letzte ist noch so ein logisches Problem. Wenn das Server zum Beispiel HTTP Codes zurückgibt in den Headern von der HTTP Antwort, dann kann man tatsächlich logische Fehler triggern, die dann zu Speicherkorruption führen. Und da habe ich mich eben gefragt, was müssen wir denn eigentlich testen, um diese ganzen Sachen auch abzudecken. Und da kam es zu der Antwort des IPC-Netzwerk und Timing und das Ganze hat inherenten Zustand. Und das bedeutet, dass wir für jede Phasing-Sitzung diesen gesamten Zustand komplett zurücksetzen. Also in C++ ist es jetzt nicht so super schwer, man kann einfach das Objekt löschen und dann wieder Neues erstellen, das ist alles gut. Und man muss einfach aufpassen, dass nichts irgendwie rumfliegt. Und das Konzept heißt dann eben, dass man zufällige IPC-Eingaben generiert und zufällige Netzwerkeigenschaften simuliert. Und Teil von dem Ansatz war auch, dass ich dann vielleicht einfach dieser alten Box nutzen kann. Und das findet man auch relativ häufig. Ich hätte jetzt einen Faser schreiben können, der dieser alten Fehler triggern kann und vielleicht finde ich damit auch einfach neue Fehler. Was dann natürlich etwas schwierig daran ist, ist, dass wenn man jetzt einfach nur zufällige Daten aus dem Netzwerk zurückgibt, dann macht man da nicht wirklich schnell einen Fortschritt. Und das ist, wo das Auditing wichtig wird. Also das Verständnis vom Code. Muss ich überlegen, was ist ausdruchsstark genug? Also wie erzähle ich dem Faser? Wie gebe ich dem genug Informationen, dass er tatsächlich ziemlich viel, ziemlich viel gut und schnell treffen kann. Aber das ist nicht generisch, nicht so generisch mache, dass eben nichts mehr findet. Und ja, das kann man dann hier in diesem Protobuf Beispiel sehen. Hier sehen wir diesen Wurzelknoten in diesem Sonntagsbaum. Und da sieht man dann eben diesen Sessionknoten. Und der enthält eine Sequenz von Kommandos. Und ja, ein Kommando kann dann eben die ganzen verschiedenen LPC-Codes sein, die man so machen kann. Der Elfte ist ein bereits bestehenden Request behandeln. Und das behandelt sowohl den Asynchronenfall als auch den Synchronenfall, wo die Antwort direkt kommt. Und dann gibt es noch dieses Run into Idle Ding, dass man zufällig in irgendwelche Idle-Zustände kommt, wenn man diese Nachrichten behandelt und was das hilft ist, dass man hiermit tatsächlich diese Race-Conditions triggern kann. Denn man kann zum relativ viel IPC auf einmal machen, obwohl man noch gar keine Arbeit verrichtet, dann effektiv, halt mit diesen Idle-IPCs. Und damit kann man das Timing beeinflussen. Ich habe da jetzt nicht irgendwie vorher drüber nachgedacht, sondern ich habe mir die Unitests angeschaut und irgendwie überlegt, wie testen die Entwickler denn das jetzt schon, das ganze Timing. Und das haben sie halt da eben gemacht. Diese Nachrichten sind ziemlich einfach zu schreiben. Ihr müsst im Prinzip einfach für jede IPC-Nachricht, die man dem Timing wirklich teilweise schreiben könnte, die ganzen Argumente spezifizieren, schauen, dass das korrekt ist. Und dann gibt es ein bisschen cleverness an der Stelle. Zum Beispiel die Host ID ist 012. Und wenn man jetzt hier Host die ganze Zeit erstellt, über die ganzen vier Billionen IDs, dann wäre das nicht so interessant. Das heißt, wir schränken das quasi künstlich ein auf 012. Und für die URL ist das auch zum Beispiel eine Nachricht, die ich auch künstlich eingeschränkt habe. So dass der Fuzzer nicht den ganzen URL-Parsing-Code testet, weil das jetzt wahrscheinlich eher langweilig gewesen wäre. Und wie habe ich mich dann um das Netzwerk gekümmert? Ich habe im Prinzip einfach durch den Quellcode durchgelesen. Und dann hat der PR Response Codes durchgeschaut, die den Kontrollfluss beeinflussen. Und im Prinzip ist das so, dass für jeden Request der vom AppCache-Subsystem reinkommt, habe ich im Prinzip einfach codiert, welchen wirklichen Antworten es geben könnte. Und die Sache mit diesen HTTP-Codes ist, dass man da unterscheiden muss, ob AppCache benutzt werden sollte oder nicht. Außerdem kann AppCache vom Server anfragen, ob es ein Manifest-File, mein Manifest gibt. Und in dem steht dann drinnen, was es alles caching soll. Und im Prinzip ist das einfach alles in einer Nachricht codiert. Und wie geht man dann von hier aus vor, also von dieser High-Level-Beschreibung zu konkretem Fuzzing? Ich habe mir einfach die Unit-Codes angeschaut und gesehen, wie sie diesen AppCache-Service aufgesetzt haben. Und sie lassen einem eben diese URL-Loader-Factory-Objekt reingeben. Und das ist im Prinzip ein... ...ein... naja, es müsste schwer zu beschreiben. Also es ist halt so ein Helfer für Unit-Tests. Und das ist die Möglichkeit, um Netzwerkanfragen für die Unit-Tests abzufangen. Und dann gibt es eben genau... dieses Schema hier, mit dem man die Interaktion zwischen Renderer und Browser nachstellen kann. Also man zieht einfach die Host-ID aus der Protobuf-Nachricht und die finden wir da oben, ganz weit oben. Und dann gehen wir da einfach durch und hoffen die APIs auf, die es bereits schon gab. Wie kriegt man uns das Netzwerkzeug zum Laufen? Wir haben diesen... also wir haben diese Mock-URL-Loader-Factory, das ist jetzt alles ein bisschen sehr zu flusspräzifisch, aber stellt euch einfach vor, es ist ein Mock-Objekt. Und ja, das hier ist dann eben genau die Stelle, wo ich eine von diesen Anfragen, die ich über diese gestellte Setup-Stelle beantworte. Das ist eine Unit-Tests-Funktion, die sie in ihrem Code haben und im Prinzip gebe ich einfach die Informationen in die... Ja. Dann schauen wir uns diese Halber-Funktion an. Das gibt es einfach weiter. Und das gibt dann einfach Antworten an alles, was wartet. DD, hier ist... das ist Synchron. Das heißt, wenn man host registriert, cash registriert, dann wird der App-Cache ein Request zum Server machen, dann holt er sich das Manifest vom Server und dann gibt es halt Dinge, die noch auf Antworten warten vom Server. Es war tatsächlich wichtig, dass man den Status ändert, bevor die Antworten kommen. Das heißt, dadurch, dass ich die Network-Factory überlade mit den Nachrichten direkt, dann ändert es tatsächlich, was die Idee hier ist, dass man das auswirrt und das sind 150 Teilen von Code oder so und dann kriegt man den Back im Address-Sanitizer, dann passiert News After Free, was hier passiert ist, den Destruktor sieht und es stellt sich heraus, dass, wenn man ein unregistered host aufruft, das ist so eine IPC-Nachricht, dann macht das aus Versehen, das ist ein inakturater Stack Trace, aber da gibt es eine Reft-Count, die von 1 auf 0 geht und dann wird das destruktet, also zerstört und dann passiert im Destruktor etwas, nämlich dass es auf den Antworten des Servers wartet. Also weil das auf die Antwort des Servers wartet, und dadurch wird die Reft-Count wieder auf 1 hochgesetzt und dann hat man überall Referenzen auf etwas, was so halb zerstört ist. Das heißt, wir haben irgendwelche Punkte zu zerstörten Objekten, wir können später wieder auf dieses zerstörte Objekt zugreifen und das ist quasi ein Rezept für so eine Artback. Ich möchte noch mal bemerken, dass dieser Fuzzer open-source ist. Das heißt, wenn ihr nach Code sucht online, dann könnt ihr einfach App-Cache-Fuzzer googeln und findet das. Nur noch ganz schnell, um zu erklären, wie der exploit funktioniert hat. Ich habe das in der Kette mit zwei anderen Leuten gemacht. Und damit haben wir, also wir haben ein RCE-Back, ein Remote Code Execution Back, dann können wir Code im Renderer ausführen und dann ist es ein bisschen hart mit Mojo beliebige Nachrichten, deswegen haben wir dafür einen anderen Weg gefunden. Und dann haben wir am Ende ein Deckref, also ein Verringer der Reference-Count, und nachdem das mehrere Male gefreet worden ist, dann gibt es zwei Stufen, das zu exploiten. Wir haben Back im Renderer, aber da brauchen wir noch ein Read aus dem Speicher, aber glücklicherweise können wir das mehrfach ausführen, diesen Back. Wenn man wieder auf 0 kommt, dann triggert man wieder den Destruktor. Wichtig ist, dass man hierfür nicht den Destruktor triggert, weil das wird einfach crashen. Die Idee ist, dass wir irgendwie ein String haben, der irgendwo im Speicher liegt, und damit können wir dann Hip-Daten liegen. Es hat auf einer Plattform String, als erstes Mitglied, das ist irgendeiner Art Cookie-Objekt, und das können wir aus dem Browser lesen. Und von dort aus konnten wir ein V-Table anschauen und wir können ein gefälsches Objekt bauen, was so aussieht, wie das Richtige, aber dann haben wir auf diese Art und Weise dafür gesagt, dass der Appcache unseren Code called, und dann machen wir ein paar von diesen Dingen zusammen und dann kriegen wir irgendwie Code execution. Nur so als Zusammenfassung, was ihr machen wollt, ist immer wieder üben, und schauen, dass ihr das absichtlich macht und bewusst, und dass ihr diesen neuen Lip-Fuzzern benutzen könnt. Ich verspreche euch, dass es nicht das letzte Mal sein wird, dass es euch jemand empfiehlt. Ich habe auch noch etwas damit gemacht, und ja, es funktioniert. Ihr werdet bald darüber was sehen. Und auch ganz wichtig, gebt nie auf, dass es besonders wichtig ist. Damit können wir jetzt zu den Fragen übergehen. Wenn ihr eine Frage habt, dann geht es zu den Mikrofonen im Raum. Wenn ihr den Raum verlassen wollt, dann macht es bitte so leid, wie möglich. Falls ihr im Stream zu hört, könnt ihr eure Frage online stellen. Es sieht so aus, als, ah, doch, da gibt es noch eine Frage. Ich wollte fragen, warum hast du Chrome ausgesucht für die Backsuche? War es bloß irgendein zufälliger Browser, oder warum? Ja, also, im Prinzip, Chrome ist irgendwie so das, die harte Sinus, die man knacken kann. Also, das war einfach was, an dem man dann auch persönlich wachsen kann, wenn man da was tatsächlich knacken kann. Und die Art und Weise, wie Chrome geschrieben ist, ist ziemlich hilfreich zur Forschung. Und außerdem kannte ich kein C++, bevor ich damit angefangen habe. Und das heißt, wenn man auf ziemlich, also Chrome ist ein ziemlich hochqualitiver C++-Code, und ich habe dann am Anfang erst mal so ein paar komische Library-Wachst gefunden, die tatsächlich nicht erreichbar waren. Aber ja, also, die Chrome ist einfach eine sehr gute Code-Base, an der man auch persönlich wachsen kann, weil es einfach sehr viel quadrativ hochwertigen Code enthält. Und diese zwei Jahre, die ich jetzt in dieses Projekt investiert habe, haben mir einfach geholfen, deutlich besser zu werden. Eine Frage aus dem Internet. Ist es möglich, Chrome IPC über Hardware-Verwundbarkeit wie Spectral zu anzugreffen? Ja, also, ich weiß es nicht. Vielleicht ist es möglich. Ich habe mich jetzt nur auf Anwendungs-Level-Bugs bezogen, also Sachen, die ich deterministisch triggern konnte. Es sind nur Bugs im Chrome-Code. Ja, es sind nur im Chrome-Code. Und diese ganzen Bugs, also Meltdown-Inspector und so, kamen deutlich später raus, also nachdem ich meine Forschung gemacht habe. Danke für Ihre Gespräche. Danke für Q&A. Okay, damit verabschieden sich auch aus der Übersetze-Kabine. Auf Problem.