Construindo e flashando uma versão AOSP segura com boot verificado e senha de tela de bloqueio separada para o Nexus 5X

Isenção de responsabilidade e Licença

Todos os dados e informações fornecidos neste tutorial são apenas para fins informativos. O autor não faz representações quanto à precisão, completude, atualidade, adequação ou validade de qualquer informação neste tutorial e não será responsável por quaisquer erros, omissões ou atrasos nesta informação ou quaisquer perdas, lesões ou danos decorrentes de sua exibição ou uso. Todas as informações são fornecidas na forma como estão.

Em nenhuma circunstância, o autor ou o howtoforge será responsável por qualquer perda ou dano, incluindo, sem limitação, perda ou dano indireto ou consequencial, ou qualquer perda ou dano de qualquer tipo decorrente da perda de dados ou lucros resultantes do uso deste tutorial.

Exceto conforme indicado de outra forma, o conteúdo desta página está licenciado sob a Licença Creative Commons Atribuição 3.0, e os exemplos de código estão licenciados sob a Licença Apache 2.0.

Motivação

O Nexus 5X e 6P foram os primeiros dispositivos que suportaram boot verificado com base em chaves de assinatura fornecidas pelo usuário (e não impostas pelo fornecedor). Antes de sua “implosão” [1], o CopperheadOS (uma variante AOSP aprimorada em segurança) costumava fornecer boa documentação e scripts para construir e flashar uma versão segura do AOSP [2]. No entanto, o projeto parou de fornecer atualizações nos últimos meses, então a maioria dos antigos usuários está procurando alternativas viáveis.

Minha impressão é que muitos usuários concordam que executar uma ROM AOSP construída por conta própria é uma alternativa muito melhor a outras opções, como mudar para, por exemplo, LineageOS. Existem várias boas razões para isso:

AOSP é o stock puro e tem apenas alguns recursos possivelmente indesejados
AOSP pode ser construído como uma variante de build “user” em vez de “userdebug” e, assim, espera-se que seja mais seguro (tentei compilar builds de usuário do LineageOS, mas parecem estar quebradas devido às mudanças invasivas que o LineageOS fez nas fontes do AOSP)
Uma vez que as fontes são obtidas, o AOSP pode ser simplesmente construído. Ao contrário do LineageOS, ele não começa a baixar fontes adicionais durante a construção.

Como o Nexus 5X é considerado um dispositivo de desenvolvedor bem suportado, eu esperava que o processo de construção do AOSP fosse fácil e bem documentado. No entanto, parece que existem várias ressalvas:

incluir os binários do fornecedor seguindo a documentação oficial resulta em builds incompletos que não podem ser usados para atualizações incrementais sem desbloquear e limpar a cada vez (a partição do fornecedor, rádio ROM etc. não está incluída na construção)
a documentação oficial não descreve como usar a build verificada de uma maneira que seja diretamente aplicável. Há uma documentação melhor nos docs do CopperheadOS [05], mas as instruções dependem de scripts desatualizados que não são aplicáveis ao AOSP.
não há documentação sobre como usar um PIN “fraco” como frase de acesso, mas uma senha forte como chave de criptografia de disco (ao contrário dos dispositivos Pixel mais novos, o Nexus 5X é baseado na abordagem FDE mais antiga). Os métodos que funcionam para dispositivos LineageOS não são aplicáveis, pois assumem que o dispositivo está com root, o que não é o caso para builds de usuário do AOSP.

Este tutorial visa fornecer instruções detalhadas sobre como resolver essas ressalvas, construindo e flashando o AOSP para o Nexus 5X com boot verificado e usando segredos separados de tela de bloqueio/criptografia. Ele também deve se aplicar ao Nexus 6P com pequenas mudanças, mas não consegui testá-lo, pois não tinha um Nexus 6P à mão.

Exceto por uma pequena coleção de scripts (necessários para extrair corretamente os blobs do fornecedor dos binários fornecidos pelo Google) e sua dependência “oatdump” (que é baixada como binário de um compartilhamento público), as instruções não fazem uso de quaisquer recursos de terceiros “não oficiais” (no sentido de “não fornecidos pelo Google”).

Esteja ciente das seguintes questões de liberdade:

A árvore de fontes do AOSP contém vários binários pré-compilados (por exemplo, toolchain, kernel Linux, …). Embora esses binários possam ser reconstruídos a partir do código-fonte, os passos necessários não estão cobertos neste tutorial.
O código-fonte para os blobs do fornecedor necessários para usar muitos componentes de hardware do Nexus 5X não está disponível publicamente!
A ferramenta “android-prepare-vendor” usada para extrair os arquivos proprietários do fornecedor usa binários pré-compilados (alguns até hospedados externamente).

