Costruire e flashare una build AOSP sicura con boot verificato e password separata per lo schermo di blocco per il Nexus 5X

Disclaimer e Licenza

Tutti i dati e le informazioni forniti in questo tutorial sono solo a scopo informativo. L’autore non fa alcuna dichiarazione riguardo l’accuratezza, completezza, attualità, idoneità o validità di qualsiasi informazione in questo tutorial e non sarà responsabile per eventuali errori, omissioni o ritardi in queste informazioni o per eventuali perdite, infortuni o danni derivanti dalla loro visualizzazione o utilizzo. Tutte le informazioni sono fornite così come sono.

In nessun caso, l’autore o howtoforge sarà responsabile per qualsiasi perdita o danno, inclusa, senza limitazioni, perdita o danno indiretto o consequenziale, o qualsiasi perdita o danno derivante dalla perdita di dati o profitti derivanti da, o in connessione con, l’uso di questo tutorial.

Salvo diversa indicazione, il contenuto di questa pagina è concesso in licenza sotto la Licenza Creative Commons Attribution 3.0, e i campioni di codice sono concessi in licenza sotto la Licenza Apache 2.0.

Motivazione

Il Nexus 5X e 6P sono stati i primi dispositivi a supportare il boot verificato basato su chiavi di firma fornite dall’utente (e non imposte dal fornitore). Prima della sua “implosione” [1], CopperheadOS (una variante AOSP migliorata per la sicurezza) forniva una buona documentazione e script per costruire e flashare una versione AOSP sicura [2]. Tuttavia, il progetto ha smesso di fornire aggiornamenti negli ultimi mesi, quindi la maggior parte degli ex utenti sta cercando alternative valide.

La mia impressione è che molti utenti concordino sul fatto che eseguire una ROM AOSP auto-costruita sia un’alternativa molto migliore rispetto ad altre opzioni come passare a e.g. LineageOS. Ci sono diversi buoni motivi per questo:

AOSP è stock puro e ha solo poche funzionalità potenzialmente indesiderate
AOSP può essere costruito come build “user” invece di “userdebug” e, quindi, ci si aspetta che sia più sicuro (ho provato a compilare build user di LineageOS, ma sembrano essere rotte a causa delle modifiche invasive apportate da LineageOS ai sorgenti AOSP)
Una volta recuperati i sorgenti, AOSP può essere semplicemente costruito. A differenza di LineageOS, non inizia a scaricare sorgenti aggiuntive durante la costruzione.

Poiché si crede che il Nexus 5X sia un dispositivo per sviluppatori ben supportato, mi aspettavo che il processo di costruzione di AOSP fosse facile e ben documentato. Tuttavia, si scopre che ci sono diverse avvertenze:

includere i binari del fornitore seguendo la documentazione ufficiale porta a build incomplete che non possono essere utilizzate per aggiornamenti incrementali senza sbloccare e cancellare ogni volta (la partizione del fornitore, radio ROM ecc. non è inclusa nella build)
la documentazione ufficiale non descrive come utilizzare la build verificata in un modo che sia direttamente applicabile. C’è una documentazione migliore nei documenti di CopperheadOS [05], ma le istruzioni si basano su script obsoleti che non sono applicabili per AOSP.
non c’è documentazione su come utilizzare un PIN “debole” come passphrase ma una password forte come chiave di crittografia del disco (a differenza dei dispositivi Pixel più recenti, il Nexus 5X si basa sull’approccio FDE più vecchio). I metodi che funzionano per i dispositivi LineageOS non sono applicabili poiché presumono che il dispositivo sia rootato, il che non è il caso per le build utente AOSP regolari.

Questo tutorial mira a fornire istruzioni dettagliate su come risolvere queste avvertenze, costruendo e flashando AOSP per il Nexus 5X con boot verificato e utilizzando segreti separati per lo schermo di blocco/crittografia. Dovrebbe applicarsi anche al Nexus 6P con piccole modifiche, ma non sono stato in grado di testarlo poiché non avevo un Nexus 6P a disposizione.

