In Ordnung, Leute.
Willkommen zurück.
Eine Sache, über die wir bisher noch nicht gesprochen haben, ist der empathische kommerzielle Angriff innerhalb eines Kondomanbieters.
Und dann sind wir mit unseren Inhaltsanbietern fertig.
Wir haben also eine SQL-Injektion gesehen, und jetzt fehlt nur noch ein Angriff mit Impact Traversal.
In dieser Woche werden wir also herausfinden, wie man dies ausnutzen kann und
vor allem, wie man diese Art von Angriff in einer mobilen Anwendung erkennt.
Sind Sie so aufgeregt? So
wie ich im Moment?
Dann lass uns gehen.
In Ordnung, hier sind wir wieder bei Ubuntu VM und ich habe
eine wirklich nette Anwendung vorbereitet, mit der wir diese Path-Traversal-Schwachstelle trainieren können.
Sie finden diese also wie immer als Anhang zu diesem Abschnitt.
Und ja, ich habe den gesamten Quellcode beigefügt.
Also laden wir es einfach herunter, importieren es in das Android Studio und schauen uns das an.
Also gut.
Ich habe es also bereits heruntergeladen.
Deshalb brauche ich nur damit zu beginnen.
Ich starte also das Android-Studio und führe das Bash-Studio-Stage-Skript aus.
Jetzt geht's los.
Gut, hier haben wir den Hauptbildschirm, den Willkommensbildschirm.
Um dieses Projekt zu importieren, brauchen wir nur auf Projekt importieren
zu klicken, und schon wählen wir diesen fantastischen Musikplayer aus.
APK Also los geht's.
Ja.
Lassen Sie uns ausreden.
Oh, es ist schon fertig.
Sehr schön.
Nein, nein.
Tipp des Tages.
Okay, das erste, was ich bei der Analyse einer mobilen Anwendung gerne mache, ist ein Blick
in das Manifest, weil wir dann einen guten Überblick darüber bekommen, was vor sich geht.
Also machen wir dieses Android-Manifest und hier haben wir es, damit
wir sehen können, dass wir eine Berechtigungsrate für externen Speicher verwenden.
Also gut.
Das ist etwas, wonach wir suchen müssen.
Dann haben wir unsere Anwendungstechnik, nichts allzu Ausgefallenes hier drin.
Und dann haben wir einen Anbieter bekommen.
Hier haben wir also den Content-Provider und dieser wird in dieser Klasse definiert.
In Ordnung, hier haben wir den Namen der Behörde aktiviert, exportieren Sie ihn durch.
Also gut.
Dieser Inhaltsanbieter wurde also durch exportiert.
Dieser Content Provider ist also für die Außenwelt verfügbar, was bedeutet, dass wir mit
ihm auf der Grundlage einer anderen Anwendung oder innerhalb der ADB-Shell interagieren können.
Also gut.
Wir wissen im Moment nicht, ob wir mit der Datenbank oder mit einigen Dateien interagieren.
Wir werden dies herausfinden, indem wir den Code innerhalb dieser Java-Klasse analysieren.
Aber für den Moment wollen wir es dabei belassen.
Wir wissen also, dass wir einen Inhaltsanbieter haben und dass er exportiert wird.
Dann haben wir eine Aktivität, unsere Hauptaktivität, unseren bekannten Inhaltsfilter.
Dies ist also unser Einstiegspunkt.
Es wartet darauf, dass wir auf das Symbol klicken, um loszulegen, und dann landen wir dort.
Also gut.
So weit, so gut.
Bevor wir diesen Code weiter analysieren, würde ich vorschlagen, dass wir einen Blick auf diese
Anwendung werfen, denn ich habe das Gefühl, dass diese Anwendung nicht wirklich toll ist.
Schauen wir also mal.
Wir haben unseren Emulator.
Ich habe bereits damit begonnen.
Und um diese Anwendung zu installieren, müssen wir nur auf dieses Symbol klicken.
Drücken Sie dort eine Taste.
Machen wir es so.
Und lassen Sie uns das hier festhalten.
OC Degradable wird nun im Hintergrund ausgeführt.
Anschließend wird die Anwendung erstellt und über ADB
auf das Smartphone übertragen und automatisch gestartet.
All dies geschieht also auf magische Weise im Hintergrund und.
Das war's.
Das sieht absolut fantastisch aus.
Ja.
Nein, das tut es nicht.
Aber wir wollen sehen, ob die Funktionalität gegeben ist, denn das ist der wichtigste Punkt.
Richtig.
Drehen wir also die Lautstärke auf, und zwar die maximale Lautstärke.
Wir haben also einen Musikplayer, und es gibt Tasten für Play und Stop.
Schauen wir also mal.
Ich kann nichts hören.
Nein.
Ja.
Dies ist eine absolut entspannende Musik, ideal für die Überprüfung
von Bewerbungen, die auf einem Pfad der Verletzlichkeit basieren.
Absolut erstaunlich.
Daher möchte ich dem Autor oder dem Musiker wirklich danken, ich würde sagen, für die Kraft, weil
sie zur Verfügung gestellt wird, und für die Lizenz, die für Kosten wie diese verwendet werden kann.
Er hatte also den Vorspann für die Freilassung.
Ich danke Ihnen.
Also gut.
Zurück zu diesem Thema.
Wir haben also einen wirklich schönen Musikplayer und ich habe auch eine kleine Funktion eingebaut.
Aber zuerst wollen wir sehen, ob diese Funktion funktioniert.
Ja, die Musik wird gestoppt.
Okay, jetzt haben wir also eine Art Mischanwendung, denn wenn du
auf die Play-Taste drückst, fängt diese entspannende Musik wieder an.
Und jetzt können wir es mehrmals spielen.
Ich muss zum Beispiel das Timing treffen.
Ja.
Völlig daneben.
Das spielt keine Rolle.
Los geht's.
Machen wir weiter so.
Ja.
Es ist also absolut furchtbar.
Und es funktioniert nicht mehr.
Erstaunlich.
Lassen Sie uns also ganz schnell zum Schluss kommen.
Also gut.
Ja, ich habe es natürlich so vorbereitet, dass
wir es ein bisschen interessanter machen können.
Jetzt hast du also eine Musikanwendung, und wenn du ein großartiger Lehrer
wirst, dann gib mir bitte ein paar Credits für dieses Video hier.
Also gut.
Perfekt.
Okay, jetzt wissen wir also, was diese Anwendung macht, zumindest den Hauptzweck.
Aber lassen Sie uns herausfinden, was genau das ist.
Deshalb würde ich vorschlagen, dass wir uns mit der Haupttätigkeit befassen, denn das ist unser Einstiegspunkt.
Also Hauptaktivität und mal sehen.
Wir haben also Kontakte, einen Media Player.
Ich meine, wir haben noch nicht darüber gesprochen, aber wir können uns denken, was dieser hier macht.
Unsere eigene Methode zum Erstellen von Kontakten, Textansicht, nichts allzu Ausgefallenes.
Oh, was ist das für eine geheime Datei, die Klänge erzeugt.
Das klingt interessant.
Hier haben wir Start- und Stoppmusik.
Das können die Funktionen sein, die mit der Taste verbunden sind.
Und ja, Sie können sehen, dass es sich nicht um einen Programmierfehler handelt.
Das habe ich absichtlich getan.
Also gut.
Ja.
Ich meine, die Stoppfunktion, das ist etwas, was
ich vermasselt habe, aber ja, das ist okay.
Also zurück zu diesem Thema.
Wir haben geheime Dateien erstellt.
Was macht das also?
Wir haben zwei Saiten.
Das könnte der Dateiname sein und das ist der Inhalt.
Okay, dann haben wir einen Dateiausgabestrom.
Ich meine, wir wissen nicht, was dieser hier macht, aber hey, okay, wir haben eine offene Dateiausgabe.
Was soll's? Lassen Sie uns
das aus dem Weg räumen.
Vielleicht öffnen wir also diese Datei, meinen geheimen Dateinamen hier drüben im privaten Kontextmodus.
Und dann sieht es so aus, als würden wir diesen Inhalt in diese Datei schreiben, also erstellen wir einfach eine Datei.
Und das Erstaunliche daran ist, dass diese Datei
im geschützten Datenverzeichnis dieser Anwendung gespeichert wird.
Dies liegt also in der Sandbox, wie zum Beispiel die Freigabeeinstellungen,
was bedeutet, dass ein normaler Benutzer keinen Zugriff darauf hat.
Richtig.
Lassen Sie uns das überprüfen.
Stellen wir also unsere ADB-Shell-Verbindung her.
Und dann, mal sehen, müssen wir richtig religiös werden.
Wir wurden anschließend ohne getestet.
Wir müssen uns also mit den Daten befassen.
Daten.
Dann den Paketnamen.
Wie lautet der Name des
Pakets? Schauen wir mal.
Das sollten wir im Auge behalten.
Und dies ist der Paketname.
Und dann haben wir noch Verzeichnisse, Fallcode und Dateien.
Sehen wir uns also die Dateien an.
Und hier haben wir meine Geheimakte.
Ja.
Überprüfen wir die Berechtigungen für diese Datei.
Und dieser Benutzer oder höher privilegierte Benutzer können auf diese Datei zugreifen.
In Ordnung, drucken wir es aus.
Ist da etwas
drin? Ja.
Dies ist mein supergeheimer Text, den niemand lesen sollte.
Alles klar? Ich meine, dieser Text
wurde in den Java-Quellcode aufgenommen.
Nachdem wir über das Reverse-Engineering einer Anwendung gesprochen haben, können wir
diese zumindest lesen, aber nehmen wir an, sie speichert einige Benutzeranmeldedaten.
Es könnte also einige anfängliche Referenzen geben.
Okay, aber danach gibt der Benutzer ein neues Passwort ein und das Passwort wird in dieser Datei aktualisiert.
Dann sind wir nicht in der Lage, diese Informationen auf der Grundlage des Quellcodes abzurufen.
Also gut.
Jetzt müssen wir also sicherstellen, dass wirklich nur dieser Benutzer oder ein höher privilegierter Benutzer darauf zugreifen kann.
Deshalb verlassen wir den Wurzelkontext und drucken ihn aus.
Ups, ich drucke es noch einmal aus.
Schauen wir mal.
Erlaubnis verweigert.
Perfekt.
Das ist also genau so, wie es funktionieren sollte.
Wir haben den Dateikontext privater gestaltet.
Sie wird im internen Verzeichnis der Sandbox-App gespeichert und in keinem anderen.
Diese Anwendung und höhere Berechtigungen können dies lesen, aber derzeit keine Anwendungen von Drittanbietern.
Ja.
Also gut.
Dies ist also die gesamte Funktionalität dieser Haupttätigkeit.
Es schafft eine.
Und gut.
Und sie hat zwei Tasten.
Das Interessante an der Sache ist, dass es im Moment keinerlei andere Interaktion gibt.
Wir greifen dort also nicht auf unseren Content Provider zu.
Das wirft die Frage auf, ob wir immer noch unverwundbar sind.
Ich meine, wir verwenden diesen Code nicht, aber bevor wir darüber
sprechen, lassen Sie uns zunächst einen Blick auf diesen Inhaltsanbieter werfen.
Hier haben wir also die Klasse des Musikdateianbieters und diese erweitert den Inhaltsanbieter.
Und hier haben wir Knotenmethoden.
Die meisten von ihnen werden nicht umgesetzt.
Es gibt also diese beiden Regeln.
Bitte setzen Sie diese Dinge um.
Wir haben eine Abfrage vom Typ delete get insert on create und einige andere Dinge.
Ja, aktualisieren.
Das sieht aus wie unsere Datenbank, die Aktion,
aber es scheint, als hätten wir keine Datenbankinteraktionsaktion.
Aber was wir haben, ist dieser personifizierte Kampf.
Was ist mit "Datei öffnen"? Dies ist
also auch eine überschriebene Methode, was bedeutet,
dass sie in diesem Inhaltsanbieter definiert wurde.
Wir haben es jetzt also nicht mehr mit einer Datenbank zu tun.
Wir haben es mit Dateizugriff zu tun.
Inhaltsanbieter bedeutet, dass sie neben Datenbanken auch Inhalte bereitstellen.
Wir können auch Zugang zu den Akten gewähren.
Erstaunlich, oder? Auf
jeden Fall.
Und hier sehen wir, dass wir diese Datei geöffnet haben.
Dieser nimmt nun zwei Argumente entgegen: URI und Modus.
Der URI scheint der Dateipfad zu sein, da wir sehen können, dass wir ein
neues Datei-Objekt auf der Grundlage dieses URIs erstellen und dann sehen wir weiter.
Wurde dies hier verwendet? Dieser wird hier verwendet und wir
öffnen diese Datei gerade und können diesen Modus sehen.
Ich meine, es könnte lesen, schreiben, anhängen sein.
Ich bin nicht sicher, ob es append gibt, aber dieser Modus gibt einfach an,
welche Art von Zugriff wir auf diese Datei haben wollen, lesen oder schreiben.
In diesem Fall können wir in dieser Methode zum Öffnen einer Datei, die
übrigens nach außen exportiert wird, so dass wir mit ihr interagieren können, diese
beiden Parameter bereitstellen, aber dieser Parameter, zumindest der kleine, wird nicht verwendet.
Selbst wenn wir sagen, dass wir in diese Datei schreiben wollen, funktioniert das
nicht, weil wir sie hier fest einprogrammiert haben und nur lesen können.
Aber lasst es uns tun.
Im Moment nicht so schnell.
Wir öffnen also diese Datei und können sie nur lesen.
Und dann geben wir diesen Pfad-Dateideskriptor zurück.
Hier geht es also einfach darum, das Skript auf diese Datei zu übertragen.
Es handelt sich also um eine Art, nennen wir es mal, Zugriff auf diese Datei.
Ich möchte jetzt nicht zu sehr auf das Linux-System eingehen, weil es nicht relevant ist.
Wir haben also einen Dateideskriptor und Sockets, aber am Ende, ich meine, was das bedeutet, ist,
dass wir Zugriff auf eine Datei erhalten, so dass wir mit der Datei interagieren können, und
diese Datei, mit der wir interagieren können, wird hier geöffnet und über die Theorie referenziert.
Also stellen wir sie bereit und reichen sie ein.
Wir wollen diesen Inhaltsanbieter öffnen, und dieser Inhaltsanbieter öffnet
diese Datei und ermöglicht uns den Zugriff darauf.
Ja.
Ein Anwendungsfall könnte zum Beispiel das Senden einer Musikdatei an diese
Art von Anwendung sein, die von den Inhaltsanbietern geöffnet wird.
Und ja, in der Rückgabefunktion hier drüben könnte man das
jetzt auch in einen Musikstream packen und abspielen, zum Beispiel.
Aber um das Ganze so einfach wie möglich zu gestalten, habe ich nur die notwendigen Teile aufgenommen.
Das ist das absolute Minimum, um diesen Inhaltsanbieter funktionsfähig und anfällig für unsere Art von Angriffen zu machen.
Ich meine, wenn Sie jetzt diesen Anwendungsfall finden und den Inhaltsanbieter mit dieser
Parser-Dateibeschreibung exportieren, den URI einer Datei öffnen und dieser URI direkt in eine
Datei übergeben wird, die hier geöffnet wird, dann haben wir unsere Schwachstelle.
Sie sehen gerade nicht, welcher es
ist? Das ist kein Problem.
Wir werden dies jetzt ausführlich diskutieren.
Also gut.
Ja.
Also, nehmen wir das Grafiktablett und ja, mal sehen, ich mache
ein bisschen Platz und jetzt schreiben wir das direkt hierhin.
Okay? Mal sehen, wir
haben unsere Anwendung.
Das hier ist unser Musikplayer.
Lassen Sie uns den Bildschirm erstellen.
Und dieser exportiert nun diesen Musikdateianbieter, der sich im Content Provider befindet und
dieser wird exportiert, d.h. bei dieser Methode ist er von außen verfügbar.
Ja.
Wir können also mit dieser Methode interagieren.
Diese Methode hat jetzt zwei Parameter: URI und Modus.
Die erste Frage ist also, was ist dieser URI? Der URI ist einfach
nur ein Verweis auf in fine und er sieht wie folgt aus.
Wenn Sie also auf eine Datei verweisen wollen, können Sie dies auf folgende Weise tun.
Inhaltlich ist dies unser Schema.
Dann haben wir den Namen der Behörde, ja, ich nenne
das jetzt einfach und dann haben wir den Namen definieren.
Wenn Sie also z. B. etwas auf der
SD-Karte öffnen wollen, sieht es wie folgt aus.
Schrägstrich Schrägstrich unsere Behörde und dann SD-Karte.
Musik dachte Punkt MP drei, um auf diese Datei zuzugreifen.
Sie basiert auf der SD-Karte.
Ich meine, wir müssen diese Berechtigung zum Lesen des externen Speichers verwenden,
aber diese App hat diese Berechtigung, also wäre das in Ordnung.
Also gut.
Ja.
Nun stellt sich die Frage, wie können wir das ausnutzen? Nun, wenn
wir diese Anwendung oder eine Anwendung eines Drittanbieters haben, dann können wir
jetzt eine Datei bereitstellen, die diese Anwendung in dieser hier öffnen wird.
Und anstatt die MP-3-Datei von der SDCARD zu verwenden, können wir, sagen wir mal, was immer wir wollen, angeben.
Aber natürlich muss diese App die Berechtigung haben, diese zu öffnen.
Was ist, wenn wir nicht die SD-Karte und die P3-Datei
bereitstellen? Was ist, wenn wir etwas wie Inhalt Schrägstrich Schrägstrich,
dann unseren Autoritätsnamen und dann den Zugang zu diesem bereitstellen.
Meine Geheimakte.
Dann nimmt diese Anwendung diese URI.
Es ordnet dies einer neuen Datei zu.
Es öffnet diese Datei und gibt den Zugriff auf diese Datei in diesem Paketdateideskriptor zurück.
Wir senden dies also an diese Anwendung, und diese Anwendung kehrt nun zurück.
In diesem Dateideskriptor, diesem Parser-Dateideskriptor, geht es einfach um den Zugriff auf diese Datei.
Und jetzt gibt es diesen Hinweis, weil meine geheime Datei in dieser hier
drüben, ich habe es ist es ein Unterstrich nicht und nichts anderes.
Also lasst uns das sauber machen.
Das war's.
Jetzt haben wir also einen Unterstrich hier.
Meine geheime Datei wird im Datenverzeichnis dieser Anwendung gespeichert.
Nehmen wir also eine andere Farbe, die nicht sichtbar ist.
Nehmen wir das hier.
Dieser hat also noch Luft im Speicher unserer Smartphone-Daten.
Daten, und dann den Paketnamen.
Und dann haben wir noch Akten, und dann haben wir noch meine Geheimakte.
Diese wird also im geschützten Datenverzeichnis dieses Pakets gespeichert.
Das heißt, wenn unsere Anwendung versucht, auf diese Datei zuzugreifen, sehen wir dies in
der ADB-Shell mit Cut Access wird blockiert, weil diese Benutzer-ID keinen Zugriff darauf hat.
Dieser hat keine Berechtigung zum Zugriff auf diese Datei.
Also gut.
Aber wenn wir jetzt um diese Anwendung bitten, so bitten wir, dass Stratus noch einmal, um dies noch dramatischer zu machen.
Wir bitten diese Anwendung hier drüben, diese Datei mit dieser Methode zu öffnen.
Diese Anwendung hat also Zugriff auf diese Datei,
weil sie in diesem internen Verzeichnis gespeichert ist.
Und diese Benutzer-ID hat natürlich Zugang zum Öffnen dieser Datei.
Und nun öffnet diese Anwendung diese Datei und ermöglicht unserer Anwendung den Rückgriff darauf.
Also wird dieser hier jetzt wieder in den Zugang auf der Grundlage dieser Parzelle fünf Skripten bereitgestellt werden.
Also gut.
Ja.
Wenn nicht, machen Sie sich keine Sorgen.
Wir werden dies jetzt noch einmal im Hinblick auf die Art des Angriffs diskutieren.
Und dann werden wir einige praktische Übungen dazu machen.
Also gut.
Hier haben wir also diese Anwendung, und hier haben wir unsere Anwendung.
Jetzt wissen wir also, dass wir mit diesem Inhaltsanbieter interagieren können, und
wir wollen eine Dateizugriffsanforderung senden, zum Beispiel diese geöffnete Datei hier.
Also gut.
Wir können also den URI definieren.
Um nun diese Sicherheitslücke auszunutzen, müssen wir folgendermaßen vorgehen.
Ich meine, wir haben mehrere Möglichkeiten, aber ich zeige Ihnen jetzt eine Möglichkeit, die immer
funktioniert, und deshalb müssen Sie sich nur diese eine und nicht die anderen Teile merken.
Also gut.
Ja.
Das Problem ist nun, dass wir, wenn Sie diese Datei,
meine geheime Datei, öffnen wollen, den folgenden Pfadinhalt angeben müssen.
Es ist weniger.
Weniger als unser Behördenname und dann Dateien und dann meine geheime Datei.
Wir kennen den Kontext unseres Dateizugriffs nicht.
Diese URI hier könnte also einige zusätzliche Informationen enthalten.
Zum Beispiel könnte sie sagen, dass sie, anstatt auf diesen URI direkt zuzugreifen
oder ihn an unsere Anwendung weiterzugeben, zuerst ein anderes Verzeichnis anhängen könnte.
In unserer Anwendung haben wir drei Verzeichnisse.
Bis jetzt haben wir einen Cache.
Wir haben noch etwas, an das ich mich nicht mehr erinnere, und wir haben dieses Dateiverzeichnis.
Nehmen wir an, der Anwendungscode wurde so konzipiert, dass dies das Basisverzeichnis ist.
Und wenn wir nun diesen Teil anhängen, versucht die Anwendung, auf dieses Dateiverzeichnis
in diesem Cache-Verzeichnis zuzugreifen, und darin befindet sich meine geheime Datei, die
natürlich nicht verfügbar ist, weil diese meine geheime Datei hier gespeichert ist.
Wir öffnen also gerade eine Datei im Cache-Verzeichnis oder versuchen, sie zu öffnen.
Aber diese Datei existiert nicht, denn wir haben hier
im Cache den Kontext, nennen wir ihn Kontext.
So beginnt die Anwendung mit dem Öffnen von Dateien in diesem Verzeichnis.
Auf den ersten Blick sieht es also so aus,
als könnten wir auf keine anderen Dateien als die
in diesem Fallverzeichnis zugreifen, richtig? Nein, natürlich nicht.
Denn was wir gerade tun, ist ein Pfadüberquerungsangriff, was bedeutet, dass wir,
anstatt Dateien bereitzustellen, meine geheime Datei, was wir tun können, wenn wir
in diesem Cache-Verzeichnis-Kontext sind, könnten wir einfach zwischen diesen beiden anhängen.
Oh, es wird ein bisschen chaotisch, aber ich denke, das ist in Ordnung.
Punkt, Punkt, Schrägstrich.
Das ist zu chaotisch.
Lassen Sie uns umschreiben, was dieser Punkt-Punkt-Schrägstrich macht.
Wenn wir uns jetzt in diesem Cache-Kontext hier befinden, erhalten wir ein Verzeichnis zurück.
Wir gehen also ein Verzeichnis zurück, was bedeutet, dass wir uns jetzt im
Stammverzeichnis dieser Anwendung befinden und jetzt das Dateiverzeichnis betreten, das jetzt verfügbar ist,
weil die Dateien hier drüben sind und wir jetzt diesen Cache-Kontext verlassen haben.
Wir sind jetzt in den Dateien und können diese geheime Datei hier öffnen.
Das würde also funktionieren.
Fragen Sie, indem Sie einen Punkt Punkt Schrägstrich eingeben.
Nun wissen wir nicht, in welchem Kontext wir uns befinden, und wir wollen Ihnen eine Lösung anbieten, die immer funktioniert.
Was wir tun können, ist die Bereitstellung von vielen Punkt Punkt Schrägstrich Versuche, was bedeutet,
dass wir wollen, woops, wir wollen zurück zu einem Zustand, wo wir wissen, wie die
Struktur aussieht und geben Sie an, wie weit wir zurückgehen wollen ist das Stammverzeichnis.
Wenn wir uns also im Stammverzeichnis des Smartphones befinden, dann wissen
wir, dass wir ein Datenverzeichnis haben und dieses ein weiteres Datenverzeichnis.
Dieser hat nun dieses Paketverzeichnis.
Der Name des Pakets und dieses hier haben dieses Dateiverzeichnis.
Und darin haben wir diese Geheimakte.
Wenn wir also zurückgehen oder die Möglichkeit haben, zum Stammverzeichnis zurückzugehen, dann können wir
dieses Schema immer anwenden, weil es sich nie auf der Grundlage des Stammverzeichnisses ändert.
Also gut.
Ja.
Wie viele Schrägstriche brauchen wir also insgesamt, um zum Stammverzeichnis zurückzukehren? Die
Antwort ist, dass wir das nicht wissen, denn wir könnten uns in
diesem Verzeichnis befinden oder in einem Unterverzeichnis oder sogar noch weiter.
Aber das ist kein Problem, denn wenn wir einmal das Stammverzeichnis erreicht haben,
können wir nicht weiter hinter dieses Stammverzeichnis zurückgehen, denn das ist der Ausgangspunkt.
Wir können also nicht weiter zurückgehen, d. h. wir können so viele Punkt-Punkt-Schrägstriche anwenden, wie wir wollen.
Wir müssen nur genug haben, um aus jedem einzelnen Unterverzeichnis, in
dem wir uns gerade befinden, herauszukommen und zum Stammindex zurückzukehren.
Und dann können wir unserem Weg hier drüben folgen, diesem hier.
Auf diese Weise kann ein Path-Traversal-Angriff leicht ausgenutzt werden, ohne dass
man sich Gedanken darüber machen muss, wo wir uns gerade befinden.
Wie ist die Struktur? Muss ich
in ein Verzeichnis gehen, zurück oder
vorwärts und so weiter? Also gut.
Ja.
Deshalb würde ich vorschlagen, dass wir das einfach tun.
Probieren wir das mal aus.
Also, unser Angriffsvektor, lassen Sie uns das ein wenig bereinigen.
Ja.
Unser Angriffsvektor würde also etwa so aussehen: Inhalt, Schrägstrich, Schrägstrich, dann der Name
der Behörde und dann Punkt, Punkt, Punkt, Punkt, Schrägstrich und so weiter.
Noch einer, nur einer als Glücksbringer, dieser und der letzte.
Das ist wirklich das letzte.
Dann fügen wir unsere Dateien an, und dann ist da noch meine Geheimdatei.
Also gut.
Dies ist der Inhalt, den wir von unserer Anwendung an diese Anwendung weitergeben und freundlich
fragen: "Hey, bitte öffne deine geheime Datei für uns und gib uns Zugang dazu.
Sie fragen sich jetzt vielleicht, warum jemand so etwas entwickelt?
Aber es gibt tonnenweise wirklich gute Anwendungsfälle für so etwas.
Ich meine, nicht auf diese Weise.
Natürlich würde die Abschwächung einfach darin bestehen, diesen Teil hier zu filtern, diesen URI.
Wenn dies jedoch nicht gefiltert wird und wir unseren Parameter direkt
eingeben können, dann können wir auf diese privaten Dateien zugreifen.
Und das geschieht immer noch recht häufig.
Heutzutage gibt es eine Reihe von wirklich unsicheren Pfadvorschlägen,
die zu enormen Sicherheitsrisiken für diese Anwendungen führen.
Ich meine, stellen Sie sich vor, wie viele sensible Daten in
den gemeinsam genutzten Einstellungen oder Datenbanken oder ähnlichem gespeichert sind.
Wir können auf alle zugreifen, wenn wir diese Art von Schwachstelle haben.
Erstaunlich.
Richtig? Also, lasst
uns das tun.
Wie können wir diese Datei jetzt senden? Und noch
einmal, wir tun dies in der ADB-Shell und schreiben
dann unsere eigene benutzerdefinierte Anwendung, um diese Aufgabe auszuführen.
Wenn du bereit bist, dann lass uns gehen.
Okay, als Erstes sollten wir das hier aufräumen, in Ordnung? Und lassen Sie
uns das auch ein bisschen weiterbringen, damit wir Zugang zu diesen Dingen haben.
Ja.
Und ich würde vorschlagen, dass wir diese Anwendung im Hintergrund öffnen.
Ich meine, ist es erforderlich, dass sie
offen ist? Ich bin mir nicht sicher.
Ich denke nicht.
Wir können das später ausprobieren.
Aber ich mag sie wirklich, diese Chillout-Musik.
Und ja, ich denke, wir können es spielen, weil es lizenzfrei ist.
Lassen wir also diese Musik im Hintergrund laufen.
Also gut.
Jetzt haben wir also etwas entspannende Musik, um das jetzt auszunutzen.
Ja.
Lautstärke runter.
Okay, cool.
Wenn Sie also mit diesem Kondomprovider interagieren wollen, brauchen wir zuerst unsere ADB-Shell.
Und dann müssen wir die Inhalte nutzen.
Und wenn Sie sich erinnern, bin ich mir nicht sicher, ob Sie es noch hören können, aber für mich ist es im Moment in Ordnung.
Okay, vielleicht.
Vielleicht ein Band höher.
Das war's.
Das wäre absolut perfekt.
Also, ja, hier haben wir unsere Kondomanbieter Hilfe.
Und wir haben darüber gesprochen, dass wir es in zwei Wege aufgeteilt haben.
Ich denke, wir haben es hier geteilt, aber.
Und dieser könnte es sein.
Ich bin mir nicht sicher, ob dies der Fall sein könnte.
Ja, ich denke, wir sollten es so aufteilen.
Das hier ist dateibezogen, und das hier ist datenbankbezogen, dieser Hilfspfad.
Okay, das bedeutet also, dass wir uns auf diesen einen konzentrieren können und ich meine, wir haben ADB-Shell-Inhalte, die Uri lesen.
Nun, so einfach ist das.
Finden wir es heraus.
Wir haben Uri gelesen.
Rechts Uri und get type.
Ich vermute, dass sich dies auf die Zählertypen bezieht.
Ich bin mir bei diesem Thema nicht sicher, aber ja.
Ich würde also vorschlagen, dass wir das mal aufräumen.
Ja.
Wenn wir nun eine Datei öffnen wollen.
Was wir also tun müssen, ist, den Inhalt zu lesen und den URI bereitzustellen.
Also gut.
Was ist der URI? Nun, er beginnt mit Inhalt, so dass
der Inhaltsanbieter weiß, dass es sich um den Inhaltsanbieter handelt oder
diese Anwendung weiß, dass es sich um den exportierten Inhaltsanbieter handelt.
Und um zu sagen, dass es sich um genau diesen handelt, müssen wir den Namen der Behörde angeben.
Und dann müssen wir die Datei angeben, die wir öffnen wollen.
So haben wir unsere Geheimakte sowohl auf den Akten gesehen.
Meine Geheimakte.
Ich denke, das wird funktionieren, weil wir vielleicht im Anwendungsverzeichnis beginnen.
Schauen wir also mal.
Nö.
Es funktioniert nicht, und das ist gut so.
Das heißt, wir sind uns nicht sicher, in welchem Kontext wir uns gerade befinden.
Wir sind also nicht auf diese Datei gestoßen, aber wir kennen die Dateistruktur dahinter.
Gehen wir also zurück zum Stammverzeichnis und folgen wir unserem Pfad.
Also gut.
Um dies zu tun, müssen wir zunächst sicherstellen, dass wir auf das Stammverzeichnis zugreifen.
Wir verwenden also viele Punkt-Punkt-Schrägstriche.
Die Menge spielt keine Rolle, sie muss nur ausreichen, um zum Stammverzeichnis zurückzukehren.
Es könnten also drei oder 15 sein.
Wir müssen das ausprobieren, aber wir können im Moment nicht zu viel machen.
Fügen wir also noch ein paar weitere hinzu.
Okay, öffnen wir nun eine weitere Shell und überprüfen wir dies.
Wir erhalten also Root-Rechte und stoßen nun auf
das Root-Verzeichnis, und dann folgen Sie diesem Pfad.
Also Daten, Daten und jetzt dieses Paket mit dem Namen com packing music player.
Dann haben wir Akten und hier haben wir meine Geheimakte.
Dies ist also der Pfad vom Stammverzeichnis aus.
Und dann müssen wir nur noch diese meine geheime Datei öffnen.
Also gut, mal sehen, ob das funktioniert.
Ich habe das mit 3:1 gewonnen.
Ja.
Dies ist mein supergeheimer Text, den niemand lesen sollte.
Dann ein
Tippfehler? Nein.
Okay, perfekt.
Ich meine, so können wir in dieser Anwendung auf beliebige Dateien zugreifen.
Erstaunlich.
Richtig? Also,
ja.
Ich meine, so kann man eine Sicherheitslücke ausnutzen und den Pfad überqueren.
Das, worauf wir achten müssen, ist, oh, mal sehen, lass uns noch
einmal spielen, weil es auf dieser Basis absolut reibungslos funktioniert hat.
Also die Dinge, die wir haben, um zu suchen ist und Anbieter, die exportiert wird,
um wahr und die diese Methode B definiert diese Parzelle Datei Deskriptor öffnen Datei hat.
Und die Theorie wird nicht gefiltert.
Wenn dies der Fall ist, Exporter, Inhaltsanbieter, offene
Datei, ungefilterter URI, dann haben wir eine Pfadüberquerungsschwachstelle.
Erstaunlich.
Richtig? Schauen wir uns also an, wie wir dies von unserer
eigenen Anwendung aus ausnutzen können, denn ich meine, dass diese ADB-Shell
ausreicht, um zu zeigen, dass diese Anwendung für diese Art
von Angriff anfällig ist, und Sie brauchen keinen weiteren Beweis.
Aber wenn Sie Kunden haben, dann wäre es
doch toll, wenn Sie Geheimnisse, Pässe, Datenbanken in
Ihrer Bewerbung zeigen könnten, oder? Auf jeden Fall.
Ich meine, wir müssen uns auch keinen physischen Zugang verschaffen, weil
wir dies aus der Ferne mit HTTPS-Anfragen und Ähnlichem tun können.
Aber ich denke, eine Demonstrationsanwendung, die diese Dateien
in unserer eigenen Anwendung öffnet, sollte ausreichen.
Also gut, fangen wir an.
Ich bin sehr aufgeregt darüber.
Oh, ich bin immer noch begeistert, weil der Code nicht wirklich viel ist.
Das dauert bei mir also nur ein paar Minuten.
Vielleicht viele Minuten, aber ich will das nicht unnötig in die Länge ziehen.
Also lasst uns kreativ werden.
Huch.
Legen wir also ein neues Projekt an.
Ja.
Wir wählen eine leere Tätigkeit.
Und dann haben wir das hier benannt.
Wie benennen
wir diese
Pfadüberquerung? Puck.
Ja.
Ich entscheide mich für eine Schätzung des Mindestmaßes an Sprachtrauma.
Das hier klicke ich zu Ende.
Drehen Sie die Lautstärke ein wenig herunter.
Es wird gerade zu aufregend.
Also gut.
Das Ausschreibungsverfahren ist hier abgeschlossen.
Wir haben unsere eigene Erstellungsmethode.
Wie können wir nun die gleiche Aufgabe
in dieser durchführen? Nicht in diesem.
Diese hier.
Also.
Nein, dieser auch nicht.
Ich hoffe, ich habe sie irgendwo geöffnet.
Okay, dann machen wir das mal ganz schnell.
Also ADB-Shell-Inhalt, URI-Inhalt lesen, und ich habe es.
Vielleicht in der Zwischenablage.
Ja.
Sieht gut aus.
Das ist ein Schrägstrich zu viel.
Also gut.
Ja, das funktioniert.
Perfekt.
Dies ist also die Datei oder die Inhaltsanforderung, diese URI-Anforderung, die wir an diese Anwendung senden wollen.
Okay, und wie können wir das tun? Nun,
auch hier müssen wir unsere Gruppen definieren.
Entschuldigung, unsere Inhaltsressource.
Wir können dies mit dem Get-Content-Resolver tun, und dann haben wir einen offenen Eingabestrom.
Ja.
Hier wird also nach einer URI gefragt.
Definieren wir also diesen URI.
Und wir haben das schon gesehen, also können wir das auch.
Also Ihre URI neue URI-Objekt und dann Uri dachte passieren und dies.
Ja.
Was ist
das? Wiederkehrend.
Schauen wir mal.
Sie muss von Kriminalität umgeben sein.
Fangen, weil der Dateizugriff schief gehen kann.
Und was bringt dieses
eine zurück? Können wir.
Können wir das sehen? Dann
mache ich es so.
Dann erhalten wir einen Fehler.
Denn was ist der Rückgabewert des Eingabebildschirms?
Okay, hier wird also ein Eingabestrom zurückgegeben.
Eingangsstrom OC.
Lassen Sie uns das so benennen.
Und ja, das ist schon ein seltsamer Zauber.
Wir fragen uns also, warum dieser "get content resolver, open input screen".
Wir wollen einen Stream zu dieser URI haben und wir übergeben nun unseren
Path-Traversal-Angriff an diese Anwendung, die uns einen Stream zu dieser Datei zurückgibt.
In Ordnung, nun die Frage, wie können wir das ausdrucken? Und um
ehrlich zu sein, nun, das ist sehr tief in der Android-Programmierung.
Ich versuche, dies auf einer hohen Ebene zu zeigen und dann zu erklären, wie wir dies ausdrucken können.
Also gut.
Also nur ganz grob, und wir gehen hier nicht weiter in die Tiefe, also zurück zur Grafikvorlage.
Ja.
Um also einen Eingabestrom auszudrucken, schauen wir uns an, was passiert.
Wir haben also unsere Akte und diese kehrt nun zurück.
Dieser Teil hier.
Dies ist unser Eingabestrom für diese Datei.
Und das ist natürlich nicht nur im Frühling so, denn es ist eine Art Bach.
Wir müssen also Daten aus diesem Stream abrufen können.
Ja.
Was wir tun müssen, ist Folgendes.
Ich schätze, ich bin mir auch nicht 100%ig sicher.
Nehmen wir an, wir filtern dies oder wir greifen auf der Grundlage eines Eingangslesers darauf zu.
Wir brauchen also einen Eingangsleser vor diesem Gerät.
Ja.
Dann haben wir hier und Rita, die das Material lesen kann, das aus dem Eingabestrom zu uns gelangt.
In dieser Richtung ist dies also unsere Anwendung hier und
dies ist die andere Anwendung, die diese Dinge bereitstellt.
Und dann in der Eingabe-Leser, ich vermute, es ist in Puffer-Leser, wenn ich es ist nicht so,
wie es lesen Puffer Puffer Puffer Leser lesen Puffer rip Puffer vielleicht ist es so, lesen Puffer.
Andernfalls werden wir nachschauen und dieser kann nun bestimmte Teile aus dem
Bildschirm auslesen, zum Beispiel immer 1024 Bytes, und diese Bytes können dann
in einen String übertragen werden und wir können unsere Feder anhängen.
Und wir müssen so lange aus dem Stream lesen, bis wir keine Daten mehr erhalten.
Wenn dies also unsere Daten sind, bis der Stream nichts mehr
zurückgibt, dann wissen wir, dass wir jetzt am Ende sind.
Also gut.
Ja, das hört sich sehr kompliziert an, aber ich denke, es handelt sich nur um zwei oder drei Zeilen und eine breite Schleife.
Aber wir werden das jetzt herausfinden.
Schauen wir also mal.
Im Übrigen.
Ja, es handelt sich nicht um einen Kurs zur App-Entwicklung.
Falls Ihnen das jetzt zu viel ist, lehnen Sie sich zurück, entspannen Sie sich, drehen
Sie die Musik lauter und schauen Sie mir dabei zu, falls Sie eine Referenzanwendung wünschen.
Wenn Sie also einem Kunden zeigen wollen, wie wir den Pfad zu einer
virtuellen Schwachstelle ausnutzen und die Daten und unsere eigene Anwendung zeigen können.
Einfach diesen Code kopieren und einfügen.
Ben Es funktioniert.
Wenn es also funktioniert, dann können Sie das natürlich frei verwenden.
Und Sie müssen das nicht durchmachen.
Nun, sagen wir mal, ich verstehe es sogar vollständig.
Aber es ist gut, wenn Sie ein Grundwissen darüber haben.
Also gut.
Ja.
Hier haben wir nun also unseren Eingabestrom, was bedeutet, dass wir jetzt unseren Eingabestromleser brauchen.
Wir brauchen jemanden, der versteht, wie es weitergeht.
Eingabebildschirmleser und
dieser.
Mal sehen, wir können, denke ich, diesen Teil liefern.
Ja.
Der Eingabestrom wurde in diesem Try- und Catch-Block definiert, d. h. wenn
wir hier eine Ausnahme erhalten, ist diese Variable für diesen Teil unbekannt.
Dieses Symbol kann nicht aufgelöst werden.
Ganz genau.
Das heißt, wir erstellen einfach eine Variable hier drüben.
Die Anwendung ist sich dessen bewusst, und wir stellen mit
unserem Try- und Catch-Block sicher, dass vorher alles gut funktioniert.
Okay, jetzt haben wir den Eingangsstromleser.
Jetzt müssen wir diese Daten lesen, und zwar so lange, bis wir keine Daten mehr erhalten.
Und das kann innerhalb einer wilden Schleife geschehen.
So, während das ist ein guter Anfang, aber jetzt die Frage, die wir brauchen, ist diese Bedingung, wenn wir
nicht empfangen keine Daten mare und ich schätze, dass dies mit Buffer-Reader getan werden, mal sehen, wie funktioniert
diese Lesepuffer lesen Buffer-Reader Buffer-Reader auf diese Weise, Puffer es, lesen Sie eine Entschuldigung, jetzt haben wir es.
Okay, aber wir müssen zuerst diesen Pufferleser zuweisen, und das können wir hier tun.
Wir erstellen also einen neuen Objektpufferleser und diesen neuen Pufferleser.
Huch.
Also lesen wir jetzt von diesem Eingangsstromleser unsere Signalpuffer
und jetzt haben wir diesen Zustandspufferleser und fertig.
Ja, fertig.
Klingt ein bisschen irreführend, aber das bedeutet auch, dass es als eine Bedingung verwendet werden kann, wenn man keine
Daten mehr empfängt, und es stellt auch sicher, dass wir auf weitere Daten zugreifen können, so dass unser
Lesen während des Lesens blockiert werden könnte, aber lassen Sie uns nicht zu tief in dieses Thema einsteigen.
Dies ist also unsere Bedingung, und wir haben hier einen Fehler.
Schauen wir mal.
Umgeben Sie sich mit Versuch und Fang.
Nun, okay.
Ich bin mir nicht sicher, ob mir dieser Code im Moment gefällt.
Wir sind also gut zurechtgekommen.
Das stimmt.
Und wir beenden unsere Wache.
Nein, nein, nein, nein, nein.
Hm, hm.
Lassen Sie uns das anders machen.
Also.
Okay, machen wir diese Reise.
Loggen Sie sich hier ein.
Und dann nehmen wir unseren Pufferleser als Bedingung.
Und so sieht es aus.
Hier.
Wir haben unseren Versuch gemacht.
Oh, da fehlt noch diese Klammer.
Ja.
Okay, jetzt ist es gut.
Ich meine, ich bin kein Encoder, aber selbst dieser Teil war es.
Nein, das war nichts, worauf ich Lust gehabt hätte.
Ja.
Jetzt lesen wir also unser Material mit diesem Pufferleser und können dies nun unserer Zeichenkette zuweisen.
Wir definieren also eine neue Zeichenfolge.
Dies ist die Eingabe der Datei.
Das mag ich auch nicht.
Auf diese Weise.
Jetzt können wir diese Datei plus gleich verwenden und jetzt Pufferleser lesen Zeile.
Ja.
Jetzt lesen wir also eine Zeile aus unserer Datei und
ordnen sie unserer Zeichenkette in der Datei input string zu.
Das Problem ist jedoch, dass diese Lesezeile am neuen Zeilenzeichen endet.
Und wenn wir diese Zeile lesen, wird alles in einer Zeile angehängt.
Wenn unsere Datei also zehn Zeilen hat, ist in unserer
Zeichenkette hier alles aneinandergereiht, was nicht wirklich lesbar ist.
Nach dieser gelesenen Zeile steht also eine neue Zeile an, denn
dann wissen wir, dass die Zeile wie bisher beendet wurde.
Ja.
Wenn wir also zehn Zeilen haben, würde unser String alles in eine Zeile packen.
Aber nachdem wir jetzt eine Zeile von unseren zehn Zeilen gelesen haben, steht eine neue Zeile in
unserer Zeichenkette an, was bedeutet, dass unsere Zeichenkette auch aufgeteilt wird, damit wir dieses schöne Format haben.
Ja.
Und das ist alles, was wir tun müssen.
Ja.
Ich meine, ausdrucken, System.out.println, und dann sind wir startklar.
Wo liegt das
Problem? System.out.println.
Ich bin vielleicht nicht mehr in dieser Funktion.
Oh ja, ich bin nicht mehr in dieser Funktion.
Entschuldigung.
Okay, das müssen wir hierher legen.
Also gut.
Jetzt.
Wir sind startklar.
Das Einzige, was uns jetzt noch fehlt, ist, dass wir diesen Code auf modernen Smartphones,
auf Android 11 und höher, verwenden können, denn dann müssen wir uns mit den
Datenschutzeinstellungen befassen, was bedeutet, dass wir, selbst wenn dieser Inhaltsanbieter exportiert wird, nicht in
der Lage sind, mit ihm zu interagieren, bis diese Anwendung für uns sichtbar ist.
Uns als Netznutzer ist das egal, denn wir wollen
natürlich sichtbar sein, um alle Daten abrufen zu können.
Ich meine, wir haben keine Probleme damit.
Die Anwendung kann das, aber in unserer Anwendung ist alles in Ordnung.
Also gut.
Wir gehen also in das Manifest und fragen dann ab, mal sehen.
Nicht sicheres Paket.
Und dann gibt es da noch den Namen des Androiden, den ich mir nicht merken
kann und den wir einfach nachschlagen könnten, aber es ist besser, ihn so zu haben.
Wir brauchen also einen Paketnamen für dieses eine Paket.
Und das ist alles, was im Moment funktionieren sollte.
Unsere Anwendung sollte also in der Lage sein, die geheime Datei aus der anderen Datei zu holen.
Schauen wir mal.
Führen wir das also aus und testen wir, ob die Anwendung im
Vordergrund sein muss, denn ich bin mir da nicht ganz sicher.
Das wird auch für mich interessant sein.
Unsere Bewerbung beginnt also in einem Augenblick.
Aber Labor.
Dort.
Ich kann es schon sehen.
Ich habe das System gesehen.
Dies ist mein supergeheimer Text, den niemand lesen sollte.
Erstaunlich.
Richtig? Dies ist also innerhalb unserer
eigenen Anwendung der Pfad zur Versionsverwundbarkeit.
Und wissen Sie was? Lass
uns diesen Text hier ausdrucken.
Drucken wir sie also direkt auf dem Bildschirm aus und wenden wir unser Schleimaal-Schema an.
Ich meine, das ist absolut nicht mehr relevant, und Sie können das jetzt
gerne überspringen, aber ich würde vorschlagen, dass wir das wirklich schnell machen.
Es dauert nur ein paar Minuten.
Ja.
Also, was wir tun müssen, ist, wir müssen in unserer Aktivität Hauptprüfung Layout innerhalb
von Code gehen und dann meine ich, wir haben diese Hallo Welt Textansicht.
Lassen Sie uns also einen Standardtext erstellen, der gerade gehackt wird.
Okay, dann lass uns die ganze Hintergrundfahne so gestalten, dass sie absolut null aussieht.
So führen so Androide Hintergrundfarbe, schwarz.
Ja.
Und lassen Sie uns diesen Text etwas grün gestalten.
Ich meine, es ist nicht einmal annähernd grün, aber ich kenne den englischen Begriff dafür nicht.
Also machen wir es teal.
Ich bin mir nicht sicher.
Ja.
Und vielleicht eine Anpassung der Größe.
14 DPI und auch, dass es ein wenig von der linken
Seite entfernt ist, damit es nicht direkt auf den Bildschirm passt.
Setzen wir also ein Polster von 20 an, oder ich bin mir nicht sicher, ob das zu viel ist.
Schauen wir mal.
Hm.
Für diesen Text.
Das ist in Ordnung, aber wir wollen sehen, wie es funktioniert.
Ja.
Wir brauchen also eine ID für unsere Textansicht, um dies in unserer Hauptaktivität zu berücksichtigen.
Wir müssen also eine neue ID zuweisen, eine Plus-ID hinzufügen und die Baugruppentextansicht wie immer umbenennen.
Und dann ist das alles, was wir tun müssen.
Wir haben eine ID zugewiesen, wir machen dies absolut hek ish aussehen und das einzige,
was wir jetzt tun müssen, ist in die Hauptaktivität gehen und weisen Sie diese ein.
Wir erstellen hier also eine neue Textansicht.
Wir haben also eine Textansicht in unserer Anwendung, und jetzt weisen wir diese Textansicht zu.
Diese Textansicht behalte ich also bei, auch wenn sie nicht mehr üblich ist.
Das ist also die Art und Weise, wie ich das mache.
Ja.
Jetzt müssen wir also diese ID finden und die in unserem Layout definierte
Textansicht, die in der Methode on create verfügbar ist, dieser Textansicht zuweisen.
Und das ist einfach zu finden Ansicht von id, r Punkt, id, Punkt, und dann dieser Name und
dann statt System aus, wir sind einfach diesen Text dieser Ansicht, Text setzen und wir sind fertig.
Das ist alles.
Lasst uns das ausprobieren und sehen, was für tolle Hacker wir sind.
Das ist der falsche Weg.
Okay, das war's.
Oh, diese Aktionsleiste.
Dies ist mein supergeheimer Text, den niemand lesen sollte.
In Ordnung, erstaunlich.
Oder? Ich meine, wir können uns auch mit dem Zugriff auf meine
geheime Datei anfreunden, und dann können wir es ein bisschen hässlich machen.
Aber, ich meine, es ist okay.
Lassen Sie uns also auch diese Aktion loswerden.
Aber weil das furchtbar aussieht, kann das im Thema im Android-Manifest-Thema gemacht werden.
Damit sind wir bei einem Thema angelangt.
Und dann in dieser letzten Aktionsleiste, ich meine, Index auch in dunkel, denke ich.
Ja.
Aber bleiben wir wirklich bei diesem einen.
Schauen wir mal.
Ja.
Unsere App wird gerade geladen und.
Da haben wir es.
Es könnte ein bisschen hübscher sein.
Aber zur Veranschaulichung reicht das doch, oder? Wir können also
sehen, dass wir innerhalb unserer Anwendung auf diese Datei zugreifen.
Und Sie denken, ich würde wirklich gerne testen, ob dies funktioniert, wenn die App nicht geöffnet wurde? Um
ehrlich zu sein, ich denke, es ist, weil in unserem Absichtsordner B wir diese Fehlermeldung erhalten haben, dass
im Hintergrund Aufgabe ausgeführt wird nicht erlaubt ist, aber dies scheint wie nicht in Hintergrundaufgaben zu sein.
Schauen wir also mal.
Oh, ich muss wirklich ein paar Icons anbringen, sonst wird es ein bisschen lästig.
Dieser eine Weg ist progressiv.
Deshalb wurde diese App geschlossen.
Schauen wir mal.
Funktioniert es noch? Ich
drücke die Daumen.
Erstaunlich.
Es funktioniert immer noch.
Wir können also jederzeit und so oft wir wollen auf diese Datei zugreifen.
Es ist so cool.
Es ist wirklich schön.
Also gut.
Das ist also alles für dieses Video.
Es ist wieder einmal ein bisschen lang geworden.
Aber ja, ich meine, die Dinge, die wir hier gesehen haben, sind ziemlich erstaunlich.
Und das ist etwas, das auch in Kopfgeldprogrammen noch
funktioniert, denn diese Art von Angriff ist absolut kritisch.
Und viele Menschen suchen nicht nach dieser Art von Schwachstellen in mobilen Anwendungen.
Wenn Sie also ein Bug-Bounty-Programm durchführen wollen, schauen Sie sich auch den Abschnitt "Reversing"
an, über den wir am Tag der Messe sprechen werden, das Kompilieren von Anwendungen.
Und dann hoffe ich, dass Sie eine Menge Geld verdienen.
Also gut.
Als Nächstes werden wir eine praktische Übung durchführen.
Die C-Anwendung weist also genau diese Art von Schwachstelle auf.
Und das ist etwas, das Sie selbst üben können, wenn Sie möchten.
Die Aufgabe bestünde also darin, die Schwachstelle im Bereich der Pfadumgehung zu ermitteln und zu versuchen, diese auszunutzen.
Ich meine, ich bin mir nicht sicher.
Ja.
So sollten zum Beispiel die Einstellungen lesbar sein.
Ich bin mir nicht sicher, welche Art von Ausgabe wir erhalten, wenn wir versuchen, auf diese Datenbank zuzugreifen.
Aber um ehrlich zu sein, denke ich, dass dies auch funktionieren sollte.
Es sieht vielleicht ein bisschen billiger aus, aber ja, der Text sollte da sein.
Versuchen Sie also, dies in der C-Anwendung auszunutzen, um die Pässe oder die Datenbank zurückzubekommen.
Also gut.
Also viel Glück und viel Spaß.