Requisitos e suposições

O tutorial assume que você tem os seguintes pré-requisitos (outras versões/distribuições podem funcionar também, mas podem exigir outros ou pacotes adicionais):

um Nexus 5X com o bootloader desbloqueado (o desbloqueio não é coberto neste tutorial)
máquina (virtual) executando Debian9 na variante x86_64, usada exclusivamente para nosso propósito (assumimos que você usa sudo, se não, adapte os comandos)
pelo menos 5 GB de RAM (mais é melhor)
aproximadamente 200 MB de espaço em disco
conexão de internet rápida (precisamos baixar cerca de 30G de dados)

Instalando dependências

Primeiro, instale as dependências conforme descrito nas instruções de construção do LineageOS [3] (as instruções de construção do AOSP não fornecem esta lista):

sudo apt install bc bison build-essential ccache curl flex g++-multilib gcc-multilib git gnupg gperf imagemagick lib32ncurses5-dev lib32readline-dev lib32z1-dev liblz4-tool libncurses5-dev libsdl1.2-dev libssl-dev libwxgtk3.0-dev libxml2 libxml2-utils lzop pngcrush rsync schedtool squashfs-tools xsltproc zip zlib1g-dev

Agora, instale dependências adicionais:

sudo apt install cmake zip unzip openjdk-8-jdk-headless

Em seguida, configure um caminho bin no seu diretório home (no Debian 9, este caminho é configurado automaticamente no perfil bash):

mkdir -p ~/bin

Instale o comando repo:

curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo  
chmod a+x ~/bin/repo

Verifique o checksum do binário repo. Deve ser e147f0392686c40cfd7d5e6f332c6ee74c4eab4d24e2694b3b0a0c037bf51dc5 para a versão atual 1.23. para versões posteriores, verifique a página de instruções de construção do AOSP [4]. Use o seguinte comando para calcular o checksum:

sha256sum ~/bin/repo

Em seguida, forneça uma identidade git executando os seguintes comandos (você pode deixar os dados de exemplo se preferir permanecer anônimo):

git config --global user.email "[email protected]"

git config --global user.name "Seu Nome"

Infelizmente, o pacote brotli (necessário para empacotar as builds) no Debian 9 é muito antigo, então precisamos construir a versão atual nós mesmos. Primeiro, obtenha o código-fonte e mude para seu diretório:

git clone https://github.com/google/brotli.git

Execute a construção (substitua -j15 pelo número de threads da sua cpu):

cd ~/brotli

./configure-cmake

make -j15

Finalmente, copie o binário resultante para nosso caminho bin:

cp brotli ~/bin/

Finalmente, saia e entre novamente para que seu perfil bash seja lido novamente.

Obtendo os blobs do fornecedor

Existem várias questões ao usar os blobs do fornecedor dos pacotes de drivers binários fornecidos pelo Google (veja [5]). Para resolvê-los, usamos o conjunto de scripts externos “android-prepare-vendor” de “anestisb” que extrai os blobs do fornecedor das imagens de fábrica.

Primeiro, clone o repositório:

git clone https://github.com/anestisb/android-prepare-vendor.git

Usando o site do Google [6], descubra a última tag de Build para o seu Nexus 5X (atualmente é OPM6.171019.030.K1).

Mude para o repositório, crie um diretório de saída e execute o script (executamos o script como root devido a problemas com fuse no Debian 9):

cd android-prepare-vendor

mkdir bullhead-blobs

sudo ./execute-all.sh -k -d bullhead -a bullhead -b OPM6.171019.030.K1 -o bullhead-blobs

Baixando fontes do AOSP

Nota: Os seguintes passos carecem de instruções para verificar a fonte baixada.

Primeiro, crie um diretório onde as fontes serão armazenadas:

mkdir -p ~/aosp

Sabendo a tag de build atual para o Nexus 5X, descubra qual é a tag correspondente do Android usando a visão geral disponível em [6]. Em seguida, faça checkout do manifesto do Android para o branch correspondente (neste exemplo, usamos android-8.1.0_r46):

cd ~/aosp

repo init -u https://android.googlesource.com/platform/manifest -b android-8.1.0_r46

como de costume em XML para comentar repositórios. Eu recomendo excluir/substituir o seguinte:

- o QuickSearchBox está quase quebrado no AOSP de qualquer forma
- substitua isso por um repositório que contenha uma árvore de dispositivo corrigida onde os dois núcleos de cpu defeituosos estão desativados. Isso vem com uma penalidade de desempenho de ~30%. No entanto, recomendado, mesmo que você tenha um Nexus 5X que não seja afetado pelo bootloop, pois é provável que seja afetado no futuro.
- existem melhores alternativas para o calendário AOSP padrão que você pode instalar depois (como Etar)
- Silence.im é uma melhor alternativa para o aplicativo de mensagens AOSP
- OpenCamera é uma melhor alternativa para a câmera padrão