Salvo una piccola raccolta di script (necessaria per estrarre correttamente i blob del fornitore dai binari forniti da Google) e la sua dipendenza “oatdump” (che viene scaricata come binario da una condivisione pubblica), le istruzioni non fanno uso di alcuna risorsa di terze parti “non ufficiale” (nel senso di “non fornita da Google”).

Fai attenzione ai seguenti problemi di libertà:

L’albero sorgente AOSP contiene un certo numero di binari precompilati (e.g. toolchain, kernel Linux, …). Anche se questi binari potrebbero essere ricostruiti a partire dal sorgente, i passaggi necessari non sono coperti in questo tutorial.
Il codice sorgente per i blob del fornitore necessari per utilizzare molti componenti hardware del Nexus 5X non è disponibile pubblicamente!
Lo strumento “android-prepare-vendor” utilizzato per estrarre i file proprietari del fornitore utilizza a sua volta binari precompilati (alcuni anche ospitati esternamente).

Requisiti e assunzioni

Il tutorial presuppone che tu abbia i seguenti prerequisiti (altre versioni/distribuzioni potrebbero funzionare ma potrebbero richiedere pacchetti diversi o aggiuntivi):

un Nexus 5X con bootloader sbloccato (lo sblocco non è coperto in questo tutorial)
macchina (virtuale) che esegue Debian9 nella variante x86_64, utilizzata esclusivamente per il nostro scopo (presumiamo che tu utilizzi sudo, in caso contrario, adatta i comandi)
almeno 5 GB di RAM (meglio di più)
circa 200 MB di spazio su disco
connessione internet veloce (dobbiamo scaricare circa 30G di dati)

Installazione delle dipendenze

