Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Vollständige Überprüfung der APK-Transparenz von Google-Systemdiensten

Auf dieser Seite werden verschiedene Methoden beschrieben, mit denen Sie sicherstellen können, dass das auf Ihrem Android-Gerät installierte APK mit der Behauptung im Claimant Modelübereinstimmt. Dazu wird das betreffende APK von Ihrem Gerät abgerufen, die Codeintegrität geprüft und ein Log-Einschlussnachweis für das extrahierte Artefakt durchgeführt.

Bestätigungsprozess

Ein Transparenzlog wird mit einem Merkle-Baum implementiert, der aus Hashes besteht. Ein Blattknoten enthält Daten und ein übergeordneter Knoten enthält den Hash seiner untergeordneten Knoten.

Grundsätzlich werden zwei Berechnungen für den Merkle-Baum durchgeführt, um die Manipulationssicherheit von Transparenzlogs zu überprüfen: der Einschlussnachweis und der Konsistenznachweis. Ersterer beweist, dass das Log einen Eintrag enthält, der einer bestimmten APK-Version entspricht. Der Logeintrag enthält einen Hash, der der SHA256-Digest des Codesignatur-Tokens in Form eines JSON Web Tokens (JWT) ist, das aus entsprechenden APKs abgerufen werden kann. Letzterer beweist, dass der neue Prüfpunkt (kryptografisch) mit der vorherigen Version des Baums übereinstimmt, wenn neue Einträge hinzugefügt werden.

Um ein abgedecktes APK zu überprüfen, führen Sie einen Einschlussnachweistest basierend auf einem bezeugten Prüfpunkt durch. Wir planen, dieses Log mit einem öffentlichen Zeugennetzwerk zu verknüpfen , das ein standardisiertes Zeugenprotokoll verwendet. Dadurch wird ein bezeugter Prüfpunkt bereitgestellt, der die Konsistenz des Logs garantiert.

Wenn Sie sich selbst davon überzeugen möchten, dass das APK auf Ihrem Gerät der Behauptung im Claimant Model entspricht, lesen Sie den folgenden Text.

Einschlussnachweis

Ein Android-Nutzer kann prüfen, ob ein abgedecktes APK auf seinem Gerät im Log enthalten ist. Dazu muss er zuerst das APK und die zugehörigen Metadaten extrahieren und dann den neu berechneten Root-Hash mit dem Root-Hash vergleichen, der im veröffentlichten Prüfpunkt enthalten ist. Wenn sie übereinstimmen, kann sich der Android-Nutzer auf einige der im Bedrohungsmodell beschriebenen Schutzmaßnahmen verlassen.

Überprüfen, ob ein APK im Log enthalten ist

Wie bereits beschrieben, finden Sie die Liste der derzeit abgedeckten APKs auf der Seite „Übersicht“.

Bestätigungsgrundlagen

Bevor Sie überprüfen, ob das Artefakt (Firmware oder APK) der Behauptung entspricht, müssen die folgenden Tools auf einem mit dem Netzwerk verbundenen Computer verfügbar sein. Je nach Bestätigungsziel benötigen Sie möglicherweise nicht alle.

Golang

Das Bestätigungstool ist in Go geschrieben. Installieren Sie Go 1.24 oder höher von der Go-Website, um es zu erstellen.

Android Debug Bridge (ADB)

ADB ist ein Tool, das mit einem Android-Gerät kommuniziert, um das Image zu prüfen oder APKs zu extrahieren. Es ist auf der Website Android SDK Platform Tools verfügbar.

Tool zur Überprüfung des Einschlussnachweises

Das Tool zur Überprüfung des Einschlussnachweises ist ein Go-Modul, das das Transparenzlog abfragt und ausgibt, ob ein Artefakt im Log enthalten ist. Es wird im android-binary-transparency GitHub-Repository unter https://github.com/android/android-binary-transparency/tree/main veröffentlicht.

So klonen Sie das AOSP-Repository avb:

computer:~$ git clone https://android.googlesource.com/platform/external/avb

So klonen Sie das GitHub-Repository android-binary-transparency:

computer:~$ git clone https://github.com/android/android-binary-transparency

AAPT2

AAPT2 (Android Asset Packaging Tool) ist ein Build-Tool, mit dem die Ressourcen einer Android-App kompiliert und verpackt werden. Es ist als eigenständiges Tool in Android SDK Build Tools Version 26.0.2 und höher verfügbar.

