Wenn sie zurückkommen.
Lassen Sie uns einige praktische Übungen in Bezug auf unseren Content-Provider durchführen. Wir beginnen
mit unserem Screen-Injection-Angriff, der zwar erstaunlich klingt, aber eigentlich nicht mehr so häufig vorkommt.
Dennoch sind die Anbieter von Exportinhalten immer noch ziemlich gefährlich, und wir werden herausfinden, warum.
Also, auf geht's.
Hier sind wir also wieder bei der Ubuntu-VM.
Wir haben unser Smartphone hier drüben und installieren noch einmal die sichere Anwendung,
weil diese einen wirklich netten Textdienst in Bezug auf den Inhaltsanbieter hat.
Also innerhalb von Apps und siehe da, hier haben wir es.
Wir installieren also die alte Version, ich meine, nicht die alte Version.
Wir installieren die APK und nicht die, sorry, entschlüsselte Version.
Ja.
Und ich schätze, wir müssen es erst einrichten, was ein
bisschen lästig ist, und deshalb werde ich diesen Prozess vorziehen.
Ja.
Wir wollen also den Zugang zu Dateien und Medien ermöglichen, und ja, wir müssen ihn einrichten.
Und wir bekommen auch noch diese Warnung, aber es läuft auf dem Smartphone einwandfrei.
Ich verwende also ein neues Gerät mit der App-Version 30 und das funktioniert wahrscheinlich.
Ja.
Deshalb werde ich diesen Prozess jetzt vorantreiben.
Ja.
Hier sind wir also wieder und haben diese Anwendung bereits eingerichtet.
Wir haben also den Dienst dort drin, wir haben ein Passwort, wir haben eine Anstecknadel und einen Haufen anderer Dinge.
Schauen wir uns also an, wie wir diesen Content-Provider dort nutzen können.
Deshalb werfen wir einen Blick in das Android-Manifest.
In der Decompile-Version bekommen wir sie also immer noch hier drüben.
Hier haben wir ein Beispiel für ein Android-Manifest.
Ja.
Und hier können wir sehen, dass es zwei Kondomanbieter gibt.
Diese und diese.
Ja.
In diesem Video werden wir einen Blick in diese Kondom-Anbieter, die einfach nur in der Datenbank-Interaktion ist haben.
Und das hier drüben ist ein Dateianbieter, der uns
die Möglichkeit gibt, nach Sicherheitslücken durch Pfadüberwindung zu suchen.
Also gut.
Wir werden dies im nächsten Video tun.
Im Moment konzentrieren wir uns auf die Interaktion mit der Datenbank, indem wir uns dieses Beispiel ansehen.
Wir wissen nicht, ob sie in der Datenbank oder beim Dateianbieter gespeichert ist.
Wir werden also einen Blick in den Quellcode werfen müssen, um dies herauszufinden.
Aber bevor wir das tun, sollten wir erst einmal ganz kurz darüber
sprechen, denn es gibt eine Reihe von Dingen, die ziemlich interessant sind.
Kommen wir also zurück zum Grafiktablett.
Ja.
Hier haben wir also unseren Inhaltsanbieter, den hier drüben,
und wir haben den Autoritätsnamen, also diesen Teil.
Ja.
Und dann haben wir durch exportiert.
Erstaunlich.
Das bedeutet, dass dieser Inhaltsanbieter von der Außenwelt aus erreichbar ist.
Wir können mit diesem interagieren.
Das ist also gut zu wissen.
Mehrere Prozesse werden ignoriert und wir haben den Android-Namen.
Das hier ist also der Klassenname.
Sie wurde hier definiert.
Und das ist etwas, das wir später noch überprüfen wollen.
Ich meine, wir müssen noch über Reverse Engineering sprechen.
Daher werde ich den Reverse-Engineering-Ansatz anwenden und den Decompile-Quellcode bereitstellen.
Es ist nicht der Originalcode.
Ich kann es online nicht mehr finden, aber es ist schon gut genug, um unsere Rückwärtsaufgaben zu erfüllen.
Wir wissen also, dass wir eine DB-Content-Provider-Klasse haben, und dies ist der Autoritätsname, was bedeutet, dass wir
so etwas wie Content-Code ohne Schrägstrich haben und dann com und w, r und so weiter.
Und dann haben wir diesen Teil, der auch hier enthalten sein kann.
Und jetzt kommt ein interessanter Teil, denn wir haben auch diese Zeile und diese Zeile ist jetzt eine Pfaderlaubnis.
Dieser sagt uns also, dass wir jetzt eine Datenbank haben.
Dies ist unser Inhaltsanbieter.
Ich meine, das wissen wir jetzt noch nicht, aber das werden wir in Kürze herausfinden.
Wir haben also eine Datenbank, und diese Datenbank hat jetzt verschiedene Tabellen.
Wir wissen nicht, wie viele es sind, aber wir können schon einen sehen,
weil der hier drüben und der hier leider die falsche Farbe hat.
Und das hier, das ist jetzt der Tisch.
Bringen wir das in Ordnung.
Die Tasten der Tabelle.
Ja.
Um genau zu sein, kann der Tabellenname noch anders lauten.
Aber das ist das Schema, die URI für den Zugriff auf die Tabelle.
Wir haben hier also eine Tabelle, die ein Schlüssel sein könnte.
Wie könnte man es
auch nennen? Völlig anders.
Aber wir können über diesen URI darauf zugreifen.
Ja.
Aber warum ist diese hier separat aufgeführt? Und was ist
mit den anderen Tabellen? Nun, diese Tabelle wurde separat aufgeführt,
weil wir eine Sondergenehmigung für diese Tabelle erhalten haben.
Das heißt, wenn Sie in dieser Tabelle lesen oder schreiben wollen, müssen wir diese Berechtigung haben.
Dies oder jenes hängt natürlich von der Aktion ab, die wir durchführen wollen.
Und diese beiden Berechtigungen sind hier definiert.
Jetzt haben wir es also mit benutzerdefinierten Berechtigungen zu tun, was bedeutet, dass der Inhaltsanbieter exportiert wird.
Das hier ist also exportiert.
Aber der Schlüsseltisch wurde gesperrt.
Die Schlüsseltabelle wird durch diese beiden Berechtigungen geschützt.
Wir können diese beiden Berechtigungen in unsere eigene Anwendung aufnehmen.
Und wenn wir den Nutzer nett fragen, dann wird er uns vielleicht die Erlaubnis erteilen.
Und dann können wir von unserer bösartigen Anwendung aus trotzdem darauf zugreifen.
In diesem Teil.
Aber wir haben diese Schutzstufe gefährlich.
Daher kann es vorkommen, dass der Benutzer ein Pop-up-Fenster erhält.
Es hängt von der Android-Version und dem verwendeten Smartphone ab,
aber normalerweise sollte der Benutzer hier ein Pop-up-Fenster erhalten.
Möchten Sie dieser Anwendung Zugang gewähren und der Benutzer muss dies akzeptieren? Um ehrlich zu sein, würde
ich dies nicht als große Sache betrachten, da der Benutzer diese Berechtigungen für unsere Anwendung leicht
erhalten könnte und wir dann in der Lage sein könnten, trotzdem auf diese sensiblen Daten zuzugreifen.
Daher ist das Einfügen von benutzerdefinierten Berechtigungen innerhalb der Schutzstufe gefährlich.
Ich denke, das ist kein gutes Geschäft.
Zumindest sehe ich das im Moment so.
Wenn das Schutzniveau so etwas wie eine Signatur
wäre, dann würden wir über etwas anderes sprechen.
Das ist also eine ganz andere Geschichte.
Dieser hier wäre perfekt.
Über die Unterschrift und den Entwurfsprozess werden wir in einem anderen Thema sprechen.
Bislang bedeutet dies lediglich, dass eine Anwendung und eine andere Anwendung,
die mit demselben Schlüssel signiert wurde, problemlos Informationen austauschen können.
Aber das schließt natürlich andere Anwendungen aus.
Es kommt also immer auf den Anwendungsfall an, den der Entwickler
durchführen möchte, oder auf die Daten, die der Entwickler hier bereitstellt.
Es hängt also immer von der Art der Daten ab, die wir austauschen.
Wenn diese Daten kritisch sind, z. B. wenn es sich um unsere Passwörter
und unseren Passwort-Safe handelt, dann ist die Schutzstufe gefährlich möglicherweise nicht ausreichend.
Wir sollten uns für die Unterschrift entscheiden, aber wenn sie
ohnehin verschlüsselt werden, ist es vielleicht doch nicht so gefährlich.
Also gut.
Es hängt also von den Daten selbst ab.
Ja.
Aber zurück zu diesem hier, das wie ein völliges Chaos aussieht.
Also lassen Sie uns das vielleicht kurz zusammenfassen.
Wir haben also eine Datenbank, und wir haben diesen Behördennamen und diesen.
Dies ist unsere Klasse, die im Content Provider definiert ist.
Und das hat mindestens eine Tabelle, und diese Tabelle kann auf folgende Weise adressiert werden
Inhalt und Schrägstrich dann unsere Behörde Name und wir haben diesen Pfad Schlüssel, falsche Farbe.
Bleiben wir konstant, und zwar in Großbuchstaben.
Okay, die Tabelle dieses Schlüssels wird mit diesen beiden Berechtigungen geschützt, was keine große Sache ist.
Wir können dies umgehen.
Auch dies werden wir später tun.
Wir werden unsere eigene Anwendung schreiben und sie in diese
Anwendung integrieren, aber im Moment ist sie zumindest geschützt.
Daher muss der Benutzer diese Erlaubnis möglicherweise erteilen.
Ich schlage also vor, dass wir dieses Netz entschlüsseln.
Gehen wir also zurück zum Quellcode und werfen wir einen Blick
in diese Klasse, um zu sehen, was hier vor sich geht.
Also gut, fangen wir an.
Also lösche ich den Bildschirm und dann.
Och, ich benutze das Tool von Chad X, wenn Sie das verfolgen wollen.
Lassen Sie mich zuerst Ihre Hilfe in Anspruch nehmen.
Wenn Sie dies nachvollziehen wollen, empfehle ich Ihnen, das Instrument der Handelsausrede
zu verwenden, weil Sie dort eine gewisse Verbindung zwischen diesen Klassen haben.
Sie können einfach auf etwas doppelklicken.
Aber wir haben noch nicht über Reverse Engineering gesprochen und deshalb werde ich Ihnen den Quellcode zur Verfügung stellen.
Ich meine, es ist sowieso der kompilierte Code.
Dies wird also unser Arbeitsbereich sein, und deshalb wähle ich das Befehlszeilenwerkzeug von Chad X.
Also gut.
Wie können wir das also
erreichen? Wir haben den Handel.
Wir müssen eine Eingabedatei bereitstellen, die für ABCC unsicher ist.
Und dann einfach ein Ausgabeverzeichnis festlegen.
Und das ist alles.
Also der kompilierte Code.
Ja.
Wir könnten uns auch nur auf umfangreiche Quellen beschränken
und diese nicht zusammenstellen, aber wir halten alle zusammen.
So alles in diesem Verzeichnis jetzt können wir das ganze Verzeichnis mit Assistenten öffnen, um Code zu tun.
Ja.
Das ist also genau das, was Sie jetzt von mir bekommen werden.
Diese beiden Verzeichnisse, die Ressourcen, die das Android-Manifest enthalten
und auch die Quellen, die den Quellcode enthalten.
Schauen wir also, nach welchem Cluster wir suchen müssen.
Wir müssen einen Blick auf diesen einen DB-Inhaltsanbieter werfen.
Also lasst uns das finden.
Es ist nicht so, dass es nicht heiß ist, dass wir es schon haben.
Also gut.
Ja.
Und wir können bereits sehen, dass wir das Inhaltsschema haben.
Also genau so, wie wir es vorher aufgeschrieben haben.
Also durch die Verwendung dieses Schemas in genau dieser Weise
mit diesem DB-Content-Provider Schrägstrich-Schlüssel sind wir Adressierung und Tabelle.
Aber die Tabelle muss nicht genau so heißen wie diese.
Es könnten also Schlüssel sein, aber es könnte auch ganz anders sein.
Dies ist eine Art Alias für eine bestimmte Tabelle.
Also gut.
Ja.
Im Moment müssen wir uns darüber noch keine Gedanken machen, denn wir werden
später herausfinden, wie wir damit umgehen, wenn diese Namen nicht mehr übereinstimmen.
Ja.
Im Moment können wir sehen, dass wir einen Inhalt haben.
Wir haben also einen Alias für die Schlüssel und hier drüben eine weitere Tabelle.
Passwörter.
Ich meine, noch einmal, es muss nicht nach Passwörtern benannt werden, aber das ist der Alias-Name für dieses Passwort.
Also gut.
Wir haben es also immerhin mit zwei Tabellen zu tun und haben jetzt schon etwas Interessantes.
Unser Inhaltsanbieter wird exportiert, die Schlüssel wurden gesperrt, aber die Pässe sind frei.
Wir sollten also zumindest in der Lage sein, diese Referenz abzufragen, was auch
immer hier drin ist, und diese Daten herauszubekommen, was super toll ist.
Richtig.
Wenn sie an diesen Daten interessiert sind.
Wir werden uns das also später ansehen müssen.
Ja.
Und dann haben wir noch einen Haufen Sachen.
Ich meine, das sind Referenzen, IDs.
Wer weiß? Das
hier klingt interessant.
Wir haben den P.W. RD-Helfer bekommen, also lasst uns das vielleicht ein bisschen rausholen.
Dann haben wir den URI Matcher.
Das passt also zu unserem Uris aus dem.
Von hier aus.
Hier können wir sehen, dass wir Uri Pass OC haben.
Und dann schauen wir mal.
Also gut.
Und dann haben wir noch unsere bekannten Methoden.
Auf den ersten Blick sieht es also nach einem totalen Chaos aus.
Aber Sie müssen sich nicht zu viele Gedanken darüber machen.
Lassen Sie mich die Grafikvorlage zurückholen, und dann werde ich Ihnen zeigen, warum.
Also gut.
Wenn Sie sich also noch an den theoretischen Teil erinnern, dann haben wir unseren Content Resolver auf der Client-Seite.
Und der Inhaltsauflöser bittet den Inhaltsanbieter, einen Zugang zu den Daten zu gewähren,
der Inhaltsanbieter gibt einige Cursor zurück und gewährt ebenfalls Zugang zu diesen Methoden.
Hier haben wir also zum Beispiel die Methode delete.
Es handelt sich also lediglich um das Löschen eines Eintrags in einer Tabelle neben dieser.
Wir haben auch einen Einsatz in diesem hier.
Hier können wir also einen neuen Wert in eine Tabelle einfügen.
Dann haben wir eine Abfrage.
Das ist jetzt vielleicht der interessanteste Teil, denn hier
sehen wir, dass wir jetzt alle fünf Parameter haben.
Wir haben die Theorie, wir haben diese Projektion, wir haben die Auswahl, die Auswahlbögen und die Sortierreihenfolge.
Aus diesen Parametern wird dann die SQL-Syntax gebildet.
Wir haben also etwas wie Select und dann haben wir unsere Projektion.
Und Schutz von dann haben wir unsere diese eine, unsere in der falschen Farbe.
Wir machen Grün rein und dann haben wir Verschleiß
und den ganzen Rest und Auswahl, Auswahl, Axt sortieren.
Aus diesen Parametern wird also eine kodierte Syntax gebildet.
Und genau das ist unser Wendepunkt später in diesem Teil hier und dieser Projektion.
Aber darauf werden wir später eingehen.
Lassen Sie uns zunächst die Diskussion über diese Datei hier beenden und dann sehen,
ob wir die Datenbank und auch die Tabellen bereits anhand des Quellcodes rekonstruieren können.
Denn wenn Sie eine Injektion durchführen wollen, müssen wir mit dieser Struktur
vertraut sein, um sie richtig zu benennen, sonst wird es nicht funktionieren.
Also gut, räumen wir das auf und sehen wir weiter.
Also gut.
Also, ja, wir haben über die Erholung und auch über die Einfügung gesprochen, und diese kann jetzt ignoriert werden.
Der obige Teil wurde ebenfalls analysiert, und dieser ist interessant, weil wir hier
nun eine Methode zum Erstellen haben, aber dieses Mal haben wir nicht die
Aktivität bei der Erstellungsmethode, die wir bei der Erstellung unserer Datenbank haben könnten.
Und das ist ziemlich wichtig, denn wenn wir unsere Datenbank in diesem Teil hier
erstellen, dann können wir einige Schlüsse über die Struktur unserer Datenbank ziehen, welche Tabellen
darin enthalten sind, was die Spalten sind und wie sie miteinander verbunden sind.
Das ist also etwas, das wir auf jeden Fall herausfinden
wollen, und deshalb werden wir uns das später ansehen müssen.
Ja.
Nach der Abfragemethode bleibt nur noch die Aktualisierungsmethode übrig, mit
der wir einfach unsere Einträge in einer Tabelle aktualisieren können.
All dies wird also später geschehen.
Wir werden mit Einfüge-, Lösch- und Aktualisierungsanweisungen herumspielen und natürlich
mit unserer Abfrageanweisung, um unsere eigene SQL-Syntax in diese einzufügen.
Bevor wir das tun können, bleibt nur noch eine Aufgabe übrig, und das ist diese hier.
Lassen Sie uns also herausfinden, wie die Struktur dieser Datenbank aussieht.
Okay, hier haben wir also den p.w.d.-Helfer.
Mal sehen, p.w dx helper ist hier drüben und dieser hier.
Also gut.
Damit wird der Name der Datenbank definiert.
Innerhalb des Datenverzeichnisses haben wir also unseren Paketnamen und darin ein
Verzeichnis namens DB und dies ist die Datei in diesem Verzeichnis.
Diese Datenbank wird also dort gespeichert werden.
Wir können diese Datei mit dem ADB-Pool auf unseren Laptop
herunterladen und müssen sie zunächst auf der SD-Karte speichern.
Aber dann können wir sie herunterladen und Tools wie einen SQL-Light-Browser verwenden.
Ich vermute, es ist Escalade Browser drei oder einfach das Kommandozeilentool für SQLite.
Und dann können wir auf diese Datenbank zugreifen und sie abfragen und so die Struktur herausfinden.
Wir können dies aber auch hier tun, da es möglicherweise
nicht vollständig initialisiert wurde oder kein Wert vorhanden ist.
Deshalb sollten wir auch den umgekehrten Weg gehen, aber
probieren Sie es doch einfach mal hier aus.
Ja.
Bis jetzt gibt es nichts Interessantes bis hier und hier.
Wieder haben wir eine weitere on create-Methode und dieses Mal haben
wir etwas p.w de p w Tabelle auf diese Weise.
Wir haben also die Tabelle p.w, und hier können wir sehen, wie SQL-Einträge erstellt werden.
Also gut.
Und auf diese wird nirgends verwiesen.
Es könnte sich also um ein statisches Feld handeln.
Werfen wir also einen Blick in diese Klasse hier drüben und wir finden sie hier.
Also gut, öffnen wir sie.
Perfekt.
Dies ist die endgültige Struktur unserer Datenbank.
Jetzt haben wir also alles fertiggestellt.
Wir haben die Datenbankdatei, die den Namen database trägt.
Ich bin mir nicht mehr sicher.
Das spielt eigentlich keine Rolle.
Dies ist also unsere Datenbank.
Ja.
Der Name der Datenbank war Teil der Vollmacht, so dass ich davon
ausgehe, dass der Anbieter ihn nachschlagen muss, falls er falsch ist.
Der Be-Provider, das ist der Name.
Und hier sehen wir nun, dass wir eine Tabelle haben.
Hier sind die Passwörter für die Tabellennamen.
Wir haben also eine Tabelle mit dem Namen Passwörter.
Und wir haben auch den Schlüssel für den Tabellennamen.
Und dieser hier ist jetzt interessant.
Schlüssel, weil, wenn Sie sich erinnern, der Inhalt, den Sie bezüglich dieser Schlüsseltabelle sind,
mit Schlüsseln referenziert worden ist, also ist die Referenz dieser Inhalt, den Sie Schlüssel.
Dies ist die Art und Weise, wie wir darauf zugreifen.
Diese Tabelle mit einem Inhaltsanbieter.
Wenn wir sie jedoch im Rahmen einer SQL-Injektion verwenden, müssen wir
genau den richtigen Namen dieser Tabelle verwenden, nämlich den Schlüssel.
Also nicht der inhaltliche Bezug.
Wir müssen den richtigen Tabellennamen verwenden.
Das hier ist einfach nur ein Alias für unseren Content Provider, um auf diese Tabelle zuzugreifen.
Also gut.
Ja.
Und lassen Sie mich das aufräumen.
Ja.
Und jetzt schauen wir mal, was für Einträge
wir haben. Wir haben E-Mail, Passwort, Service, Benutzername.
Und im Moment wissen wir nicht, ob sie im Pass oder im Schlüssel sind.
Hier haben wir wieder einen Reisepass.
Ja.
Interessant, aber sie heißen auch anders: großes P, kleines P.
Hier haben wir die PIN.
Und dann ja, das ist es, wonach ich gesucht habe.
Hier haben wir nun einen Tabellenschlüssel erstellt und wir können diese Tabelle sehen, sorry.
Dieser Tabellenschlüssel hat die Spalte password, die ein Text ist, der der
Primärschlüssel ist, und er hat auch einen Pin, der ein Text ist.
Diese hat nun zwei Spalten, nämlich Passwort und Pin, und beide sind Text.
Das könnte also bedeuten, dass sie im Klartext gespeichert werden.
Sie könnte beispielsweise auch verschlüsselt und base64-kodiert sein.
Dann würde dieser Textparameter auch Sinn machen.
Das ist also etwas, was wir noch herausfinden müssen, aber wir können bereits die Struktur unserer Tabelle sehen.
Unser Tabellenschlüssel hat also die Spalten Passwort und Pin.
Okay? Und dann haben wir diese Tabelle
hier drüben und schauen wir mal.
Ja.
Und das hier ist für unseren Reisepass.
Ja, das ist für unsere Pässe.
Und diese hat eine Menge Einträge.
Wir haben eine ID, die der Primärschlüssel ist.
So wird es in der Spalte Name ID sein, die auch in der Spalte Name Service sein wird.
Es wird in der Spalte Name, Benutzername, Reisepass stehen.
Interessant.
Noch einmal: Pass hier, Kleinbuchstaben hier, Großbuchstaben dort.
Und dieses Mal ist der Pass ein Klecks.
Das bedeutet also, dass es sich um binäre Daten handelt.
Die Daten werden also höchstwahrscheinlich verschlüsselt.
Ja.
Und zu guter Letzt haben wir noch diese E-Mail.
Also gut.
Und das sind die Dinge, die wir bereits herausgefunden haben, indem wir einfach ein paar Klassen zurückentwickelt haben.
Wir kennen also die Datenbank und den B-Anbieter.
Wir haben zwei Tische da drin.
Und die interessanteste ist die Schlüsseltabelle.
Aber das ist auch diejenige, die gesperrt wurde.
Wir können also nicht darauf zugreifen.
Also gut.
So weit, so gut.
Unser Angriffsvektor ist nun der folgende.
Der Schlüssel ist also verschlossen, aber das Schloss ist nur von außen zugänglich.
Der DB-Provider ist also exportiert worden.
Und wenn wir von außen kommen und versuchen, darauf zuzugreifen, dann wird
uns der Zugriff verweigert, wenn wir nicht die Erlaubnis dazu haben.
Aber wenn wir in der Lage sind, diese in der Tabelle Pässe abzufragen, dann sind wir schon drin.
Diese Sperre findet also nicht mehr statt.
Und wenn wir jetzt unsere eigene Syntax, unsere eigene SQL-Abfrage einschmuggeln können.
Ups.
Chris, ich habe wohl etwas anders geschrieben.
Das ist die Art und Weise, wenn Sie jetzt unsere eigene SQL-Abfrage in
diese Passwörter schmuggeln, dann könnten wir in der Lage sein, darauf zuzugreifen.
Dies ist also unser Angriffsplan.
Aber bevor wir das tun, wollen wir erst einmal herausfinden, wie wir mit diesem interagieren können.
Wie können wir also diese Tabellen und in diesem Fall die
Tabelle "Passwörter" abfragen? Weil die Schlüsseltabelle nicht abgefragt werden kann.
Und auch das werden wir jetzt herausfinden.
Also gut.
Machen wir es so.
Ja.
Zu diesem Zweck verwenden wir wieder die ADB-Shell.
Und dieses Mal verwenden wir nicht den Aktivitätsmanager.
Diesmal geht es um Inhalte.
Lassen Sie mich dieses Thema abschließen.
Auf den ersten Blick sieht es also nach einem totalen Chaos aus.
Komplexe Parameter.
Wir wissen im Moment nicht, was besonders verbindlich ist und solche Dinge.
Aber wir können die Sache ein bisschen einfacher machen.
Wenn der Text hier drüben beginnt, haben wir ein neues Kapitel.
Es handelt sich also um ADB Shell Content Insert.
Hier geht es also um das Einfügen neuer Daten.
Hier können wir sehen, dass wir aktualisieren, löschen und abfragen können.
Und dann haben wir Inhalte, die wir lesen, und einige andere Dinge.
Die zweite Hälfte kann im Moment einfach ignoriert werden, da es
hier um den Dateizugriff geht, der im nächsten Video besprochen wird.
Dann werden wir herausfinden, wie die Pfadüberquerung funktionieren wird.
Im Moment konzentrieren wir uns nur auf die erste Hälfte, die mit der Datenbank interagiert, und jetzt wissen wir,
dass wir es mit der Datenbank zu tun haben, zumindest für unseren Inhaltsanbieter hier drüben in diesem Beispiel.
Aber wir haben ihn hier, diesen einen, diesen DB-Inhaltsanbieter.
Also gut.
Okay, vielleicht sollten wir das auf der rechten Seite anbringen.
Lassen Sie uns das abschließen.
Ja.
Die Frage ist nun, wie können wir auf diese Tabellen
zugreifen? Hier haben wir also eine Datenbank, die in einem
geschützten Verzeichnis gespeichert ist, aber der Zugriff auf die Datenbank-IP
des Inhaltsanbieters ist verfügbar, weil sie als exportiert eingestellt wurde.
Es ist also sehr einfach, dies zu tun.
Alles, was wir tun müssen, ist, dass wir Inhalte verwenden und dann sehen wir,
Abfrage, Abfrage und dann müssen wir uns nicht um all diese komplexen Parameter kümmern.
Ich meine, wir wissen, was Schutz ist, wie und wo die Anweisung funktioniert
und solche Dinge, aber wir müssen uns nicht darum kümmern, denn wenn wir
keinen Parameter anwenden, dann wählen wir einfach alles aus dieser Tabelle aus.
Einfach, nicht
wahr? Ja.
Wie können wir also diese Tabelle ansprechen? Nun, alles, was wir
tun müssen, ist, Inhalte bereitzustellen und diese als Kommentar hier aufzuschreiben.
Der Inhalt und der Name der Behörde stimmen also mit diesem überein.
Und dann Schrägstrich und der Tabellenname.
So können Sie auf diese Tabelle zugreifen.
Und wir müssen dies nicht selbst tun, da dies bereits im DB Content Provider definiert ist.
Wenn wir also ein wenig nach oben scrollen, haben wir es hier.
Hier sehen wir also, dass die Inhaltsberechtigung und der Tabellenname perfekt sind.
Wir kopieren also einfach diesen Teil und fügen ihn hier ein.
So führen wir die Auswahl aller Passwörter in der Tabelle durch.
Schön, nicht wahr? Lass uns das
in 3 zu 1 machen.
Da haben wir es.
Sehr schön.
Wir sehen, dass wir den Benutzernamen und das Kennwort für den Dienst Banking blockiert haben.
Wir können die binären Daten daraus extrahieren, denn jetzt heißt es nur: "Okay,
das sind binäre Daten, die nicht angezeigt werden, aber wir können damit umgehen.
Diese Daten sind jedoch verschlüsselt, so dass wir keinen Vorteil daraus ziehen können, es
sei denn, wir können sie entschlüsseln, was im Moment nicht möglich ist, da
wir nicht wissen, wie das geht, und sie könnten auch mit dem Benutzerkennwort
geschützt sein, was es noch unmöglicher macht, wenn das Benutzerkennwort richtig gewählt wurde.
Das sind also viele.
Was wäre, wenn, und das wollen wir jetzt nicht diskutieren.
Wir werden einen separaten Abschnitt über diese Kryptographie einrichten.
Aber jetzt wollen wir erst einmal über die Anbieter von Inhalten sprechen.
Ja.
Also gut.
Zu guter Letzt haben wir noch diese E-Mail, die ein Informationsleck darstellt.
Und wenn Sie einen Blick auf die Struktur werfen, Unterstrich ID, Service,
Benutzername, Passwort, E-Mail, das ist genau das, was wir zurückentwickelt haben.
Alles, was wir also tun müssen, ist, der Zeile unseres Content Providers zu folgen, denn
dort wird definiert, wie man auf die Datenbank zugreift und wie die Datenbank erstellt wird.
Es könnte also einen Hinweis darauf geben.
Rechts.
Ja.
Dies ist also ein Weg, wie man mit diesem interagieren kann und was
passiert, wenn man versucht, auf die geschützten Seiten zuzugreifen und diese zu schützen.
Das ist der Schlüssel zu diesem hier.
Schauen wir also mal.
Jetzt wollen wir diesen mitnehmen.
Und hier bekommen wir jetzt einen Fehler.
Lassen Sie uns das ein bisschen größer machen.
Ja.
Erlaubnis verweigert.
Was wir erwarten.
Und wenn wir sehen, versuchen wir, auf die Schlüssel zuzugreifen, von denen dieser Prozess es wirklich nicht wichtig ist.
Wichtig ist nur, dass wir versuchen, von der Benutzer-ID 1000
aus darauf zuzugreifen, die unsere ADB-Shell hier drüben ist.
Die ADB-Shell hat also nicht die Berechtigung, dies abzufragen.
Wenn Sie Root-Rechte erhalten würden, wäre dies natürlich möglich.
Aber dann ist es auch kein Angriffsvektor mehr, denn dann könnten wir
einfach in das Datenverzeichnis gehen und direkt auf die Datenbank zugreifen.
Also gut.
Ja.
Innerhalb der ADB-Shell haben wir also keinen Zugriff, weil unsere
ADB-Shell nicht über diese beiden benutzerdefinierten Berechtigungen verfügt, diese beiden.
Also gut.
Sehen wir uns nun an, wie wir mit Hilfe einer SQL-Injektion dennoch auf diese Tabelle zugreifen können.
Und um ehrlich zu sein, könnte dies der einzige Anwendungsfall sein, in dem SQL-Injektion nützlich
ist, denn ansonsten haben wir dies mit den Passwörtern in der Tabelle in diesem gesehen.
Wir können also einfach auf diese Daten zugreifen, wenn der Inhaltsanbieter
exportiert wurde, und in den meisten Fällen trennt der Entwickler dies.
Der Entwickler erstellt also zwei Datenbanken, eine, die vollständig geschützt ist, und
eine, die für die Interaktion mit anderen Anwendungen exportiert werden kann.
Aber dann sind diese Daten nicht mehr so sensibel.
Und wenn Sie dort einen Fehler finden, macht das nichts, weil wir keinen Zugriff auf die andere Datenbank haben.
Also gut.
Das sind also die Dinge, denen wir am häufigsten begegnen.
Aber lassen Sie uns trotzdem darüber sprechen, denn wenn Sie diesen
Fall haben, dann könnte es ein absolut schöner Fund sein.
Also gut.
Wie können wir das also jetzt
missbrauchen? Nun, wenn Sie zurückgehen.
Und dann haben wir noch das hier.
Und das hier drüben.
So wird aus der Entdeckung und der SQL-Syntax eine neue gebildet.
Und das ist etwas, was wir wohl noch einmal auf dem Grafiktablett diskutieren sollten.
Ich werde also SQL-Injection auf einer sehr hohen Ebene diskutieren.
Für den Fall, dass Sie damit nicht vertraut sind und eine erweiterte Version mit union
blind time based stack queries und noch mehr error based, error based smoothing haben möchten.
Wenn Sie sie alle in einem separaten Video haben möchten, schreiben Sie mir bitte eine Nachricht
in den Kommentaren unter diesem Video und ich werde ein Bonusvideo zum Thema SQL-Injection hochladen.
Aber das ist etwas, das dieses Video im Moment sehr stark erweitern würde, und deshalb,
ja, wenn Sie daran interessiert sind, würde ich das teilen und Ihnen diese Informationen geben.
Aber wenn du das schon kennst, wäre es super langweilig für dich.
Wir haben das also nur auf hohem Niveau diskutiert.
Ja.
Aus dieser Abfrage mit diesen Parametern und dieser, dieser und dieser, dieser und dieser und
einer skalierten Syntax wird also eine Abfrage gebildet, die wie die folgende aussehen könnte.
Dies ist übrigens der URI, den wir an diesen übergeben, und der URI, den wir
übergeben müssen, ist Passwörter, weil dies die Tabelle ist, auf die wir zugreifen können.
Im Moment sind die Schlüssel blockiert, so dass wir Zugang dazu haben oder Passwörter dafür bereitstellen müssen.
Ja.
Und dann haben wir eine Where-Klausel, die im Moment einfach ignoriert werden kann, weil
hier diese Auswahlhandlungen und solche Dinge normalerweise bei einer SQL-Injection verwendet werden würden.
Aber hier können wir diesen Produktionsteil direkt definieren, d.h. wir können
direkt eine SQL-Syntax in diese Abfrage einfügen, was absolut erstaunlich ist.
Wir könnten also Folgendes tun: Wenn wir eine Projektion bereitstellen, etwa
diese Projektion und eine einzelne Tastatur, dann haben wir eine Auswahl.
Ups.
Ja, schreiben wir es in diese Ecke.
Das ist okay, wählen Sie aus.
Dann haben wir das einzelne Zitat in dieser Spalte von.
Und so weiter, und ein einzelnes Anführungszeichen wird die Abfrage unterbrechen.
Die Skalensyntax wartet also irgendwo auf ein weiteres einzelnes Zitat.
Andernfalls wird dieses from in ein einfaches Anführungszeichen eingefügt, was
bedeutet, dass es als eine Zeichenkette behandelt werden könnte.
Wenn Sie also nur ein einfaches Anführungszeichen haben, erhalten
wir hier einen Fehler, weil das einfache Anführungszeichen fehlt.
Wir fangen die ursprüngliche Anfrage ab und schließen sie im Moment nicht.
Dies führt also zu einem Fehler.
Das wollen wir herausfinden.
Also lassen Sie uns das abschließen.
Ja.
Lassen Sie mich diese Grafikvorlage ganz schnell aus dem Weg räumen.
Also gut.
Wie können wir also diesen Schutz anwenden? Nun, wenn Sie
Inhalte verwenden und dann einen Blick in das Hilfemenü werfen.
Aber wir haben Barry hier drüben und dann haben wir diese Projektion,
so dass wir die Projektion verwenden können, um unsere Projektion anzuwenden.
Wenn wir dies auf folgende Weise anwenden.
Dann können wir sehen, dass das Terminal hier drüben erwartet, die Zeichenkette jetzt zu beenden.
Und genau das Gleiche passiert in der SQL-Syntax.
Wenn wir dies also jetzt schließen, erhalten wir einen Fehler bei der Auswahl aus dem Durchlauf.
Wie lautet der Signalcode? Wenn Sie ihn auf diese
Weise einfügen, wird er die Bestimmung durcheinander bringen.
Daher müssen wir links und rechts neben dem einfachen Anführungszeichen doppelte Anführungszeichen verwenden.
Dadurch wird unser ADB-Shell-Terminal umgangen und ein einfaches Anführungszeichen direkt in die SQL-Syntax eingefügt.
Also gut, machen wir das und schauen wir, was passiert.
Oh, schön.
Unerkanntes Token hier.
Wir können genau sehen, wie wir es vorher aufgeschrieben haben.
Haben wir sie noch?
Schauen wir mal.
Ja.
Hier haben wir sie also noch.
Wählen Sie und diese.
Hier haben wir also die Abfrage geöffnet.
Und jetzt beschwert es sich über diesen Weg, dass er nicht eingeschlossen ist.
Wir haben also Ihre ursprüngliche Anfrage unterbrochen.
Also gut.
Wie können wir das nutzen? Nun, das ist jetzt unser Punkt,
an dem wir unsere eigene Syntax in die ursprüngliche Syntax einfügen
können, und danach müssen wir nur noch die ursprüngliche Abfrage korrigieren.
Und das kann man ganz einfach mit einem Kommentar erreichen.
Ich möchte Ihnen das hier zeigen.
Wenn wir also etwas wie das hier in die Projektion einfügen, brauchen
wir kein einfaches Anführungszeichen mehr, also lassen wir das einfache Anführungszeichen weg.
Wenn Sie nun etwas wie dieses einfügen.
Von Pässen, von Schlüsseln.
Und wir müssen uns um den Schlüssel kümmern.
Also wie es richtig geschrieben wird, also Großbuchstaben Kleinbuchstaben und es sind keine Tasten.
Keys ist der Verweis im Inhalts-URI, aber der Tabellenname ist der Schlüssel.
Und hier müssen wir genau sein, denn wir müssen den Tabellennamen ansprechen.
Wir befinden uns nicht mehr innerhalb der URI des Inhaltsanbieters.
Ja.
Wenn wir also unsere eigene SQL-Syntax einfügen, müssen wir bei der SQL-Syntax bleiben oder
uns an sie halten, was bedeutet, dass SQL die ursprünglichen Werte kennen muss.
Ja.
Zurück zu diesem Thema.
Wenn wir den Schutz als von Schlüssel und dann zu Bindestrichen bereitstellen,
wird dies den Rest auskommentieren, was zu der folgenden Syntax führt.
Und so haben wir hier die Auswahl.
Und jetzt fügen wir alles von Schlüssel, Bindestrich, Bindestrich ein.
Und das wird gleich zu folgendem führen.
Nach dem, was wir jetzt haben, sehen wir mal, was wir von den Pässen haben.
Und gut.
Und so weiter.
Also alles, was danach kommt, wird jetzt auskommentiert.
Dies wird also einfach ignoriert.
Und die einzige Syntax, die ausgeführt wird, ist diese hier.
Wählen Sie also alle aus Schlüssel und dies über die Kennworttabelle, auf die
zugegriffen werden kann, da diese nicht durch die benutzerdefinierte Benutzerberechtigung geschützt ist.
Also gut, probieren wir es aus.
Okay, also sehen wir mal.
Hier drüben.
Ja.
Und Projektion alles aus Schlüssel.
Und das ist alles 3 zu 1.
Ja, ich vermisse den Bindestrich, weil dann jetzt sind wir mit können
wir sehen, diese perfekt wählen Sie alle aus Schlüssel aus Pass.
Dies ist als Q-Syntax nicht gültig.
Deshalb müssen wir sie auskommentieren.
Das war natürlich beabsichtigt.
Schauen wir also mal.
3 zu 1.
Sehr schön.
Wir haben das Passwort im Klartext und auch abhängigen Klartext.
Erstaunlich.
Richtig.
So können wir also die benutzerdefinierte Benutzerberechtigung auf der Grundlage einer SQL-Injektion umgehen.
Und um ehrlich zu sein, ist dies der einzige Anwendungsfall, bei dem ich mir vorstellen kann, dass
ein australischer Abschnitt in unserer Android-App nützlich sein könnte, denn sonst könnten wir dies ohnehin abfragen.
Richtig.
Also gut.
Nichtsdestotrotz denke ich, dass dies ein ziemlich erstaunlicher Angriffsvektor sein könnte, wenn der
Entwickler alles in eine einzige Datenbank packt und neben dieser SPL-Injektion auch noch
einen teilweisen Zugriff auf diese Datenbank ermöglicht, haben wir noch ein weiteres Problem.
Und dieses Thema ist hier drüben.
Diese benutzerdefinierte Berechtigung wird also für die Pfad-Slash-Schlüssel
definiert, d.h. wenn Sie versuchen, auf diese zuzugreifen.
Am Anfang, denke ich.
Ja.
Wenn Sie versuchen, auf diesen Inhalt mit
den Pfad-Schrägstrich-Tasten zuzugreifen, wird die Benutzerberechtigung geprüft.
Und wenn wir sie nicht haben, wird unser Zugang gesperrt.
Aber dieser Pfad wurde nicht in einem regulären Ausdruck definiert, was bedeutet, dass
wir auf diese Schlüssel auf eine andere Art und Weise zugreifen, zum Beispiel.
Vier.
Lassen Sie uns diese Inhaltsabfrage hier löschen.
Dies ist also das normale Verhalten, das verweigert wird.
Oh, ja.
Bindestrich, Bindestrich.
Das war's.
Ja.
Zugriff oder Erlaubnis verweigert.
Was aber, wenn wir auf folgende Weise
darauf zugreifen? Also mit einem Schrägstrich? Na
ja, wir bekommen immer noch das Passwort.
Wenn der Entwickler also keinen regulären Ausdruck zur Verfügung stellt, wenn er versucht, den Zugriff auf der
Grundlage von Schrägstrichschlüsseln, einer Hardcopy oder eines hartkodierten Wertes zu blockieren, dann können wir dies möglicherweise umgehen.
Aber um ehrlich zu sein, bin ich mir nicht sicher, ob es noch möglich
ist, eine solche Anwendung zu schreiben und sie in den Play Store hochzuladen.
Google könnte also den Upload dieser Anwendung in den offiziellen Store verweigern,
und deshalb würde ich davon ausgehen, dass dies nicht mehr oft vorkommt.
Für den Fall, dass Sie denken, okay, können wir einfach Schrägstrich Schlüssel und Schrägstrich Schlüssel Schrägstrich wie in Pfad.
Das funktioniert nicht, denn wir können hier viele Schrägstriche am
Ende anbringen und dann können wir immer noch darauf zugreifen.
Die einzige Lösung für dieses Problem besteht darin, einen regulären Ausdruck zu verwenden und nicht nur zu prüfen.
Schrägstrich-Tasten.
Wir sollten erst die Schrägstrichschlüssel und dann alles andere überprüfen.
Also gut.
Ja.
Das war's dann auch schon mit der SQL-Injektion.
Schauen wir uns nun an, wie wir mit dem Inhaltsanbieter interagieren können.
Schauen wir uns also an, wie wir einfügen, löschen und aktualisieren können.
Und wir haben bereits gesehen, ja, einfügen löschen und aktualisieren bestimmte
Einträge in der Datenbank, weil die Syntax ist ein wenig komplex.
Ja.
Aber wenn Sie das gesehen haben, ist es auch in einem Spickzettel enthalten.
Es ist gar nicht mehr so schwer, mit Hilfe des Hilfemenüs wieder darauf zuzugreifen.
Also gut.
Schauen wir also mal.
Wir haben diese Tische passieren lassen.
Was ist das hier? Okay, mal sehen,
wie wir hier neue Werte einfügen können.
Also.
Da wir Inhalte verwenden, müssen wir die Hilfe nutzen, da dies sonst nicht möglich ist.
Es ist ein bisschen kompliziert, aber wir werden das hier in Ordnung bringen.
Wir haben den Inhalt eingefügt und jetzt haben wir den Stress-URI. Wir
müssen also unsere Passworttabelle bereitstellen und diese Benutzer-ID kann man wohl überspringen.
Aber wir haben das übersprungen und jetzt haben wir diese Bindung und das ist wichtig bindet einen typisierten
Wert an eine Spalte und ist in der folgenden Weise formatiert Spalte, Name, Typ und dann der Spaltenwert.
Das sieht vielleicht ein bisschen kompliziert aus, aber wenn wir den
Pass öffnen, also den hier drüben, dann können wir das machen.
Wir beginnen bereits mit dem Einfügen für diese große Tabelle, was wohl die komplexeste Syntax ist.
Seien Sie also hinterher nicht frustriert.
Das wäre viel einfacher.
Also gut.
Lassen Sie uns das also trotzdem tun.
Wenn Sie also einen neuen Eintrag einfügen wollen, müssen
wir einen URI angeben, und zwar diesen hier.
Ja.
Ich sehe meinen Tippfehler.
Ja.
Und jetzt müssen wir diese seltsame Bindung nutzen.
Und ich denke, es gibt immer ein Beispiel.
Ja.
Hier, wir haben es.
Also das hier drüben.
Name ist die Spalte.
Name.
Typ ist String.
Und dann haben wir den Spaltenwert, der die neuen Einstellungen darstellt.
Ja.
Wenn Sie also einen neuen Eintrag einfügen wollen, müssen Sie wie folgt vorgehen.
Underscore ID kann nicht verwendet werden, da es sich um den
Index und den Primärschlüssel handelt und dieser automatisch erhöht wird.
Dies kann also übersprungen werden, aber dann muss ein neuer Dienst eingegeben werden.
Unser Dienst ist also der Name der Spalte.
Dann müssen wir den Typ definieren, der string ist, und dann müssen wir den Wert
definieren, der der neue Wert ist, den wir in diesem Fall hat einfügen wollen.
Also gut.
Schauen wir mal.
Wir wollen einen neuen Benutzernamen definieren.
String und der Benutzername ist durchgesickert, und dann wollen wir ein neues Passwort definieren.
Jetzt wird es interessant.
Ich vermute, es ist B für Byte, aber ich bin mir nicht sicher.
Und wir bieten null.
Und dann B, bei dem bin ich mir nicht sicher.
Vielleicht muss ich das später noch einmal nachschlagen.
Aber lassen Sie uns das erst einmal ausprobieren.
Ja.
Dann müssen wir die E-Mail-Spalte neun mit dem Wert String verwenden, und dies ist zumindest gehackt.
Also gut.
Mal sehen, ob das funktioniert.
Also geben wir das 3 zu 1 ein.
Wir erhalten keine Fehlermeldung, was gut ist, um zu überprüfen, ob dies funktioniert.
Lassen Sie uns dies noch einmal vergleichen.
Ja.
Sehr schön.
Wir können also sehen.
Ja.
Wir haben einen neuen Eintrag eingefügt.
Das ist.
Leider kann das nicht hilfreich sein, da es sich bei diesem Kennwort um
binäre Daten handelt. Wenn es verschlüsselt ist und beim Einloggen nicht entschlüsselt
werden kann, weil es keine gültige Verschlüsselung ist, erhalten wir einen Fehler.
Trotzdem wollen wir mal sehen, ob wir dieses Kennwort auf leer setzen können.
Vielleicht klappt es ja dann.
Dies könnte also auch ein Weg sein, um in die Bewerbung einzusteigen.
Und nun wollen wir sehen, wie wir dieses Passwort aktualisieren können.
Wir können.
Wenn Sie also das Kennwort ändern wollen, müssen wir eine neue Abfrage verwenden,
nämlich die Aktualisierungsabfrage, was ziemlich gut ist, denn deshalb sind wir ja hier.
Also Aktualisierung des Inhalts.
Schauen wir uns an, wie das Update hier verwendet wird.
Ja.
Auch hier müssen wir die URI anwenden.
Ups, die vollständige URI.
Ja.
Und mal sehen.
Aktualisierung.
Aktualisieren ist gut, denn wir haben in unserer Anweisung und wir
haben unsere binden, binden Sie noch einmal Spaltenname, Typ, neuen Veranstaltungsort.
Bind ist also der aktuelle Name, der unser Passwort ist.
Der Typ D ist B und wir wenden keinen Wert an.
Ich hoffe, dass dies auf diese Weise funktioniert.
Wenn Sie also keinen Wert darauf legen, hoffe ich, dass es nicht in Ordnung ist.
Und dann müssen wir definieren, welche Abfrage wir aktualisieren wollen, sorry, welche Spalte.
Deshalb müssen wir die Aussage quadrieren, bis wir sie haben.
Okay, kopieren wir dieses OC und geben nun weiter, was nicht möglich ist.
Das könnte zu riskant sein.
Sagen wir, wo a d gleich ist.
Das ist also auch unser Rollenausweis.
Und jetzt wollen wir das Passwort dort aktualisieren.
Mit einem neuen Bisswert, der nichts ist.
Ich bin nicht sicher, ob das funktioniert.
Schauen wir mal.
3 zu 1.
Keine Pfeile.
Lassen Sie es uns noch einmal tragen.
Es scheint also nicht zu funktionieren, leider.
Es könnte sein, dass wir das Kennwort auf diese Weise aktualisieren und einen neuen Wert eingeben müssen.
Um das herauszufinden, müssen wir also noch etwas ändern.
Ändern wir also diesen Dienst, der sich in der Zeichenkette befindet, und wir wollen ihn in diesem Teil ändern.
Das ist also der Name der Spalte.
Und jetzt hat es den Wert.
Hecht Und wir nennen das wieder Hecht, und wir wollen
den Dienst, der schon den Namen Hecht hat, diesen ändern.
Schauen wir also, wo der Dienst steht.
Hecht.
Das sollte also auf jeden Fall funktionieren.
Ich bin mir ziemlich sicher, dass es so funktioniert.
Schauen wir mal.
OC-Inhaltsaktualisierung eine 3 zu 1.
Kein Fehler.
Aber ich meine, wir haben bis jetzt noch keine Fehler gemacht.
Ja.
Es handelt sich um ein Problem mit dem Passwort und dem Byte-Wert, denn wie wir sehen können, haben wir den Namen geändert.
Wir können auch den Namen des ersten Kontos ändern, zu dem wir keinen Zugang haben.
Also Service.
Aber kann Hecht den Namen nicht lesen? Also
wollen wir jetzt den Namen der Bank ändern.
Also gut, mal sehen.
Ja, sie wurde geändert.
Schauen wir uns also diese Anwendung an und überprüfen wir sie.
Hier haben wir also den Eingabetext der App und ich hoffe, es war dieses Passwort.
Schauen wir mal.
Ja.
Oh, schön.
Wir haben zwei geschaffen.
Also.
Das ist interessant.
Hier sehen wir wieder einen Grafen Hecht und Hecht.
Wir können also vorhandene Daten dort ändern, was nicht gut ist, denn ja.
Selbst wenn das Kennwort verschlüsselt ist, können wir möglicherweise einen Nullwert anwenden.
Ich werde das überprüfen und in den Spickzettel aufnehmen, wenn es eine Lösung für dieses Problem gibt.
Indem wir also ein neues Konto einfügen, können wir dieses hier vielleicht umgehen.
Oh, ja.
Mir ist klar, dass selbst wenn wir ein neues Konto einrichten könnten, dieses Passwort ein anderes ist.
Das ist also nicht das Passwort der Anwendung.
Es ist das Passwort des Passworts.
Sicher.
Das tut mir sehr leid.
Ich war verwirrt, weil diese beiden Tabellen denselben Eintrag enthielten.
Mein Fehler.
Ja.
Selbst wenn wir also ein neues Konto erstellen könnten, können wir den Anmeldebildschirm nicht
umgehen, da der Anmeldebildschirm in der Schlüsseltabelle und nicht in der Kennworttabelle definiert wird.
Also gut.
Ja.
Nicht um Sie zu verwirren, sondern um die Sache richtig zusammenzufassen.
Ich meine, wir könnten unsere Schlüssel verwenden, um den Protokollierungsbildschirm zu umgehen.
Und genau das ist es, was wir hier tun.
Deshalb habe ich diese Sequenz jetzt hinzugefügt.
Wir überprüfen einfach, welche Einträge in unserer Schlüsseltabelle vorhanden sind, indem wir den Bypass verwenden.
Und dann können wir aktualisieren oder auch neue einfügen.
In diesem Fall fügen wir einfach einen neuen Eintrag ein.
Und dann ist es ein bisschen interessant, weil es nur einen Eintrag für diese ganze Anwendung gibt, weil wir
nicht mehrere Benutzer haben können, was bedeutet, dass wir jetzt erhöhen müssen, aber wir können sehen, dass das Passwort,
das wir eingegeben haben, verwendet werden kann, um sich in diese Anwendung einzuloggen, aber wenn wir den Schlüssel stabil
manipulieren können, dann meine ich, ja, wir könnten einfach das ursprüngliche Passwort auslesen und uns in diese Anwendung einloggen.
Deshalb habe ich am Anfang noch nicht als S im
Bypass gezählt und werde es auch jetzt nicht tun.
Ja.
Wenn wir also das Passwort auslesen, brauchen wir es nicht
zu umgehen, indem wir die alten Einträge eingeben oder aktualisieren.
Also gut.
Ich bin perfekt.
Ja.
Zu guter Letzt haben wir noch diesen Inhalt zu löschen.
Warum haben wir
es? Dieses hier.
Inhalt löschen.
Wie funktioniert das also? Okay, wir müssen
nur den Wortlaut der Erklärung angeben.
Okay, das ist einfach.
Kommen wir zurück zu den Passwörtern.
Ja.
Löschen wir nun zum Beispiel den zweiten Eintrag, den hier drüben, den Inhalt und dann.
Urin löschen.
Dann müssen wir diese in diesem Urin bereitstellen.
Und ich denke, wir müssen vorsichtig sein, wenn Sie die Eingabetaste drücken.
Ich bin mir nicht sicher, ob es möglich ist, alles zu löschen, was dort steht.
Nun wollen wir sehen, wo.
Also Inhalt löschen und dann fügen wir einfach diesen hier ein.
Ja.
Nun, und jetzt müssen wir diesen Datenbankeintrag identifizieren.
Also, ja.
Wo Dienst.
Dienst ist.
Hecht wieder.
Och.
Es sollte verschwinden, denke ich.
Vielleicht müssen wir diese Sichtweise auffrischen.
Wenn Sie also in die Einstellungen gehen, vielleicht und zurück.
Ja.
Wie Sie sehen können, wurde sie gelöscht.
Also gut.
Ich schätze, ich habe nicht geklickt.
Ja, ich glaube, ich habe es verpasst.
Klicken Sie.
Wir haben also gesehen, wie eine SQL-Injektion bei Inhaltsanbietern funktioniert.
Wir haben gesehen, wie wir Einträge einfügen, aktualisieren und löschen können, und
wir haben auch gesehen, dass wir hier einen regulären Ausdruck angeben sollten.
Was wir bisher nicht gesehen haben, ist ein B, das dieses Teil verwendet.
Und ich denke, ja, lassen Sie uns das in einem ganz kurzen Bonusvideo nachholen.
Wir werden also eine eigene Anwendung schreiben, die hier die
Erlaubnis erteilt, und dann einfach auf diese Schlüssel zugreifen.
Also gut.
Ja.
Falls Sie Fragen haben, können Sie gerne einen Kommentar unter diesem Video hinterlassen.
Ansonsten freue ich mich darauf, Sie im zweiten Teil dieses Videos
zu sehen, wo wir dies mit unserer eigenen bösartigen Anwendung ausnutzen.
Wir sehen uns also dort.