Agora, busque todos os repositórios (pode levar um tempo, principalmente dependendo da sua conexão de internet):

repo sync

Finalmente, copie os blobs do fornecedor gerados anteriormente como root (isso é necessário, ou qmus e outros blobs estarão faltando e causarão falha na compilação posterior) para o diretório do fornecedor da sua árvore AOSP (substitua o número da build de fábrica pelo atual):

sudo cp -av ~/android-prepare-vendor/bullhead-blobs/bullhead/opm6.171019.030.k1/vendor .

sudo cp -av ~/android-prepare-vendor/bullhead-blobs/bullhead/opm6.171019.030.k1/vendor_overlay .

Faça seu usuário o proprietário dos diretórios do fornecedor (ou a construção falhará mais tarde). Substitua yourusername pelo seu nome de usuário real:

sudo chown -R yourusername:yourusername ~/aosp/vendor

sudo chown -R yourusername:yourusername ~/aosp/vendor_overlay

Gerando Chaves

Defina as variáveis de construção:

source build/envsetup.sh

Construa a ferramenta necessária para gerar a chave de verificação:

make generate_verity_key

Crie um diretório para armazenar suas chaves (os docs do CopperheadOS [2] recomendam usar uma chave separada para cada dispositivo, neste caso bullhead):

mkdir -p keys/bullhead

Agora é hora de gerar as chaves (não defina senhas em suas chaves):

cd keys/bullhead

../../development/tools/make_key releasekey '/C=DE/ST=Hometown/L=XX/O=yournamehere/OU=yournamehere/CN=yournamehere/[email protected]'

../../development/tools/make_key platform '/C=DE/ST=Hometown/L=XX/O=yournamehere/OU=yournamehere/CN=yournamehere/[email protected]'

../../development/tools/make_key shared '/C=DE/ST=Hometown/L=XX/O=yournamehere/OU=yournamehere/CN=yournamehere/[email protected]'

../../development/tools/make_key media '/C=DE/ST=Hometown/L=XX/O=yournameher /OU=yournamehere/CN=yournamehere/[email protected]'

../../development/tools/make_key verity '/C=DE/ST=Hometown/L=XX/O=yournamehere/OU=yournamehere/CN=yournamehere/[email protected]'

cd ~/aosp

Converta a chave de verificação para o formato exigido pelo AOSP:

out/host/linux-x86/bin/generate_verity_key -convert keys/bullhead/verity.x509.pem keys/bullhead/verity_key

Compilando

Certifique-se de que suas variáveis de construção estejam definidas:

cd ~/aosp

source build/envsetup.sh

Crie uma configuração de lunch para o dispositivo bullhead (substitua user por userdebug se quiser uma configuração userdebug):

lunch aosp_bullhead-user

Desative o Jack (ele frequentemente causa problemas de compilação e foi descontinuado no Android 9 de qualquer forma):

export ANDROID_COMPILE_WITH_JACK=false

Compile o pacote de arquivos de destino (substitua -j15 pelo número de threads da sua cpu):

make target-files-package -j15

Empacotando e assinando

Crie um diretório para armazenar os arquivos de saída (fora do diretório de construção usual chamado out):

mkdir dist

Execute o alvo dist (substitua -j15 pelo número de threads da sua cpu):

make dist -j15

Crie um pacote de arquivos de destino assinado, substituindo as chaves de teste padrão pelas suas chaves (substitua yourusername pelo seu nome de usuário real no sistema):

build/tools/releasetools/sign_target_files_apks -o -d keys/bullhead --replace_verity_public_key keys/bullhead/verity_key.pub --replace_verity_private_key keys/bullhead/verity --replace_verity_keyid keys/bullhead/verity.x509.pem out/dist/aosp_bullhead-target_files-eng.yourusername.zip dist/signed-target-files.zip

Crie um pacote OTA assinado:

 build/tools/releasetools/ota_from_target_files -k keys/bullhead/releasekey dist/signed-target-files.zip dist/signed-ota-update.zip

Flashando

Inicie seu dispositivo Nexus 5X no bootloader (segure o volume para baixo e, em seguida, pressione o botão de energia).

Conecte seu dispositivo via USB à sua máquina (e torne-o disponível para a VM caso você construa em uma VM). Você também pode copiar o conteúdo do diretório dist para outra máquina e flashar a partir de lá, mas assumimos que você flasha usando os binários fastboot/adb construídos a partir das fontes do AOSP (se você flashar de fora, certifique-se de que seu binário fastboot esteja atualizado).

