Auf dieser Seite werden verschiedene Methoden beschrieben, mit denen Sie prüfen können, ob das auf Ihrem Android-Gerät installierte APK der im Anspruchstellermodell gemachten Behauptung entspricht. Dazu müssen Sie das betreffende APK von Ihrem Gerät abrufen, die Codeintegrität prüfen und einen Log-Inclusion-Nachweis für das extrahierte Artefakt ausführen.
Überprüfungsverfahren
Ein Transparenzprotokoll wird mit einem Merkle-Baum aus Hashes implementiert. Ein Endknoten enthält Daten und ein übergeordneter Knoten den Hash seiner untergeordneten Knoten.
Im Grunde werden zwei Berechnungen auf dem Merkle-Baum durchgeführt, um die manipulationssichere Eigenschaft von Transparenz-Logs zu überprüfen: der Einschlussnachweis und der Konsistenznachweis. Ersteres beweist, dass das Protokoll einen Eintrag enthält, der einer bestimmten APK-Version entspricht. Der Logeintrag enthält einen Hash, der SHA256-Digest des Codesignatur-Tokens in Form eines JSON Web Tokens (JWT) ist, das aus den entsprechenden APKs abgerufen werden kann. Letzteres beweist, dass der neue Prüfpunkt (kryptografisch) mit der vorherigen Version des Baums übereinstimmt, wenn dem Baum neue Einträge hinzugefügt werden.
Führen Sie zum Überprüfen eines abgedeckten APK einen Test zum Nachweis der Einbeziehung anhand eines Zeugen-Checkpoints durch. Wir planen, dieses Protokoll mit einem öffentlichen Zeugennetzwerk zu integrieren, das ein standardisiertes Zeugenprotokoll verwendet. Dadurch wird ein Zeugen-Checkpunkt erstellt, der für die Konsistenz des Protokolls sorgt.
Wenn Sie sich selbst davon überzeugen möchten, dass das APK auf Ihrem Gerät den im Modell des Anspruchstellers gemachten Angaben entspricht, lesen Sie den Artikel unten.
Nachweis der Inklusion
Android-Nutzer können prüfen, ob ein abgedecktes APK auf ihrem Gerät im Log enthalten ist. Dazu müssen sie zuerst das APK und die zugehörigen Metadaten extrahieren und dann den neu berechneten Root-Hash mit dem im veröffentlichten Checkpoint enthaltenen Root-Hash vergleichen. Wenn sie übereinstimmen, kann der Android-Nutzer sich auf einige im Bedrohungsmodell beschriebenen Schutzmaßnahmen verlassen.
APK-Einschluss im Log prüfen
Wie bereits erwähnt, finden Sie die Liste der derzeit abgedeckten APKs auf der Übersichtsseite.
Voraussetzungen für die Bestätigung
Bevor Sie prüfen, ob das APK, das Sie gerade von Ihrem Gerät extrahiert haben, unseren Angaben entspricht, benötigen Sie die folgenden Tools. Installieren Sie sie von einem mit dem Netzwerk verbundenen Computer aus.
Android Debug Bridge (ADB)
ADB ist ein Tool, das mit einem Android-Gerät kommuniziert. Es ist auf der Website der Android SDK-Plattformtools verfügbar.
bundletool
bundletool ist ein Tool, mit dem ein Android App Bundle (AAB) erstellt wird. Außerdem können Sie damit ein AAB in APKs konvertieren, die auf Geräten installiert werden können.
Sie können es von GitHub herunterladen.
Androguard
Androguard ist eine Sammlung von Tools, die zum Analysieren von APKs verwendet wird. Es kann von der Androguard-Website heruntergeladen und installiert werden.
Prüfer für Nachweise zur Inklusion
Dies ist ein Go-Modul, das wir in einem Git-Repository im Android Open Source Project (AOSP) mit dem Namen avb veröffentlicht haben.
Es kann das APK-Transparenzprotokoll der Google-Systemdienste abfragen und ausgeben, ob ein Paket im Protokoll enthalten ist.
Ein Beispiel für die Verwendung finden Sie in einem späteren Abschnitt.
Wenn Sie dieses Tool herunterladen möchten, müssen Sie zuerst das avb-Repository klonen.
computer:~$ git clone https://android.googlesource.com/platform/external/avb
Den Quellcode des Verifiers finden Sie im Repository avb unter tools/transparency/verify.
Nutzlast für die Überprüfung erstellen
Um zu bestätigen, dass das APK, das Sie gemäß unseren Angaben von Ihrem Gerät extrahiert haben, echt ist, müssen Sie eine Protokollnutzlast aus Informationen erstellen, die aus dem APK stammen.
Prüfen Sie zuerst, ob adb auf Ihrem Gerät verwendet werden kann. Aktivieren Sie dazu die ADB-Fehlerbehebung auf Ihrem Gerät.
Suchen Sie dann nach der APK-Datei auf Ihrem Gerät. In diesem Leitfaden verwenden wir die APK Android System Key Verifier (com.google.android.contactkeys) als Beispiel.
computer:~$ adb shell pm list packages -f | grep contactkeys
package:/data/app/~~i5WYSO4PuAAv798-eHdM7A==/com.google.android.contactkeys-PQCKjnn7xDqjeVhcUDibBA==/base.apk=com.google.android.contactkeys
Wenn die Android System Key Verifier APK auf Ihrem Gerät installiert ist, gibt der Befehl oben einen Pfad zurück, der angibt, wo sie auf Ihrem Gerät installiert ist. Andernfalls wird keine Ausgabe angezeigt.
Laden Sie das APK dann mit diesem Befehl von Ihrem Android-Gerät auf den Computer herunter, auf dem Sie arbeiten. Der tatsächliche Speicherort und der APK-Dateiname auf Ihrem Gerät können variieren:
computer:~$ mkdir -p /tmp/testdir && cd /tmp/testdir
computer:/tmp/testdir$ adb pull /data/app/~~i5WYSO4PuAAv798-eHdM7A==/com.google.android.contactkeys-PQCKjnn7xDqjeVhcUDibBA==/base.apk ./contactkeys_candidate.apk
Um den Paketnamen des gerade heruntergeladenen APK abzurufen und zu überprüfen, müssen Sie es zuerst entpacken, da es sich bei einem APK letztlich um eine spezielle Art von ZIP-Datei handelt.
computer:/tmp/testdir$ mkdir extracted && unzip contactkeys_candidate.apk -d extracted/
In diesem Schritt werden alle Dateien, aus denen das APK besteht, entpackt. Der Paketname und die Version finden Sie im Manifest des APK, das sich normalerweise in einer Datei mit dem Namen AndroidManifest.xml befindet.
Die resultierende Manifestdatei ist jedoch in binärer Form, die nicht für Menschen lesbar ist. Um die binäre XML-Datei in eine visuell lesbare Form umzuwandeln, verwenden wir das Tool axml aus der androguard-Suite, das im Abschnitt Voraussetzungen installiert werden muss.
computer:/tmp/testdir$ androguard axml extracted/AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1413" android:versionName="1.48.688082145" android:compileSdkVersion="35" android:compileSdkVersionCodename="VanillaIceCream" android:requiredSplitTypes="" android:splitTypes="" package="com.google.android.contactkeys" platformBuildVersionCode="35" platformBuildVersionName="VanillaIceCream">
Anhand der obigen Ausgabe können wir jetzt sicher sein, dass der Paketname dieses APKs com.google.android.contactkeys und die Versionsnummer (versionCode) 1413 ist.
Jetzt suchen wir im APK nach der Codetransparenzsignatur. Es sollte sich um eine Datei mit dem Namen code_transparency_signed.jwt handeln, die sich im Ordner META-INF unter den anderen aus dem APK extrahierten Dateien befindet.
computer:/tmp/testdir$ sha256sum extracted/META-INF/code_transparency_signed.jwt
1779a2aee029112c2c9bfc9390b9678f3e5f4595b39705e8528dd522e8042f11 code_transparency_signed.jwt
Mit diesem Hash-String haben wir jetzt alle Informationen, die zum Zusammenstellen einer Log-Nutzlast gemäß dem im Abschnitt Loginhalt beschriebenen Format erforderlich sind. In diesem Beispiel sollte eine entsprechende Protokollnutzlast so aussehen:
1779a2aee029112c2c9bfc9390b9678f3e5f4595b39705e8528dd522e8042f11
SHA256(Signed Code Transparency JWT)
com.google.android.contactkeys
1143
Beachten Sie auch das Zeilenumbruchzeichen nach der Paketversion.
Sie können den Inhalt in einer Datei speichern, z. B. payload.txt. Das ist später beim Test zur Prüfung der Inklusion hilfreich.
Authentizität der APK-Codesignatur prüfen
Jetzt sollten wir die Authentizität des im APK eingebetteten Codesignatur-Tokens überprüfen. Dazu verwenden wir bundletool und den öffentlichen Schlüssel des Schlüsselpaars, mit dem es ursprünglich signiert wurde. Sie werden in jedem Abschnitt der jeweiligen APKs veröffentlicht. Angenommen, Sie haben das Zertifikat für den öffentlichen Schlüssel (z.B. für den Android System Key Verifier) in einer Datei namens signing_cert_pubkey.pem gespeichert, folgen Sie der Anleitung unten, um die Codesignaturprüfung durchzuführen.
Erstellen Sie zuerst ein ZIP-Archiv und fügen Sie das entsprechende APK hinzu.
computer:/tmp/testdir$ zip -u test.zip contactkeys_candidate.apk
zip warning: test.zip not found or empty
adding: contactkeys_candidate.apk (deflated 58%)
computer:/tmp/testdir$ file test.zip
test.zip: Zip archive data, at least v2.0 to extract, compression method=deflate
Wir können jetzt den Befehl check-transparency von bundletool verwenden, um zu prüfen, ob die im Kandidaten-APK eingebettete Codesignatur mit der veröffentlichten übereinstimmt.
computer:/tmp/testdir$ java -jar BUNDLETOOL_INSTALL_PATH/bundletool-all-version.jar check-transparency \
--mode=apk \
--apk-zip=test.zip \
--transparency-key-certificate=signing_cert_pubkey.pem
APK signature is valid. SHA-256 fingerprint of the apk signing key certificate (must be compared with the developer's public key manually): D9 E1 73 5B 2A 39 51 27 3A 87 35 B7 66 9E F1 9E F5 3A F1 C1 27 5C BA 31 39 3C 18 40 8B 03 79 D0
Code transparency signature verified for the provided code transparency key certificate.
Code transparency verified: code related file contents match the code transparency file.
Die Ausgabe des Befehls oben sollte zeigen, dass sowohl die Codetransparenzsignatur als auch die Codetransparenz bestätigt sind.
Wenn dies nicht der Fall ist, z. B. wenn eine Ausgabe wie Code transparency verification failed because the provided public key
certificate does not match the transparency file angezeigt wird, ist die Codeintegrität des betreffenden APK möglicherweise beeinträchtigt und Sie sollten dem APK nicht vertrauen.
Prüfen Sie, ob Sie sie mit dem richtigen öffentlichen Schlüsselzertifikat vergleichen.
Wenn alles andere in Ordnung ist, bedeutet das, dass die Authentizität der Codesignatur für die APK bestätigt wurde, die Sie prüfen.
Paketeinschluss prüfen (Inclusion Proof)
Mit der zuvor erstellten Nutzlast können Sie jetzt testen, ob das betreffende Paket in das Transparenzprotokoll aufgenommen wurde.
Ein Tool zum Nachweis der Aufnahme wurde im avb Repository des Android Open Source Project veröffentlicht. So führen Sie den Befehl aus:
computer:external/avb/tools/transparency/verify$ PAYLOAD_PATH=PATH_TO_PAYLOAD_DIR/payload.txt
computer:external/avb/tools/transparency/verify$ go build cmd/verifier/verifier.go
computer:external/avb/tools/transparency/verify$ ./verifier --payload_path=${PAYLOAD_PATH} --log_type=google_system_apk
Der Verifier verwendet den entsprechenden Checkpoint und den Log-Inhalt (im Kachelverzeichnis), um zu prüfen, ob sich Ihre APK-Nutzlast im Transparenzprotokoll befindet und tatsächlich von Google veröffentlicht wurde.
Die Ausgabe des Befehls wird in stdout geschrieben:
OK. inclusion check success!, wenn der Code des Pakets im Protokoll enthalten ist,FAILURE, wenn dies nicht der Fall ist.