bundletool

bundletool ist ein Tool zum Erstellen eines Android App Bundle (AAB). Es kann auch zum Überprüfen von APK-Codesignaturen verwendet werden. Es kann von GitHub heruntergeladen werden.

wget oder curl

wget und curl sind Tools, mit denen Dateien aus dem Internet abgerufen oder heruntergeladen werden können. Achten Sie darauf, dass eines dieser Tools installiert ist, da die Bestätigungsskripts möglicherweise darauf angewiesen sind.

Avbtool

avbtool wird verwendet, um den VBMeta-Digest der Factory-Images zu berechnen und Binärdateien zu überprüfen. Nach dem Klonen des avb-Repositorys (wie im Abschnitt Tool zur Überprüfung des Einschlussnachweises gezeigt) finden Sie avbtool.py im geklonten avb-Verzeichnis. Sie sollten dieses Verzeichnis der Umgebungsvariablen $PATH hinzufügen.

computer:~$ PATH=$PATH:DIRECTORY_CONTAINING_AVBTOOL

Fbpacktool

fbpacktool ist ein Python-Skript, mit dem einzelne Komponenten in der `bootloader.img`-Datei von Pixel-Geräten entpackt werden. bootloader.img Wenn Sie APKs überprüfen, benötigen Sie es nicht. Dieses Tool ist wichtig, da avbtool.py damit die für die Überprüfung erforderlichen Images finden kann.

Um dieses Tool zu verwenden, müssen Sie die folgenden drei Python-Skripts in das Verzeichnis herunterladen, in dem sich avbtool.py befindet, fbpacktool.py ausführbar machen und einen Symlink namens fbpacktool zu fbpacktool.py erstellen.

Wenn Sie wget haben:

computer:dir_to_avbtool$ wget https://source.android.com/devices/bootloader/tools/pixel/fw_unpack/fbpacktool.py \
https://source.android.com/devices/bootloader/tools/pixel/fw_unpack/fbpack.py \
https://source.android.com/devices/bootloader/tools/pixel/fw_unpack/packedstruct.py
computer:dir_to_avbtool$ chmod +x fbpacktool.py
computer:dir_to_avbtool$ ln -s fbpacktool.py fbpacktool

Wenn Sie curl haben:

computer:dir_to_avbtool$ curl -O https://source.android.com/devices/bootloader/tools/pixel/fw_unpack/fbpacktool.py
computer:dir_to_avbtool$ curl -O https://source.android.com/devices/bootloader/tools/pixel/fw_unpack/fbpack.py
computer:dir_to_avbtool$ curl -O https://source.android.com/devices/bootloader/tools/pixel/fw_unpack/packedstruct.py
computer:dir_to_avbtool$ chmod +x fbpacktool.py
computer:dir_to_avbtool$ ln -s fbpacktool.py fbpacktool

OpenSSL

openssl hilft dabei, verschiedene kryptografische Vorgänge über das Terminal im Bestätigungsworkflow auszuführen. Achten Sie darauf, dass es auf Ihrem System installiert ist. Sie können das im Terminal prüfen, indem Sie den folgenden Befehl ausführen und darauf achten, dass das zurückgegebene Ergebnis nicht leer ist:

computer:~$ which openssl
/usr/bin/openssl

Nutzlast für die Bestätigung erstellen

Um zu überprüfen, ob das APK, das Sie gemäß unseren Behauptungen von Ihrem Gerät extrahiert haben, mit der Behauptung übereinstimmt, müssen Sie eine Log-Nutzlast aus Informationen erstellen, die aus dem APK abgeleitet wurden.

Bevor Sie beginnen, stellen Sie sicher, dass adb auf Ihrem Gerät verwendet werden kann, indem Sie die ADB-Fehlerbehebung auf Ihrem Gerät aktivieren.

Suchen Sie dann nach dem Installationsort des APK auf Ihrem Gerät. In dieser Anleitung verwenden wir das APK des Android System Key Verifier (com.google.android.contactkeys) als Arbeitsbeispiel.

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 das APK des Android System Key Verifier auf Ihrem Gerät installiert ist, gibt der obige Befehl einen Pfad zurück, der angibt, wo es auf Ihrem Gerät installiert ist. Andernfalls wird keine Ausgabe angezeigt.

