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 der im Claimant Model gemachten Behauptung entspricht. Dazu wird das betreffende APK von deinem Gerät abgerufen, die Codeintegrität geprüft und ein Log-Inklusionsnachweis für das extrahierte Artefakt durchgeführt.

Überprüfungsverfahren

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

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

Wenn du ein abgedecktes APK verifizieren möchtest, führe einen Einschlussnachweistest basierend auf einem bezeugten Prüfpunkt durch. Wir planen, dieses Log mithilfe eines standardisierten Witness-Protokolls in ein öffentliches Witness-Netzwerk einzubinden. Dadurch wird ein bezeugter Prüfpunkt bereitgestellt, der die Konsistenz des Logs garantiert.

Wenn du dich davon überzeugen möchtest, dass das APK auf deinem Gerät der Behauptung im Anspruchsmodell entspricht, lies die folgende Beschreibung.

Inklusionsnachweis

Android-Nutzer können prüfen, ob ein abgedecktes APK auf ihrem Gerät im Protokoll enthalten ist. Dazu extrahieren sie zuerst das APK und die relevanten Metadaten und vergleichen dann den neu berechneten Root-Hash mit dem Root-Hash im veröffentlichten Prüfpunkt. Wenn sie übereinstimmen, kann der Android-Nutzer sicher sein, dass einige der im Bedrohungsmodell beschriebenen Schutzmaßnahmen greifen.

So prüfen Sie, ob ein APK im Log enthalten ist

Wie bereits erwähnt, finden Sie die Liste der derzeit abgedeckten APKs auf der Übersichtsseite.

Bestätigungsgrundlagen

Bevor Sie prü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 Überprüfungsziel benötigen Sie möglicherweise nicht alle.

GoLang

Das Überprüfungstool 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 für Android SDK Platform-Tools verfügbar.

Prüfer für den Nachweis der Aufnahme

Der Prüfer für den Einschlussnachweis ist ein Go-Modul, das das Transparenzprotokoll abfragt und ausgibt, ob ein Artefakt im Protokoll enthalten ist. Es wird im GitHub-Repository android-binary-transparency unter https://github.com/android/android-binary-transparency/tree/main veröffentlicht.

So klonen Sie das AOSP-avb-Repository:

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 den Android SDK Build Tools ab Version 26.0.2 verfügbar.

bundletool

bundletool ist ein Tool zum Erstellen eines Android App Bundles (AAB). Sie kann auch zur Überprüfung von APK-Codesignaturen verwendet werden. Sie 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 Überprüfungsskripts möglicherweise darauf angewiesen sind.

Avbtool

avbtool wird verwendet, um den VBMeta-Digest der Factory Images zu berechnen und Binärdateien zu verifizieren. Nachdem Sie das Repository avb geklont haben (wie im Abschnitt „Prüfer für Einschlussnachweise“ beschrieben), finden Sie avbtool.py im geklonten Verzeichnis avb. Sie sollten dieses Verzeichnis Ihrer Umgebungsvariablen $PATH hinzufügen.

computer:~$ PATH=$PATH:DIRECTORY_CONTAINING_AVBTOOL

Fbpacktool

fbpacktool ist ein Python-Script, mit dem einzelne Komponenten in der bootloader.img von Pixel entpackt werden. Dies ist nicht erforderlich, wenn Sie APKs verifizieren. Dieses Tool ist wichtig, weil avbtool.py damit die erforderlichen Images für die Überprüfung finden kann.

fbpacktool erfordert Python 3.6 oder höher und das PyYAML-Paket (z. B. python3 -m pip install pyyaml).

Wenn Sie dieses Tool verwenden möchten, sollten Sie die folgenden sechs Python-Skripts in das Verzeichnis herunterladen, in dem sich Ihre avbtool.py befindet, fbpacktool.py ausführbar machen und einen Symlink mit dem Namen fbpacktool zu fbpacktool.py erstellen.

Wenn du wget hast:

computer:dir_to_avbtool$ wget https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/fbpacktool.py \
https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/fbpack.py \
https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/packedstruct.py \
https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/xmlparser.py \
https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/xmlserializer.py \
https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/yamlparser.py
computer:dir_to_avbtool$ chmod +x fbpacktool.py
computer:dir_to_avbtool$ ln -s fbpacktool.py fbpacktool

Wenn du curl hast:

computer:dir_to_avbtool$ curl -LO https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/fbpacktool.py
computer:dir_to_avbtool$ curl -LO https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/fbpack.py
computer:dir_to_avbtool$ curl -LO https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/packedstruct.py
computer:dir_to_avbtool$ curl -LO https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/xmlparser.py
computer:dir_to_avbtool$ curl -LO https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/xmlserializer.py
computer:dir_to_avbtool$ curl -LO https://developers.google.com/android/binary_transparency/tools/pixel/fbpacktool/yamlparser.py
computer:dir_to_avbtool$ chmod +x fbpacktool.py
computer:dir_to_avbtool$ ln -s fbpacktool.py fbpacktool

OpenSSL

openssl hilft bei der Durchführung verschiedener kryptografischer Vorgänge über das Terminal im Bestätigungsworkflow. Prüfen Sie, ob es auf Ihrem System installiert ist. Sie können dies in Ihrem Terminal prüfen, indem Sie den folgenden Befehl ausführen und sicherstellen, dass das zurückgegebene Ergebnis nicht leer ist:

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

Nutzlast für die Überprüfung erstellen

Wenn Sie prüfen möchten, ob das APK, das Sie von Ihrem Gerät extrahiert haben, unseren Angaben entspricht, müssen Sie eine Lognutzlast aus Informationen erstellen, die aus dem APK abgeleitet wurden.

Prüfen Sie vorab, ob adb auf Ihrem Gerät verwendet werden kann, indem Sie das ADB-Debugging auf Ihrem Gerät aktivieren.

Suchen Sie dann auf Ihrem Gerät nach dem Speicherort der APK. In diesem Leitfaden verwenden wir die APK 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 Android System Key Verifier APK 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.

Lade dann mit dem folgenden Befehl das APK von deinem Android-Gerät auf den Computer herunter, auf dem du arbeitest. Beachte, dass der tatsächliche Speicherort und der APK-Dateiname auf deinem Gerät variieren können:

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 APKs zu erhalten und zu bestätigen, müssen Sie das APK zuerst entpacken, da es sich letztendlich 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 entpackt, aus denen das APK besteht. Der Paketname und die Version sind im Manifest des APKs enthalten, das sich normalerweise in einer Datei namens AndroidManifest.xml befindet.

Die abgerufene Manifestdatei liegt jedoch in einem Binärformat vor, das nicht menschenlesbar ist. Um die binäre XML-Datei in eine menschenlesbare Form zu konvertieren, verwenden wir das zuvor installierte Tool aapt2 (wie im Abschnitt Voraussetzung 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'

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

Jetzt suchen wir im APK nach der Codetransparenzsignatur. Es sollte eine Datei mit dem Namen code_transparency_signed.jwt sein, die sich im Ordner META-INF befindet, zusammen mit den anderen aus dem APK extrahierten Dateien.

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 wir benötigen, um eine Log-Nutzlast gemäß dem im Abschnitt Loginhalte beschriebenen 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 hilfreich.

Authentizität der APK-Codesignatur prüfen

Jetzt sollten wir die Authentizität des in das APK eingebetteten Codesignaturtokens prüfen. Dazu verwenden wir bundletool und den öffentlichen Schlüssel des Schlüsselpaars, mit dem die Signatur ursprünglich erstellt wurde. Sie werden in jedem Abschnitt der jeweiligen APKs veröffentlicht. Angenommen, Sie haben das Public-Key-Zertifikat (z. B. für Android System Key Verifier) in einer Datei namens signing_cert_pubkey.pem gespeichert. Folgen Sie dann der Anleitung unten, um die Codesignatur zu überprüfen.

Erstelle zuerst ein ZIP-Archiv und füge das Kandidaten-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 Signatur ü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 zeigen, dass sowohl die Codetransparenz-Signatur als auch die Codetransparenz verifiziert sind. Wenn dies 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 dies, dass die Codeintegrität des betreffenden APKs möglicherweise beeinträchtigt ist und Sie dem APK nicht vertrauen sollten. Prüfen Sie sorgfältig, ob Sie sie mit dem richtigen Public-Key-Zertifikat vergleichen. Wenn alles andere in Ordnung ist, bedeutet dies, dass die Authentizität der Codesignatur für das zu validierende APK bestätigt wurde.

Paketeinbindung prüfen (Einbindungsnachweis)

Mit der Nutzlast, die Sie zuvor erstellt haben, können Sie jetzt testen, ob das betreffende Paket im Transparenzprotokoll enthalten ist.

Im Repository avb des Open-Source-Projekts für Android wurde ein Tool für den Einschlussnachweis 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

Der Prüfer verwendet den entsprechenden Prüfpunkt und den Inhalt des Logs (im Kachelverzeichnis), um zu prüfen, ob sich die APK-Nutzlast im Transparenzprotokoll 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 dies nicht der Fall ist.