Esta página descreve como verificar se o APK ou APEX instalado no seu dispositivo Android corresponde às declarações feitas no modelo do requerente. O processo envolve extrair o APK do dispositivo e realizar uma prova de inclusão de registro no artefato extraído.
Processo de verificação
Um registro de transparência é implementado com uma árvore Merkle que consiste em hashes. Um nó folha contém dados, e um nó pai contém o hash dos filhos.
Dois cálculos fundamentais verificam a propriedade de evidência de violação dos registros de transparência: a prova de inclusão e a prova de consistência. A prova de inclusão confirma que o registro inclui uma entrada para uma versão específica do APK. Essa entrada de registro contém um hash, que é o resumo SHA256 do arquivo APK instalado no dispositivo. A prova de consistência garante que, quando novas entradas são adicionadas, o novo checkpoint permaneça criptograficamente consistente com as versões anteriores da árvore ou que a árvore não tenha sido adulterada. Neste guia, vamos nos concentrar no processo de cálculo da prova de inclusão, enquanto confiamos em testemunhas para realizar continuamente a prova de consistência em relação aos checkpoints mais recentes.
Para verificar um APK coberto, realize uma prova de inclusão em relação a um checkpoint testemunhado. Planejamos integrar esse registro a uma rede de testemunhas pública usando um protocolo de testemunha padronizado. Essa integração vai fornecer checkpoints testemunhados, garantindo a consistência do registro.
Para verificar se os apps do Google no seu dispositivo estão em conformidade com as declarações feitas no modelo do requerente, siga as etapas abaixo.
Prova de inclusão
Para verificar se um APK coberto no seu dispositivo está no registro, extraia o APK, calcule o hash e use uma prova de inclusão para verificar se esse hash existe no checkpoint publicado. Uma prova de inclusão bem-sucedida garante proteção contra os riscos descritos no modelo de ameaça, confirmando que o app é um app legítimo do Google.
Como verificar a inclusão de um APK no registro
Qualquer app que se declare um app do Google de terceiros pode ser verificado em relação a esse registro.
Pré-requisitos de verificação
Antes de prosseguir para verificar se o artefato (firmware ou APK) está de acordo com a declaração, verifique se as ferramentas a seguir estão disponíveis em um computador conectado à rede. Dependendo do destino da verificação, talvez você não precise de todas elas.
Golang
A ferramenta de verificação é escrita em Go. Para criá-la, instale o Go 1.24 ou mais recente no site do Go.
Android Debug Bridge
ADB é uma ferramenta que se comunica com um dispositivo Android para inspecionar a imagem ou
extrair APKs, disponível no Android SDK Platform Tools website.
Verificador de prova de inclusão
O verificador de prova de inclusão é um módulo Go que consulta o registro de transparência e informa se um artefato está incluído no registro.
Ele é publicado no repositório do GitHub em
https://github.com/android/android-binary-transparency/tree/mainandroid-binary-transparency
Para clonar o repositório avb do AOSP:
computer:~$ git clone https://android.googlesource.com/platform/external/avb
Para clonar o repositório android-binary-transparency do GitHub:
computer:~$ git clone https://github.com/android/android-binary-transparency
AAPT2
O AAPT2 (Android Asset Packaging Tool) é uma ferramenta de build usada para compilar e empacotar recursos de um app Android. Ele pode ser encontrado como uma ferramenta independente no Android SDK Build Tools versão 26.0.2 e mais recentes.
bundletool
O bundletool é uma ferramenta usada para criar um Android App Bundle (AAB). Ele também pode ser usado para verificar assinaturas de código APK.
Ele pode ser baixado do GitHub.
wget ou curl
wget e curl são ferramentas que podem ser usadas para recuperar ou baixar arquivos da Internet. Verifique se uma dessas ferramentas está instalada, porque os scripts de verificação podem depender delas.
Avbtool
avbtool
é usado para calcular o resumo do VBMeta das imagens de fábrica e a verificação de
binários.
Depois de clonar o repositório avb (conforme mostrado na seção Verificador de prova de inclusão
), avbtool.py pode ser encontrado no diretório avb clonado.
Adicione esse diretório à variável de ambiente $PATH.
computer:~$ PATH=$PATH:DIRECTORY_CONTAINING_AVBTOOL
Fbpacktool
fbpacktool
é um script Python usado para descompactar componentes individuais no
bootloader.img.
Você não precisa disso se estiver verificando APKs.
Essa ferramenta é importante porque permite que avbtool.py descubra as imagens necessárias para a verificação.
Para usar essa ferramenta, baixe os três scripts Python a seguir
para o diretório em que avbtool.py está,
torne fbpacktool.py executável,
e crie um link simbólico chamado fbpacktool para fbpacktool.py para facilitar.
Se você tiver wget:
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
Se você tiver curl:
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 ajuda a realizar várias operações criptográficas usando o terminal no fluxo de trabalho de verificação. Verifique se ele está instalado no seu sistema. Você pode verificar no terminal executando o comando a seguir e conferindo se o resultado retornado não está vazio:
computer:~$ which openssl
/usr/bin/openssl
Criar um payload para verificação
Para verificar o APK extraído, crie um payload de registro usando informações derivadas do próprio APK.
Antes de começar, ative a depuração USB no dispositivo para permitir adb
conexões.
Em seguida, localize o APK instalado no dispositivo. Este guia usa o
APK do Google Play Services (com.google.android.gms) como um exemplo de trabalho.
adb shell pm path com.google.android.gms
A resposta será semelhante a esta:
computer:~$ adb shell pm path com.google.android.gms
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/base.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_CronetDynamite_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_DynamiteLoader_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_DynamiteModulesA_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_DynamiteModulesC_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_GoogleCertificates_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_MapsDynamite_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_MeasurementDynamite_installtime.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_config.en.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_config.xxhdpi.apk
package:/data/app/~~oI3N-m7I3VNMk5eKUCscQg==/com.google.android.gms-O79jYXgqkqKaQ9IzJ5zqfA==/split_maps_core_dynamite_ondemand.apk
Essa saída indica que um APK de base e vários APKs divididos estão instalados
para com.google.android.gms no seu dispositivo.
O número exato de APKs divididos varia de acordo com a configuração do dispositivo.
Cada APK dividido compartilha o mesmo nome de pacote e código de versão do APK de base.
Baixe os APKs listados do seu dispositivo Android para o computador usando o comando a seguir (observando que os caminhos de arquivo reais podem variar):
mkdir -p /tmp/testdir/gms && cd /tmp/testdir/gms && \
adb shell pm path com.google.android.gms | cut -d':' -f2 | tr -d '\r' | xargs -n1 adb pull
Para verificar o nome do pacote e a versão dos APKs baixados, você precisa
inspecionar o manifesto (AndroidManifest.xml).
Como o manifesto dentro de um APK está em formato binário, use a ferramenta aapt2 (instalada durante a etapa de pré-requisitos) para extrair e ler as informações diretamente do APK:
computer:/tmp/testdir/gms$ aapt2 dump badging ./base.apk
package: name='com.google.android.gms' versionCode='260834035' versionName='26.08.34 (260400-876566425)' platformBuildVersionName='Baklava' platformBuildVersionCode='36' compileSdkVersion='36' compileSdkVersionCodename='Baklava'
minSdkVersion:'35'
targetSdkVersion:'36'
...
Repita essa etapa para receber as informações relevantes até que você tenha contabilizado todos os APKs divididos instalados no dispositivo.
A saída confirma que o nome do pacote do APK é com.google.android.gms e o número da versão (versionCode) é 260834035.
Em seguida, calcule o hash criptográfico de cada APK:
computer:/tmp/testdir/gms$ sha256sum *.apk
66aa2d7b9752cdd61065b55c8e16739d8367fa18a0f1c8c84122369f86958f1a base.apk
c20754aee886cc55a9de91ee15c623c59d94ad22b7e435a1a48afc43cf1a106c split_config.en.apk
68c09b63a1262e0d34020c139bc77deff3c32bd2b01177abac64790a62fb3be6 split_config.xxhdpi.apk
cd746820c27babd855fa5daea6fabcdf7b44abf3060bc547adc4219212410af0 split_CronetDynamite_installtime.apk
512ee48b60fdb0787a17f84a7dc448fdbf885b2b86a9cb50525d4c22d561b0f1 split_DynamiteLoader_installtime.apk
9e0c74bdc75c50c80d4e2e580a7eda6b8391423ab1161645f41ec6cadc07d678 split_DynamiteModulesA_installtime.apk
955780ac01f59b98bd9be12968f3824ad71b762620f7bf223c569c1a6ab7056c split_DynamiteModulesC_installtime.apk
34c4a2e32d31554d55fc1519e2cfc3ed5027a090fb29b54cfc99f42d1da43bc5 split_GoogleCertificates_installtime.apk
475e18dde92472cde9d8300c082b6dc269613db03398bcd9d1987dff3e68f7b5 split_maps_core_dynamite_ondemand.apk
f83faf40f08bc13f4879302e01c08c863ca2304b4b4e7c9eaf8cd1e869bb6573 split_MapsDynamite_installtime.apk
ec6d854ddda6cd1ba2ba7af2d9fdf4f28c5c78be8713c64521c785429296738c split_MeasurementDynamite_installtime.apk
Agora você tem todas as informações necessárias para criar um payload de registro, formatado conforme descrito na seção Conteúdo do registro. Selecionando um hash dos resultados como exemplo (verifique o hash de cada APK dividido), o payload de registro fica assim:
66aa2d7b9752cdd61065b55c8e16739d8367fa18a0f1c8c84122369f86958f1a
SHA256(APK)
com.google.android.gms
260834035
Inclua um caractere de nova linha no final do arquivo. Salve esse conteúdo em um arquivo, como payload.txt, para usar com a ferramenta verifier mais tarde.
Verificar a inclusão do pacote (prova de inclusão)
Com o payload criado, agora você pode verificar se o pacote está incluído no registro de transparência. Crie a ferramenta de prova de inclusão no repositório android-binary-transparency clonado anteriormente:
go build cmd/verifier/verifier.go
Isso vai resultar em um executável chamado verifier nesse diretório.
Execute o verificador, fornecendo o caminho para o payload e especificando o tipo de registro:
computer:android-binary-transparency$ PAYLOAD_PATH=PATH_TO_PAYLOAD_DIR/payload.txt
computer:android-binary-transparency$ ./verifier --payload_path=${PAYLOAD_PATH} --log_type=google_1p_apk
O verificador usa o checkpoint e o conteúdo do registro (do diretório de blocos) para verificar se o payload do APK está no registro de transparência, confirmando que ele foi publicado pelo Google.
O comando gera para stderr:
OK. inclusion check success!se o pacote estiver incluído no registro.FAILUREse não estiver.
Verificar automaticamente todos os pacotes em um dispositivo
Dado o número de apps do Google que podem ser pré-instalados no seu dispositivo, enumerar cada app e realizar provas de inclusão individualmente pode ser tedioso.
Oferecemos outra ferramenta automatizada chamada Uraniborg que pode detectar e medir todos os pacotes instalados no seu dispositivo.
Ela alimenta a saída diretamente na ferramenta verifier, permitindo que você descubra e verifique a transparência de todos os apps no seu dispositivo em uma única etapa.
Para usar esse fluxo de trabalho automatizado, verifique se o dispositivo Android está conectado ao computador via ADB. O código-fonte Uraniborg também está incluído no repositório android-binary-transparency.
Execute o script automate_observation.py localizado no diretório scripts/python:
python3 automate_observation.py --pull-all-apks --perform_inclusion_proof_check --verifier_path <path_to_verifier_executable>
Quando o script for concluído, você verá uma saída semelhante a esta:
INFO:automate_observation.py:main(858): SUCCESS! Hubble was successfully deployed and executed on connected device ABCDEFGHN01234.
INFO:automate_observation.py:main(860): Hubble output files can be found at: /Users/user/home/src/android-binary-transparency/uraniborg/scripts/python/results/google/lynx/lynx:16/BP4A.260105.004.E1/14587043:user/release-keys/001
Navegue até o diretório de saída indicado pelo script.
Dentro dele, localize o arquivo chamado packages_with_inclusion_proof_signal.txt.
Esse arquivo lista cada pacote instalado ao lado de um campo inclusion_proof_verified definido como true ou false.
Um valor true indica que o pacote foi verificado criptograficamente no registro de transparência, confirmando que ele está em conformidade com as declarações do registro.