Per prima cosa, installa le dipendenze come descritto nelle istruzioni di build di LineageOS [3] (le istruzioni di build AOSP non forniscono questa 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

Ora, installa dipendenze aggiuntive:

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

Poi, imposta un percorso bin nella tua home directory (in Debian 9 questo percorso è configurato automaticamente nel profilo bash):

mkdir -p ~/bin

Installa il comando repo:

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

Verifica il checksum del binario repo. Dovrebbe essere e147f0392686c40cfd7d5e6f332c6ee74c4eab4d24e2694b3b0a0c037bf51dc5 per la versione attuale 1.23. per versioni successive controlla la pagina delle istruzioni di build AOSP [4]. Usa il seguente comando per calcolare il checksum:

sha256sum ~/bin/repo

Successivamente, fornisci un’identità git eseguendo i seguenti comandi (puoi lasciare i dati di esempio se preferisci rimanere anonimo):

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

git config --global user.name "Il tuo Nome"

Sfortunatamente, il pacchetto brotli (richiesto per impacchettare le build) in Debian 9 è troppo vecchio, quindi dobbiamo costruire noi stessi la versione attuale. Prima ottieni il codice sorgente e cambia nella sua directory:

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

Esegui la build (sostituisci -j15 con il numero dei tuoi thread cpu):

cd ~/brotli

./configure-cmake

make -j15

Infine, copia il binario risultante nel nostro percorso bin:

cp brotli ~/bin/

Infine, esci e accedi di nuovo in modo che il tuo profilo bash venga riletto.

Ottenere i blob del fornitore

Ci sono diversi problemi con l’utilizzo dei blob del fornitore dai pacchetti di driver binari forniti da Google (vedi [5]). Per risolverli, utilizziamo il set di script esterni “android-prepare-vendor” di “anestisb” che estrae i blob del fornitore dalle immagini di fabbrica invece.

Per prima cosa, clona il repository:

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

Utilizzando il sito di Google [6], scopri l’ultima Build tag per il tuo Nexus 5X (attualmente è OPM6.171019.030.K1).

Cambia nel repository, crea una directory di output ed esegui lo script (eseguiamo lo script come root a causa di problemi con fuse in 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

Scaricare i sorgenti AOSP

Nota: I seguenti passaggi mancano di istruzioni per verificare il sorgente scaricato.

Per prima cosa, crea una directory dove verranno memorizzati i sorgenti:

mkdir -p ~/aosp

Sapendo l’attuale tag di build per il Nexus 5X, scopri qual è il corrispondente tag Android utilizzando la panoramica disponibile su [6]. Poi, checkout il manifest Android per il ramo corrispondente (in questo esempio, usiamo android-8.1.0_r46):

cd ~/aosp

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

come al solito in XML per commentare i repository. Ti consiglio di escludere/sostituire i seguenti:

- il QuickSearchBox è per lo più rotto in AOSP comunque
- sostituisci questo con un repository che contiene un albero del dispositivo patchato dove i due core cpu difettosi sono disabilitati. Questo comporta una penalità di prestazioni di circa il 30%. Tuttavia, è raccomandato, anche se hai un Nexus 5X che non è affetto dal bootloop, poiché è probabile che sarà colpito in futuro.
- ci sono alternative migliori al calendario stock di AOSP che puoi installare in seguito (come Etar)
- Silence.im è un’alternativa migliore per l’app di messaggistica AOSP
- OpenCamera è un’alternativa migliore per la fotocamera stock

Ora, recupera tutti i repository (può richiedere molto tempo, principalmente a seconda della tua connessione internet):

repo sync

Infine, copia i blob del fornitore precedentemente generati come root (questo è necessario, altrimenti qmus e altri blob mancheranno e causeranno un fallimento di compilazione successivo) nella directory vendor del tuo albero AOSP (sostituisci il numero di build di fabbrica con quello attuale):

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 .

Rendi il tuo utente il proprietario delle directory vendor (altrimenti la build fallirà in seguito). Sostituisci yourusername con il tuo nome utente effettivo:

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

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

Generazione delle Chiavi

Imposta le variabili di build:

source build/envsetup.sh

Costruisci lo strumento necessario per generare la chiave di verità:

make generate_verity_key

Crea una directory per memorizzare le tue chiavi (i documenti CopperheadOS [2] raccomandano di utilizzare una chiave separata per ogni dispositivo, in questo caso bullhead):

mkdir -p keys/bullhead

Ora è il momento di generare le chiavi (non impostare password sulle tue chiavi):

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

Converti la chiave di verità nel formato richiesto da AOSP:

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

Compilazione

Assicurati che le tue variabili di build siano impostate:

cd ~/aosp

source build/envsetup.sh

Crea una configurazione lunch per il dispositivo bullhead (sostituisci user con userdebug se desideri una configurazione userdebug invece):

lunch aosp_bullhead-user

Disabilita Jack (spesso causa problemi di compilazione ed è stato deprecato in Android 9 comunque):

export ANDROID_COMPILE_WITH_JACK=false

Compila il pacchetto dei file di destinazione (sostituisci -j15 con il numero dei tuoi thread cpu):

make target-files-package -j15

Imballaggio e firma

Crea una directory per memorizzare i file di output (al di fuori della solita directory di build chiamata out):

mkdir dist

Esegui il target dist (sostituisci -j15 con il numero dei tuoi thread cpu):

make dist -j15

Crea un pacchetto di file di destinazione firmato, sostituendo le chiavi di test predefinite con le tue chiavi (sostituisci yourusername con il tuo nome utente effettivo nel 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

Crea un pacchetto OTA firmato:

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

Flashing

Avvia il tuo dispositivo Nexus 5X nel bootloader (tieni premuto il volume giù, poi premi accensione).

Collega il tuo dispositivo tramite USB al tuo computer (e rendilo disponibile alla VM nel caso tu stia costruendo in una VM). Puoi anche copiare i contenuti dalla directory dist su un altro computer e flashare da lì, ma presumiamo che tu flashi utilizzando i binari fastboot/adb costruiti dai sorgenti AOSP (se flashi da fuori, assicurati che il tuo binario fastboot sia recente).

Estrai le immagini da signed-target-files.zip:

cd ~/aosp/dist

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

Ora, flasha tutte le immagini:

../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

Seleziona “riavvia sistema” utilizzando i pulsanti fisici del tuo dispositivo e assicurati che il tuo nuovo sistema funzioni.

Infine, riavvia nel bootloader e ri-bloccalo (cancellerà tutti i dati):

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

Ecco fatto!

Impostare segreti di avvio/schermo di blocco separati

Impostare una password di avvio/schermo di blocco separata può essere fatto con un piccolo trucco:

Sblocca il bootloader (cancella tutti i dati)
compila e flasha una build userdebug (vedi sopra)
blocca il bootloader
imposta un PIN/password per lo schermo di blocco utilizzando l’interfaccia utente di Android. Assicurati di scegliere quello giusto perché non potrai cambiarlo di nuovo senza cancellare i tuoi dati una volta che passerai alla build utente.
connettiti al dispositivo tramite adb
come root, esegui il seguente comando: vdc cryptfs changepw password your-new-password
riavvia e assicurati che funzioni
compila una build utente regolare (non sbloccare il bootloader!)
flasha la build utente

Nota: Senza passaggi aggiuntivi, il recovery non consente di flashare build più vecchie. Quindi, devi flashare una build utente che sia più recente della tua build userdebug!

Gestire gli aggiornamenti

Se desideri aggiornare a una nuova versione AOSP, devi prima scoprire il nuovo numero di versione.

Poi, cancella il vecchio manifest (fai un backup, nel caso tu abbia apportato modifiche che desideri ripetere su quello aggiornato):

cd ~/aosp

rm -rf .repo/manifests.git

rm -rf .repo/manifest.xml

Inoltre, cancella i blob del fornitore (allora obsoleti) e il repository prepare-vendor:

rm -rf ~/android-prepare-vendor

rm -rf vendor

rm -rf vendor_overlay

Inoltre, pulisci l’albero di build e gli artefatti di build:

rm -rf out

rm -rf dist

Poi, ripeti SOLO i seguenti passaggi:

Ottenere i blob del fornitore
Scaricare i sorgenti AOSP (questo sarà molto più veloce, perché verranno recuperate solo le modifiche)
Compilare
Imballare e firmare

In teoria, dovresti essere in grado di sideload aggiornamenti come nuovi pacchetti OTA dal recovery senza cancellare (poiché sarà firmato con le stesse - tue - chiavi). In pratica, non funziona ancora (vedi la sezione successiva). Lì, dovrai anche procedere come segue:

Esegui il backup di tutti i tuoi dati
Sblocca il bootloader (i tuoi dati verranno cancellati)
Flasha le immagini aggiornate e ri-blocca il tuo bootloader come descritto nella sezione “Flashing”

WIP: Aggiornamenti OTA firmati

Questa sezione è WIP, le istruzioni descritte non funzionano ancora!

In teoria, dovrebbe essere possibile creare e flashare aggiornamenti OTA firmati dal recovery. Tuttavia, tutti i miei tentativi di farlo hanno portato a un errore di “Verifica della firma fallita”. Poiché questo funziona quando si utilizzano direttamente i file del fornitore forniti da Google invece di utilizzare android-prepare-vendor, presumo che sia correlato ai file del fornitore o ad altri file (come le immagini del bootloader o della radio) non firmati correttamente.

Crea il pacchetto OTA firmato come segue:

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

Riavvia nel recovery utilizzando i pulsanti fisici del tuo dispositivo.

In recovery, vedrai un piccolo simbolo android. Tieni premuto il pulsante di accensione e premi volume su per accedere al menu di recovery.

Ora, seleziona “aggiorna da adb” utilizzando i pulsanti fisici del tuo dispositivo.

Sideload il tuo pacchetto OTA firmato:

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

Riferimenti

[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