Descompacte as imagens do signed-target-files.zip:

cd ~/aosp/dist

unzip `signed-target-files.zip IMAGES/*  
`

Agora, flash todas as imagens:

../out/host/linux-x86/bin/fastboot flash boot boot.img

../out/host/linux-x86/bin/fastboot flash recovery recovery.img

../out/host/linux-x86/bin/fastboot flash vendor vendor.img

../out/host/linux-x86/bin/fastboot flash system system.img

Selecione “reiniciar sistema” usando os botões físicos do seu dispositivo e certifique-se de que seu novo sistema funcione.

Finalmente, reinicie de volta para o bootloader e bloqueie-o novamente (isso apagará todos os dados):

out/host/linux-x86/bin/fastboot flash oem locking

É isso!

Definindo segredos de boot/tela de bloqueio separados

Definir uma senha de boot/tela de bloqueio separada pode ser feito com um pequeno truque:

Desbloqueie o bootloader (apaga todos os dados)
compile e flash uma build userdebug (veja acima)
bloqueie o bootloader
defina um PIN/senha de tela de bloqueio usando a interface do Android. Certifique-se de escolher o correto, pois você não poderá mudá-lo novamente sem apagar seus dados uma vez que você mude para a build user.
conecte-se ao dispositivo via adb
como root, execute o seguinte comando: vdc cryptfs changepw password sua-nova-senha
reinicie e certifique-se de que funcione
compile uma build user regular (não desbloqueie o bootloader!)
flash a build user

Nota: Sem etapas adicionais, a recuperação não permite flashar builds mais antigas. Assim, você precisa flashar uma build user que seja mais nova que sua build userdebug!

Tratando atualizações

Se você quiser atualizar para uma versão mais nova do AOSP, primeiro precisa descobrir o novo número da versão.

Em seguida, limpe o antigo manifesto (faça um backup, caso tenha feito alterações que deseja refazer na versão atualizada):

cd ~/aosp

rm -rf .repo/manifests.git

rm -rf .repo/manifest.xml

Além disso, limpe os blobs do fornecedor (então desatualizados) e o repositório prepare-vendor:

rm -rf ~/android-prepare-vendor

rm -rf vendor

rm -rf vendor_overlay

Além disso, limpe a árvore de construção e os artefatos de construção:

rm -rf out

rm -rf dist

Em seguida, refaça APENAS os seguintes passos:

Obtendo os blobs do fornecedor
Baixando fontes do AOSP (isso será muito mais rápido, porque apenas as mudanças serão puxadas)
Compilando
Empacotando e assinando

Na teoria, você deve ser capaz de sideload atualizações como novos pacotes OTA da recuperação sem apagar (já que será assinado com as mesmas - suas - chaves). Na prática, isso ainda não funciona (veja a próxima seção). Lá, você também terá que proceder da seguinte forma:

Faça backup de todos os seus dados
Desbloqueie o bootloader (seus dados serão apagados)
Flash as imagens atualizadas e bloqueie novamente seu bootloader conforme descrito na seção “Flashando”

WIP: Atualizações OTA assinadas

Esta seção está em WIP, as instruções descritas ainda não funcionam!

Na teoria, deve ser possível criar e flashar atualizações OTA assinadas a partir da recuperação. No entanto, todas as minhas tentativas de fazer isso resultaram em um erro de “Verificação de assinatura falhou”. Como isso funciona ao usar os arquivos do fornecedor fornecidos pelo Google diretamente em vez de usar android-prepare-vendor, eu assumo que está relacionado aos arquivos do fornecedor ou outros arquivos (como as imagens do bootloader ou rádio) não estarem devidamente assinados.

Crie o pacote OTA assinado da seguinte forma:

 build/tools/releasetools/ota_from_target_files -k keys/bullhead/releasekey dist/signed-target-files.zip dist/signed-ota-update.zip

Reinicie para a recuperação usando os botões físicos do seu dispositivo.

Na recuperação, você verá um pequeno símbolo do android. Mantenha pressionado o botão de energia e pressione o volume para cima para entrar no menu de recuperação.

Agora, selecione “atualizar via adb” usando os botões físicos do seu dispositivo.

Sideload seu pacote OTA assinado:

out/host/linux-x86/bin/adb sideload dist/`signed-ota-update.zip`

Referências

[1] https://www.reddit.com/r/CopperheadOS/comments/8qdnn3/goodbye/

[2] https://copperhead.co/android/docs/building

[3] https://wiki.lineageos.org/devices/bullhead/build

[4] https://source.android.com/setup/build/downloading

[5] https://github.com/anestisb/android-prepare-vendor

[6] https://source.android.com/setup/start/build-numbers.html#source-code-tags-and-builds