Laden Sie dann das APK 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 das APK zuerst entpacken, da ein APK letztendlich eine spezielle Art von ZIP-Datei ist.

computer:/tmp/testdir$ mkdir extracted && unzip contactkeys_candidate.apk -d extracted/

In diesem Schritt werden alle Dateien entpackt, aus denen das APK besteht. Der Paketname und die Version finden Sie im Manifest des APK, das sich normalerweise in einer Datei namens AndroidManifest.xml befindet.

Die abgerufene Manifestdatei ist jedoch binär und daher nicht lesbar. Um das binäre XML in ein lesbares Format zu konvertieren, verwenden wir das zuvor installierte Tool aapt2 (wie im Abschnitt Voraussetzungen beschrieben).

computer:/tmp/testdir$ aapt2 dump badging ./contactkeys_candidate.apk
package: name='com.google.android.contactkeys' versionCode='7805' versionName='1.219.791156583' platformBuildVersionName='Baklava' platformBuildVersionCode='36' compileSdkVersion='36' compileSdkVersionCodename='Baklava'

Aus der obigen Ausgabe können wir nun sicher sein, dass der Paketname dieses APK com.google.android.contactkeys und die Versionsnummer (versionCode) 1413 ist.

Jetzt suchen wir im APK nach der Codesignatur für die Transparenz. Es sollte sich um eine Datei namens code_transparency_signed.jwt handeln, die sich im Ordner META-INF zwischen den anderen extrahierten Dateien aus dem APK befindet.

computer:/tmp/testdir$ sha256sum extracted/META-INF/code_transparency_signed.jwt
1779a2aee029112c2c9bfc9390b9678f3e5f4595b39705e8528dd522e8042f11  code_transparency_signed.jwt

Mit diesem Hash-String haben wir nun alle Informationen, die wir benötigen, um eine Log-Nutzlast gemäß dem im Abschnitt Log-Inhaltbeschriebenen Format zusammenzustellen. In diesem Beispiel sollte eine entsprechende Log-Nutzlast 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 Testen des Einschlussnachweises nützlich.

Authentizität der APK-Codesignatur überprüfen

Jetzt sollten wir die Authentizität des Codesignatur-Tokens überprüfen, das in das APK eingebettet ist. Dazu verwenden wir bundletool und den öffentlichen Schlüssel des Schlüsselpaars, das zum Signieren verwendet wurde. Sie werden veröffentlicht in jedem Abschnitt der jeweiligen APKs. Angenommen, Sie haben das Zertifikat des öffentlichen Schlüssels (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 Codesignatur zu überprüfen.

Erstellen Sie zuerst ein ZIP-Archiv und fügen Sie das Kandidaten-APK in das ZIP-Archiv ein.

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 überprüfen, ob die in das 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 obigen Befehls sollte angeben, dass sowohl die Codesignatur für die Transparenz als auch die Transparenz überprüft wurden. Wenn das nicht der Fall ist, z. B. wenn Sie eine Ausgabe wie Code transparency verification failed because the provided public key certificate does not match the transparency file, sehen, bedeutet das, dass die Codeintegrität des betreffenden APK möglicherweise beeinträchtigt ist und Sie dem APK nicht vertrauen sollten. Prüfen Sie noch einmal, ob Sie die Überprüfung mit dem richtigen Zertifikat des öffentlichen Schlüssels durchführen. Wenn alles andere in Ordnung ist, bedeutet das, dass die Authentizität der Codesignatur für das APK, das Sie überprüfen, bestätigt wurde.

Überprüfen des Paketeinschlusses (Einschlussnachweis)

Mit der zuvor erstellten Nutzlast können Sie jetzt testen, ob das betreffende Paket im Transparenzlog enthalten ist.

Im avb Repository im Open-Source-Projekt für Android wurde ein Tool zur Überprüfung des Einschlussnachweises veröffentlicht. So führen Sie es 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_1p_code

Das Tool verwendet den entsprechenden Prüfpunkt und den Log-Inhalt (im Verzeichnis „tile“), um zu prüfen, ob sich Ihre APK-Nutzlast im Transparenzlog befindet. So wird bestätigt, dass sie 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 Log enthalten ist,
FAILURE wenn nicht.

Vollständige Überprüfung der APK-Transparenz von Google-Systemdiensten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.