Supersu 2 66 Binario Options

SuperSU APK SuperSU è lo strumento di gestione degli accessi Superuser del futuro. SuperSU richiede un dispositivo radicata. SuperSU consente la gestione avanzata dei diritti di accesso Superuser per tutte le applicazioni presenti sul dispositivo che hanno bisogno di root. SuperSU è stato costruito da zero per contrastare una serie di problemi con altri strumenti di gestione di accesso superutente. Le caratteristiche includono: 8211 rapidamente accesso Superuser 8211 l'accesso di registrazione Superuser 8211 accesso Superuser notifiche 8211 Per-app di configurazione di notifica 8211 Unroot temporanea 8211 rilevamento processo di profonda (non più incognite) 8211 Lavori in recupero (non di più va in segfault) 8211 funziona quando Android isn39t correttamente avviato 8211 funziona con sedi shell non standard 8211 viene sempre eseguito in modalità fantasma 8211 Wake on pronta 8211 Conversione di sistema app 8211 completo Unroot 8211 script di backup per sopravvivere nightly CyanogenMod 8211 Icona selezionabile tra 5 opzioni invisibile selezionabili 8211 Theme from 4 opzioni 8211 lanciare da dialer: 1234 o 7.873.778 (SUPERSU) NOTA: Non tutti i telefoni prendere entrambi i codici. Su alcuni telefoni è necessario utilizzare singola invece di doppia La versione Pro offre inoltre: 8211 in modalità OTA di sopravvivenza (garanzie) 8211 color-coded contenuti comando di registrazione completa (inputoutputerror) 8211 configurazione di registrazione Per-app 8211 Per-app utente di override 8211 Grantdeny radice di un app per un certo lasso di tempo 8211 protezione PIN 8211 protezione PIN per-app 8211 Regolare auto-negare il conto alla rovescia SUPERUSER Questo è lo scopo di sostituire Superuser (se installato), è possibile utilizzare l'uno o l'altro. Non si possono combinare. Dichiarazioni che questo rompe Superuser sono quindi del tutto priva di senso. AVVISO: Un procedura speciale necessari per la disinstallazione. SE NON piace l'applicazione, NON SOLO DISINSTALLARE IT, si perde ROOT. la gestione degli accessi Superuser attraversa un cosiddetto binaryquot quotsu. Ci può essere solo uno di questi alla volta. Quindi, se si installa SuperSU, la soluzione di gestione degli accessi superuser precedente non sarà più funzionare. Quindi, se si vuole tornare: (1) aprire l'applicazione, e la ricerca di una opzione per poter installupdatereplace il binaryquot quotsu. (2) Verificare le applicazioni di root-usando utilizzano la soluzione superutente che si desidera. (3) Disinstalla SuperSU. Acquisti in-app Questi sono completamente opzionali e più come donazioni. Non sbloccare alcuna funzionalità. Contattaci: sito web. Forum supersu: forum. supersu Facebook: facebookSuperSU-1024576694301637 What8217s Nuova guida all'installazione Manuale d'uso migliorata compatibile con l'ultima versione di TWRP (recupero personalizzato) rilevamento FBE sul kernel SU migliorato Compatibile con Google Pixel amp Pixel XL, così come varie marche con la Android 7.1 versione del sistema installato Security registro dell'agente aggiunto al kernel Samsung KNOX rilevamento SU aggiornato (forza seclabel) sulla privacy addedSuperSU -, Radice. SuperSU ROOT SuperSU, radice. SuperSU,,,. : - - - - - - - - Android - - - - - -, CM - - -: 1234 o 7.873.778 (SUPERSU):. . Pro: - OTA quotsurvival modequot () - () - - - - PIN - - PIN - SUPERUSER Superuser (),. . ,, Superuser. :. APP,. , -. quot quot. . SuperSU,. : (1),, quot quot. (2),,,,. (3) SuperSU. In-app. . : Supersu: forum. supersu Facebook: facebookSuperSU-1024576694301637 SuperSUFUKING MERDA BINARIO, nuovo binario. KingoRoot REGOLE KingRoot - QUESTO PROGRAMMA è una merda PIENA. 4,, 1000. ,, 20,,. : Baidu Radice, KingRoot, Framaroot. ))) Root Checker))). . 1. Introduzione Da quando ho iniziato a scrivere SuperSU, ho incontrato un sacco di problemi di attuazione. Problemi con il mio codice in SuperSU, stranezze senza documenti in Android, e problemi di altri popoli apps richiedono radice. Nel corso del tempo Ive passato attraverso un sacco di codici sorgente applicazioni (o invertito i binari) per capire la radice dei problemi, e ha lavorato con vari autori app (dallo sconosciuto al famoso) per risolverli. Grazie a questi sforzi, è diventato chiaro che la maggior parte si blocca e si blocca relativi alla do l'accesso - sia con SuperSU così come Superuser - provengono da due problemi fondamentali: come do viene chiamato, e quando viene chiamato su. Questi casi non sono così semplici come possono sembrare. Mi è stato chiesto da un certo numero di sviluppatori di scrivere questa guida per fornire linee guida e ulteriori informazioni su come aggirare tutti questi problemi - e questo è ciò che si sta leggendo. Poiché questo è importante per tutte le applicazioni di root, ho anche chiesto Adam ChainsDD Shanks (autore di Superuser) a recensire questo documento, che ha fatto. Io non aspettatevi di essere l'ultima parola sulla questione, o che gli esempi di codice sarà perfetto. Spero che questo documento e il codice vi fornirà le conoscenze necessarie, e in generale un buon inizio. - Jorrit Chainfire Jongma, autore di SuperSU 2. Codice: libsuperuser C'è codice sorgente che accompagna questo documento, sotto forma di libsuperuser GitHub (un progetto di libreria contenente codice riutilizzabile per chiamare su) e libsuperuserexample GitHub (un progetto di esempio utilizzando tale biblioteca e dimostrando alcune tecniche per chiamare su in background). L'obiettivo di questi due progetti è specificamente di non fornire una perfetta ristorazione libreria per ogni vostra esigenza di root. L'obiettivo è quello di dimostrare le tecniche si consiglia di riutilizzare nel vostro app radice che risolvere problemi comuni, in meno codice possibile. Tecniche avanzate come ad esempio il mantenimento di uno sfondo su sessione e usando quella sessione in caso di necessità non sono oggetto del presente articolo, per il bene di mantenere le cose semplici. La biblioteca ha tuttavia includere la classe Shell. Interactive per renderlo possibile. Il codice è breve, io vi consiglio di leggere semplicemente la fonte per entrambi i progetti. Si prega di notare che questa biblioteca si comporta in modo leggermente diverso in modalità debug (non firmato APK), che fornisce la registrazione ed eccezioni supplementari. Alcune versioni di ADT non setunset modalità di debug in modo corretto al momento della firma e l'esportazione del APK finale. Si dovrebbe controllare che le APK esportati non sono ancora registrare tutte le chiamate di shell prima di pubblicarli 3. Come chiamare su 3.1. Errori più frequenti Runtime. exec () e ProcessBuilder si è tentati di usare Runtime. getRuntime (). exec (comando su - c). ma si deve essere consapevoli che il comando dovrebbe essere un unico parametro, e quindi può richiedere il quoting. Purtroppo entrambi citando il parametro di comando, nonché il superamento delle paramaters come variabili indipendenti a uno Runtime. exec () o ProcessBuilder non funziona in modo coerente in tutte le versioni di Android, e quindi questo costrutto dovrebbe essere evitato del tutto. Non è impossibile fare questo diritto - ma c'è un alto rischio di problemi. Emissione di uno script per la do a funzionare come una soluzione a quanto sopra, vari autori radice app hanno preso a scrivere gli script e quindi chiamando su - c pathtoscript per eseguire tutti i comandi. Questo fa di evitare potenziali problemi di passaggio di parametri, ma si sta creando un file temporaneo non necessario e richiede che il percorso scrivibile non contiene uno spazio. E mentre il secondo è vero per il momento, è una cattiva idea di dipendere da quello. Ci possono essere anche problemi di SELinux correlati con questo metodo (vedere la sezione SELinux di seguito). Rapid successive su chiamate La chiamata su è un'operazione costosa, e di solito comporta un po 'di codice in esecuzione, oltre ad essere eseguita IO. E 'buona pratica così come buona per le prestazioni in batch i comandi insieme il più possibile. Avviare il minor numero di processi do, come si può, ed eseguire come molti comandi per ogni processo il più possibile. Molti su chiamate in tutto il ciclo di vita delle applicazioni Alcune applicazioni hanno bisogno di fare un sacco di chiamate su tutto il ciclo di vita delle applicazioni, ma in lotti sopraelevazione questi comandi insieme. In tal caso si dovrebbe prendere in considerazione di iniziare una shell interattiva su e mantenere in vita a fianco la vostra applicazione, in modo da poter comandi del tubo ad esso, se necessario. Questo potrebbe avere effetti positivi sulle prestazioni e la reattività della vostra applicazione. controlli hardcoded L'applicazione di gestione dei diritti non è sempre systemappSuperuser. apk. Il nome del pacchetto non è una costante sia. La su binarys posizione non è sempre systemxbinsu. Molte applicazioni hanno controlli hardcoded come questi per trovare su. Questa è una cattiva idea e completamente inaffidabile. Supponendo che il binario su accetta parametri non tutti i binari do supportano tutti i parametri. Peggio ancora, theres una buona probabilità che il do binario inizierà una shell interattiva invece di produrre un errore se un parametro ignoto è presente (il parametro - v per controllare la versione è un buon esempio di questo). Se non si prevede di questo, il vostro processo potrebbe non riprendere il controllo dalla chiamata su, e potrebbe diventare bloccato. 3.2. Effettuare la chiamata Un metodo comune per chiamare su che evita i problemi noti di cui sopra è la creazione di un interattivo comandi di shell e tubazioni ad esso. Questo viene fatto chiamando Runtime. getRuntime (). Exec (su). e recuperare i flussi di input e output dall'oggetto processo restituito. Fare questo è un pezzo abbastanza straight-forward di codice, ma compresi i registri di debug e verifica la sua un po 'lungo per riprodurre qui. Il codice di base si trova qui: libsuperuser. Shell. java GitHub. Shell. run () è una chiamata generica per eseguire codice shell, i seguenti (statiche) funzioni più specifiche di utilità sono quelli che probabilmente si finisce per utilizzare: Le varianti SH sono utilizzati per una shell non-root, in cui le varianti sono SU utilizzato per una shell di root. Queste chiamate restituiscono un ListltStringgt contenente l'output dei comandi di shell. Se non ci fosse uscita, l'elenco è vuoto, ma non nulla. Il risultato è nullo solo in caso verificato un errore di accesso negato possono o non possono innescare nullo. Questi stanno bloccando le chiamate. Si noti che in di debug compila, tutto STDINSTDOUTSTDERR guscio sarà registrata a logcat, e queste chiamate saranno (intenzionalmente) in crash la vostra applicazione se chiamato dal thread principale. La ragione di questo sarà discusso nella sezione 4. Quando chiamare su. 3.3. Verifica della disponibilità su Ci sono molti modi per verificare se è disponibile un accesso superutente. I due metodi più diffusi sono o cercando di rilevare l'esistenza di pacchetto binario o superutente su, o in realtà il tentativo di eseguire su e vedere cosa succede. Io preferisco il secondo metodo, come in esecuzione su è quello che stai dopo, non importa dove la sua struttura e se sai come trovarlo - fino a quando il sistema fa. Come ulteriore prova, eseguire il comando id, che stampa gli ID dell'utente corrente e di gruppo, in modo da poter utilizzare l'uscita per confermare se il guscio o non è stata avviata anche in realtà ha i diritti di root (l'output contiene uid0). Un problema con il comando id è che dipende su un binario esterno che deve essere presente. Non ho mai incontrato la situazione in cui non era, ma per essere sicuri che anche formulare un comando echo che controlliamo per, in modo che se il comando id non è disponibile, possiamo ancora sapere se una shell è stato eseguito affatto. In quest'ultimo caso, si assume la shell ha anche privilegi di root - se questo finisce per essere sbagliato, l'utente ha problemi peggiori che la vostra applicazione non ottenere l'accesso come root. Se si vuole essere assolutamente sicuro che anche in questo caso, a distanza di un dispositivo a torto radicata, si dovrà includere il proprio binario nativo per eseguire il controllo. Naturalmente, se si include file binari nativi in ​​ogni modo, è certamente consigliato di farli verificare se sono effettivamente in esecuzione come root prima di fare qualsiasi altra cosa. libsuperuser. Shell. java GitHub fornisce le seguenti (statico) funzione di utilità che esegue questo test per voi: si tratta di una chiamata di blocco. 3.4. Controllo della versione su Anche se questo non è qualcosa che la maggior parte delle applicazioni di root devono fare, e non tutti su binari anche sostenere questo, questo potrebbe essere qualcosa che si desidera fare. Entrambi i (recenti) binari Superuser do così come SuperSU Su binari supportano il - v (per la visualizzazione) e - V (per interni) il confronto dei parametri per verificare il numero di versione. Come detto sopra, un potenziale problema è che a su binario quello non supporta questi parametri può avviare una shell interattiva invece. Un work-around per questo è di exitn tubo per il processo su, questo assicurerà la vostra applicazione ottiene il controllo da su. libsuperuser. Shell. java GitHub fornisce le seguenti (statico) funzione di utilità che consente di recuperare i numeri di versione (per la su binario, non il pacchetto GUI), oppure il valore null se non è possibile: si tratta di una chiamata di blocco. 3.5. namespace Mount Quando versioni SuperSU 1,50 e fino eseguito in modalità demone (Android 4.3 e versioni precedenti rari OEM di Android con SELinux impostati per far rispettare), ogni processo su shell riceve un isolato di montaggio dello spazio dei nomi. Ciò significa che i supporti applicati in una do shell non possono essere visibili ad altri processi, ad eccezione (la maggior parte) altre shell Su iniziate da lo stesso processo genitore (la vostra applicazione). SuperSU in questo caso cerca anche di rendere i SDcards monti e supporti specifici dell'utente disponibili alla shell su, si spera che rende il lavoro più facile. Una delle caratteristiche di questo isolamento namespace monte è che impedisce le applicazioni di interferire con eachothers supporti in modo che le condizioni di gara tra due applicazioni cercando di manipolare lo stesso monte (sistema di commutazione tra di sola lettura e lettura-scrittura più volte, per esempio) non può avvenire , e tutto funziona come lo sviluppatore dell'app si aspetta. Android si è offerto un analogo isolamento dello spazio dei nomi di montaggio per applicazioni a partire dalla versione 4.2. versioni SuperSU 1,93 e fino supportano l'opzione --mount-master, che (se in esecuzione in modalità demone) connette la vostra applicazione di uno speciale su shell, che montano i comandi vengono applicati a tutti i processi. Se è necessario applicare pubblicamente un monte, utilizzare questa opzione. 4. Quando chiamare su 4.1. Quando non chiamare su Il thread principale Non chiamare su quando si esegue sul thread principale dell'applicazione. Il numero uno dei motivi per blocca e si blocca quando l'accesso app richiesta principale è che do viene chiamato dal thread principale. Si dovrebbe prendere in considerazione il comando su per essere equivalente a una chiamata IO blocco, come il disco o l'accesso alla rete. Questi non dovrebbe essere fatto dal thread principale o - in effetti, sulle versioni più recenti di Android, l'esecuzione di rete IO nel thread principale sarà (intenzionalmente) in crash la vostra applicazione, e in modalità rigorosa dello schermo lampeggia rosso se si esegue qualsiasi disco IO il thread principale per avvertirvi di vostro errore. Blocco IO invita il thread principale sono male, perché è completamente dipendente da fattori esterni quanto tempo la chiamata avrà. La chiamata può assumere 100 millisecondi, 30 secondi, o un'ora. Anche se pensate che qualche comando minore IO non dovrebbe mai prendere più di pochi millisecondi, è ancora dovreste farlo dal thread principale - sei fare una garanzia non puoi consegnare il, e, probabilmente, riducendo la capacità di risposta della vostra applicazione. Se i principali blocchi di filettatura applicazione come questo per più di qualche secondo, un'applicazione non risponde (ANR) incidente è generato dal sistema. Perché la chiamata su è praticamente garantito per eseguire il blocco IO stesso, e potrebbe anche bisogno di mostrare la sua interfaccia grafica e aspettare l'input dell'utente, non è possibile fare alcuna ipotesi su quanto tempo ci vorrà per la chiamata per tornare, e, quindi, non si dovrebbe mai chiamare dal thread principale. Spesso ho ricevuto lamentele da parte degli utenti SuperSU circa il conto alla rovescia nella accesso root richiesta di popup che è (al momento della stesura di questo) abilitato per impostazione predefinita, e voglio negare automaticamente l'accesso come root dopo un certo numero di secondi. L'unica ragione per questo timer è stato costruito è perché troppi applicazioni radice chiamano su dal thread principale, e se il popup non timeout e l'utente andrei concedere o negare l'accesso di root in tempi relativamente brevi, l'applicazione che aveva richiesto su accesso potrebbe andare in crash con una ANR. Il timer aiuta a ridurre (ma non eliminare) le probabilità che questo accada, ma si limita a trattare i sintomi, non risolvere problemi. Una nota su su essere una chiamata di blocco La maggior parte dei modi per iniziare un nuovo processo sono in realtà non-blocking, e il processo figlio viene eseguito in un thread diverso. Tuttavia, la maggior esempio e libreria di codice o chiamare Process. waitFor o readwrite dalal la processs STDIN, STDOUT o flusso STDERR. Tutte queste possibilità girare il codice che chiama su un blocco del codice, in attesa del processo su. Anche se è effettivamente possibile chiamare su in modo non bloccante dal thread principale, ma è facile commettere errori in questo modo, ed è spesso più semplice per creare un unico blocco di codice che gestisce chiamando su (come il campione Shell codice. XX. run fornito) e semplicemente eseguire che da un thread diverso. Vi sono tuttavia situazioni in cui chiamata su in modo non bloccante è effettivamente preferito (come tenere una sessione su aperta in background e continuamente lettura e scrittura dalal esso). Il codice di esempio fornisce la classe Shell. Interactive che può essere utilizzato in questo modo dal thread principale, in coda i comandi e la ricezione di callback, ma come utilizzare questa classe non è documentato da questo articolo (leggere la documentazione in linea nel codice sorgente, invece ), per il bene di mantenere le cose semplici. BroadcastReceivers maggior parte del tempo BroadcastReceiver s corsa sul thread principale (cosa spesso trascurata), e, quindi, nessun blocco IO chiama come do dovrebbe essere fatto. A parte in esecuzione sul thread principale, la stessa su chiamata potrebbe essere necessario trasmettere l'intenzione di comunicare con l'interfaccia grafica. Ciò presenta un problema perché quest'ultimo trasmissione sia in attesa sulla trasmissione precedente per completare, che non farà finché il metodo OnReceive completa, che è a sua volta in attesa del su chiamata per completare. Ciò causerà un ANR. Servizi Come con BroadcastReceiver s, molti sviluppatori in un primo momento si affacciano che un servizio di base esegue anche sul thread principale, ed è quindi anche suscettibili di ANR. Cioè, a meno che non si utilizza una speciale sottoclasse di servizio (come IntentService) che utilizza un thread in background, o aggiunto un thread in background per il servizio da soli. 4.2. Rilevare il thread principale Rilevare se il codice è in esecuzione sul thread principale è generalmente fatto come segue: Potreste aver notato questo codice nella Shell. run () chiamata in libsuperuser. Shell. java GitHub. Se viene rilevato è in esecuzione sul thread principale, e il progetto Android viene compilato in modalità debug (BuildConfig. DEBUG vero), un'eccezione verrà generata e andrà in crash l'applicazione. Speriamo che questo vi convincerà a provare ed eseguire il codice shell in un thread in background - e di non rimuovere il controllo 4.3. Utilizzando classe AsyncTask Il AsyncTask viene spesso utilizzato per eseguire l'elaborazione in background semplice e veloce per operazioni relativamente brevi. Si può tranquillamente chiamare do dal AsyncTask s metodo di doInBackground. Ecco un esempio di un'implementazione minima all'interno un'attività. Naturalmente, di solito si consiglia di eseguire del codice prima e dopo l'attività in background viene eseguito, come mostrare e nascondere un ProgressDialog modo che l'utente sappia viene eseguita un'azione di fondo, e la GUI cant essere utilizzato fino a che l'azione completa: libsuperuserexample. MainActivity. java GitHub contiene un esempio di base. Si prega di notare che nulla è perfetto, e AsyncTask ha anche alcuni problemi. Ad esempio, il AsyncTask continua a funzionare fino a quando non è finito, anche se il possesso di attività è chiuso, a meno che non si chiama il AsyncTask s metodo di annullare, e in realtà la maniglia che nel metodo doInBackground (verificando periodicamente l'Andor stato cancellato assicurandosi che il metodo è interrompibile ). Ad esempio, l'utente ruotando il dispositivo può causare il Activity da chiudere e ri-creato, rilanciare il AsyncTask mentre quello vecchio è ancora in corso. Questi non sono problemi insormontabili, ma come con qualsiasi strumento utilizzato, è necessario sapere quando, come, e quando non usarlo. 4.4. Utilizzando IntentService Mentre AsyncTask è una classe molto utile è senza dubbio spesso impiegare, a volte il suo solo non lo strumento giusto per il lavoro. Ad esempio, non puoi utilizzare direttamente un AsyncTask da un BroadcastReceiver. perché una volta che il metodo OnReceive completata, il processo non può avere alcun componenti attivi a sinistra, e quindi possono essere uccisi. La cosa giusta da fare per qualsiasi blocco IO - tra cui su chiamate - da un BroadcastReceiver sta iniziando un servizio e l'esecuzione del codice da lì. Tuttavia, un servizio standard in realtà viene eseguito sul thread principale e, a meno che non si fa il lavoro extra per eseguire codice in un thread in background. La classe IntentService però, è un facile da usare Servizio sottoclasse progettato specificamente per eseguire attività (espresso da Intent s) in un thread in background, e automaticamente fermarsi quando si esaurisce di lavoro. Perfetto per il fuoco e dimentica le attività di stile. Molte applicazioni utilizzano un BOOTCOMPLETED BroadcastReceiver per eseguire alcune elaborazioni dopo che il dispositivo viene avviato, senza l'interazione dell'utente - un caso perfetto per IntentService. Il file AndroidManifest. xml partirà cercando qualcosa di simile, con un (esportata) BroadcastReceiver pubblica e una privata (non esportato) IntentService. Successivamente, creiamo un IntentService molto di base in BackgroundIntentService. java. Tutto ciò che rimane ora, è quello di lanciare questo servizio in background dal BroadcastReceiver. in BootCompleteReceiver. java. Questo è tutto ciò che c'è da fare - una volta che si sa come, la sua incredibilmente facile. Naturalmente, questo IntentService esegue solo una singola azione e non prende alcun parametro: libsuperuserexample. BackgroundIntentService. java GitHub contiene un esempio più elaborato. Invece di correre in vostro BroadcastReceiver sul thread principale, il codice è ora in esecuzione in modo sicuro in un thread in background senza rischiare un incidente ANR. C'è però un intoppo minore. Molte applicazioni inviano Toast s dal loro BroadcastReceiver s - questo è un po 'più difficile da fare da un thread in background a causa di alcuni bug minori nel quadro di Android. Fare riferimento alla libsuperuser. Application. java GitHub per una soluzione alternativa. 5. SELinux SEAndroid 5.1. Introduzione SELinux è l'abbreviazione di NSA Security-Enhanced Linux. e fornisce il controllo di accesso a grana fine oltre i limiti del controllo degli accessi uidgid-based. SEAndroid è il suo porto Android, che questo articolo farà riferimento anche a come SELinux. E 'utilizzato in una delle due modalità: modalità permissiva in cui vengono registrati violazioni delle policy, ma non si interviene, e la modalità in cui le violazioni dei dati viene impedito di far rispettare accada. SELinux è presente in magazzino Android da (Livello API 18, JELLYBEANMR2) 4.3 in modalità permissiva, ed è stato commutato in modalità enforcing in Android 4.4 (API livello 19, KitKat). Non si deve però dipendere da questi livelli di API per rilevare la presenza o la modalità di SELinux, in quanto vi sono anche alcuni (4.2) firmware allo stato selvatico con SELinux built-in e impostata far rispettare. e il caso molto più comune di 4,4 firmware in esecuzione in modalità permissiva. 5.2. Che cosa questo significa per voi come uno sviluppatore principale applicazione, è necessario imparare a trattare con SELinux. Non è necessario conoscere tutti i dettagli di questo sistema molto complesso e le politiche utilizzate dal magazzino così come costruisce OEM-custom, ma a seconda del tipo di applicazione radice si stanno facendo, potrebbe essere necessario passare un po 'di tempo in più test su diversi firmware e dispositivi per far funzionare le cose in modo affidabile. A peggiorare le cose, SELinux è un bersaglio mobile, con le politiche di cambiamento tra le versioni di Android e anche OEM - le politiche in materia di (ad esempio) un dispositivo di Samsung può essere significativamente diversi dalle politiche su un dispositivo Nexus. Se SELinux è impostato in modalità permissiva, c'è relativamente poco di cui preoccuparsi, ma quando si è impostato far rispettare. la parte della vostra applicazione in esecuzione come root può funzionare in tutti i tipi di restrizioni impreviste. versioni SuperSU 2.11 e più recenti rattoppare attivamente politiche di SELinux da Android 4.4 in poi, aggirando un gran numero di problemi di una applicazione radice altrimenti incorrere in su un sistema enforcing. Da versioni SuperSU 2.23 in poi, di gran lunga maggior parte dei casi si avrebbe bisogno di scrivere codice speciale per rientrano le patch più recenti di politica. Eppure, è bene leggere il resto di questa sezione in modo da sapere come funziona se si esegue in un caso speciale. Si noti che i vari kernel personalizzati e firmware passare SELinux torna a permissiva per Android 4.4 e versioni successive. Ciò disabilita completamente tutte le nuove caratteristiche di sicurezza SELinux porta, piuttosto che rilassarsi solo le aree che abbiamo assolutamente bisogno per ottenere le nostre applicazioni di funzionare. E 'raro che una applicazione principale per richiedere ulteriori patch per l'attuale politica di SELinux di là di quanto SuperSU già fa per voi, ma se è necessario, una API è previsto per questo. Si tratta, naturalmente, fino a che l'utente a decidere se SELinux dovrebbe essere permissivo o no, ma è certamente buona norma assicurarsi che le applicazioni funzionano su un sistema enforcing. C'è un sacco di menzione di varie versioni SuperSU. Questo è elencato solo per completezza, come molti dettagli sono cambiati tra la prima vendita al dettaglio Android 4.4 di rilascio e la prima vendita al dettaglio Android release 5.0. Android 5.0 gli utenti dovrebbero essere considerate in esecuzione la versione 2.23 o più recente. 5.3. Rileva SELinux Mentre è probabilmente saggio per assicurarsi che il codice viene eseguito indipendentemente dalla presenza o la modalità di SELinux, a volte è necessario rilevare se SELinux è presente e impostato per far rispettare. Questo può essere generalmente fa leggendo sysfsselinuxenforce. che è un file leggibile da chiunque. 5.4. CONTESTI 5.4.1. Nozioni di base Il contesto di SELinux corrente definisce che le politiche di sicurezza applicate al vostro processo. Il contesto usermode più alta è generalmente u: r: init: S0. Contrariamente a quanto ci si potrebbe aspettare, questo non significa necessariamente questo contesto ha accesso a tutto. Alcuni contesti comuni che possono entrare in contatto con: u: r: init: S0 - Massima contesto init usermode u: r: initshell: S0 - Shell ha iniziato da init u: r: shell: S0 - shell Unpriviliged (come ad esempio un adb shell ) u: r: systemserver: S0 - systemserver. u: r: Sistema: S0 su alcuni firmware u: r: systemapp: S0 - applicazioni di sistema U: R: platformapp: S0 - applicazioni di sistema U: R: untrustedapp: S0 - appsu terze parti: R: supersu: S0 - SuperSU s proprio contesto, v2.79-SR1 su Android 7.0 da 4 a 9 può essere utilizzato con - cn SuperSU s - opzione contesto. Con v2.60 su Android 5.0, tutti i contesti possono essere commutati a con questa opzione. I criteri predefiniti che compongono questi contesti si trovano sotto externalsepolicy nel vostro albero dei sorgenti di Android. Si noti che gli OEM tendono a modificare queste politiche, e queste politiche di cambiamento tra la versione di Android. Per assicurare la compatibilità, la vostra applicazione dovrebbe essere testato su tutte le revisioni API, e, se possibile, su dispositivi di punta da tutti i principali OEM - se non è possibile farlo da soli, dipenderà gli utenti di base. 5.4.2. init vs initshell vs guscio vs supersu Su firmware che utilizzano SELinux, su è generalmente implementato come un proxy per un demone avviato da init. E 'importante notare che Su gusci possono funzionare come u: r: init: S0. u: r: initshell: S0 o u: r: supersu: S0. SuperSU stessa dovrebbe sempre essere eseguito come u: r: init: u S0 o: r: supersu: S0 se SELinux è impostato a far rispettare. ma non tutte le shell di superutente fanno. Ci sono vari modi per passare contesti, per questo caso specifico il passaggio da u: r: init: S0 a U: R: initshell: S0 può essere fatto con il lancio di un secondo sh (fare attenzione a non usare mksh mentre viene deprecato) . Se si è un comando che deve essere eseguito come u: r: initshell: S0. Basta avvolgere il comando in sh - c. comando. . per fare in modo che lo fa. Adb usa la u: r: shell: contesto S0, che ha politiche molto diverse. Fare attenzione a non confonderli 5.4.3. Perché passare contesti si potrebbe chiedere perché - se ce ne fosse già in esecuzione, come il contesto init, come utente root, e con SuperSU patch attivamente politiche di SELinux - facciamo abbiamo ancora bisogno di attivare contesti Se su un sistema enforcing esecuzione SuperSU si esegue il comando su, non effettivamente finisce in un guscio completamente senza restrizione. Oltre a manipolazioni a basso livello limitato dal TrustZone bootloader Andor (storie diverse in tutto), non c'è niente che non si può fare in questo guscio. Android nel suo complesso è un sistema complesso che attraversa una serie di processi, in esecuzione utenti come differenti e differenti contesti. La policy SELinux definisce le regole per le transizioni e la comunicazione tra tutti questi. Solo perché non ci sono restrizioni per il nostro guscio, non significa che non ci sono restrizioni per altri processi che dobbiamo affrontare. politiche di SELinux non sono bidirezionali, quindi, anche se siamo in grado di comunicare con altri processi, questi processi ristrette non possono essere in grado di parlare di nuovo noi. La soluzione è quella di nascondere a noi stessi in modo da tali processi sono autorizzati a parlare con noi: la commutazione contesti. Naturalmente, potremmo liberare quegli altri processi dai loro catene di SELinux, nonché, ma proseguendo lungo quella linea alla fine arriverà negare completamente tutta la sicurezza SELinux vantaggi può portare. La linea deve essere disegnata qualche parte, e per SuperSU la linea è stata disegnata sulla base della necessità. Non è necessario per rilassarsi ulteriormente le politiche di SELinux per questi comandi da eseguire, e quindi noi non rilassarsi ulteriormente le politiche di SELinux, anche se è in un piccolo inconveniente per gli sviluppatori di applicazioni di root. 5.4.4. Come passare da contesti Ci sono diversi modi per passare contesti. A volte l'esecuzione di un certo binario provoca automaticamente un interruttore (come andare da u: r: init: S0 a U: R: initshell: S0 eseguendo sh da init). La maggior parte del tempo, si avrà bisogno di fare una forma più esplicita di cambio di contesto. Il comando runcon (disponibile nel pannello degli strumenti da selezionare build di Android 4.1) esegue un comando come argomento contesto in dotazione, supponendo che si è permesso di fare questa transizione contesto. Il run-as comando (disponibile da Android 2.2.3) sarà simile imitare una specifica (non di sistema) pacchetto e il suo contesto. Purtroppo, entrambi questi comandi non può generalmente essere dipendevano, mentre lavorano solo in circostanze molto specifiche, e in tal modo, le versioni SuperSU 1,90 e fino supportano il parametro - CN o --context per eseguire la vostra su chiamate in un certo contesto. Vedere la Shell. SU. shell () chiamata in libsuperuser. Shell. java GitHub su come costruire un comando interattivo shell con quella sintassi. In questo momento, solo SuperSU supporta questa, anche se (per favore fatemelo sapere se questa situazione cambia, come mi aspetto che a). versioni SuperSU 1,97 e fino sono necessari per Android 4.4 compatibilità di questa funzione. L'u: r: systemserver: S0. u: r: systemapp: S0. u: r: platformapp: S0. eu: R: untrustedapp: S0 contesti sono attualmente supportate da v1.97 in poi, e v2.00 u aggiunge: R: shell: S0 ands u: r: recupero: S0 (se disponibile). Il mio consiglio è di usare la variante untrustedapp per quanto possibile in quanto è quella privilegiata minimo e il più probabile quella di rimanere a disposizione a lungo termine. Se si esegue in problemi, provare la variante systemapp. Si noti che la variante systemserver già non funziona su tutti i dispositivi là fuori, in modo da utilizzare solo quando è assolutamente necessario e testare bene. Si prega di notare che il - cn - opzione di contesto è progettato per funzionare indipendentemente dalla versione della piattaforma e dello Stato. Se SELinux non è presente o è impostato su permissiva. il comando verrà semplicemente eseguito come u: r: init: contesto S0. 5.4.5. Quando per passare commutazione contesti contesto è un processo complicato, e vi consiglio di usare con parsimonia. Non solo ci sono una serie di processi, in ingresso e movimentazione uscita è anche fatte diversamente da altri comandi eseguiti per mezzo di su. Non essere sorpreso quando si utilizza un adb shell per la prova, se il vostro terminale, scompare - il contesto appena commutato potrebbe non supportare l'accesso terminale, come un esempio. Avrete bisogno di trovare da soli ciò che il lavoro esattamente doesnt come u: r: init: contesto S0 e richiede un cambio di contesto, non esiste un elenco di comandi problematici. Tradizionalmente, tutti i comandi che avviano il codice Java-based tuttavia dovrebbe essere eseguito come uno dei contesti app, anche se molti di loro lavorano bene anche senza farlo. Come (strano) ad esempio, consente di pulire la sdcard interal, disinstallare il pacchetto com. example. app, e pulire la cache Dalvik. I seguenti comandi sarebbero tutti convogliati ad un guscio su e quindi eseguiti come root: bit interessante di questo esempio: su viene chiamato di nuovo da dentro una conchiglia su per minimizzare il rischio di incorrere in limitazioni per gli altri comandi, e un cambio di contesto è solo fatto quando necessario. u: r: systemapp: S0 è usato al posto di u: r: untrustedapp: S0 come quest'ultimo non può essere consentito di disinstallare un'applicazione. Il flusso di ingresso del cambio di contesto su conchiglia viene convogliata da devnull. per evitare che comando inghiottendo tutti i dati nel flusso di input (dovuta alla IO attraversando diversi processi), e impedendo così la salvietta di datadalvik-cache accada. Questo è necessario solo in alcuni casi: quando si è i comandi di tubazioni per l'su shell, e si invia il comando successivo prima di attendere il risultato del comando precedente. Nota: questo esempio specifico è in realtà non è più rilevante dal SuperSU versione 2.23 in poi, come il comando pm ora lavora dal u: r: init: contesto S0, ma illustra ancora come esattamente per eseguire comandi come un contesto diverso, in caso di necessità sorgere. 5.4.6. Filesystem e presa contesti Precedente menzioni di cambio di contesto hanno applicato ai processi. oggetti filesystem e prese però hanno anche un contesto di SELinux associato. Nel caso del file system, questi sono facilmente modificate in qualsiasi momento tramite il comando Toolbox chcon. Prese, però, sono un'altra cosa - loro contesto può essere impostato praticamente solo quando si crea il socket. Ad esempio, se si sta scrivendo il proprio servizio daemon, può essere il caso che tu sei la comunicazione tra i due contesti che non possono normalmente accedere eachothers prese. Si potrebbe lanciare il demone da un contesto diverso, ma che potrebbe portare ad altri problemi. Un'altra opzione è quella di modificare il contesto della presa a qualcosa entrambi i processi possono utilizzare. Questo può essere fatto tramite procfs come elencato di seguito. Impostare il contesto appena prima di creare il socket, e impostare nuovamente in seguito. 5.4.7. manipolazione contesto diretto È possibile manipolare diversi contesti SELinux per il processo direttamente tramite procfs. vedi procselfattr. Allo stesso modo, le impostazioni globali SELinux possono essere accessi tramite sysfs. sysfsselinux. Di gran lunga la maggior parte degli sviluppatori di applicazioni root dovrebbe mai bisogno di accedere a uno di questi manualmente. 5.5. Politiche 5.5.1. Lo strumento supolicy Lo strumento supolicy viene fornito con le versioni SuperSU 2.11 e gira su 4.4 e più recenti firmware. Il suo utilizzo principale è quello di modificare la politica di SELinux corrente, anche se non fornisce altre funzionalità come pure (che sono oltre la portata di questo documento). SuperSU esegue lo strumento supolicy quando il demone viene avviato all'avvio del sistema. In seguito, si corre tutti gli eseguibili in su. d. e le chiamate SetProp supolicy. loaded 1. I comandi supolicy patch parametri --live l'attuale politica di SELinux con le patch di base per SuperSU. e le eventuali ulteriori modifiche si aggiungono alla linea di comando. Patching e ricaricare le politiche di SELinux è una chiamata molto costoso, e dovrebbe essere eseguita il meno possibile. Tenere traccia di se è stato eseguito le patch utilizzando un valore booleano statica è consigliato, in quanto che manterrà il suo stato tra lanci di app, fino a quando Android pretende completamente chiaro la vostra applicazione dalla memoria. The --live parameter takes as many policy statements (explained further below) as you can throw at it, as long as you do not exceed the maximum command line length - which is guaranteed to be gt 4096 bytes. Each policy statement needs to be within a single parameter, though, so you need to wrap them in quotes. You may separate multiple policy statements inside the quotes with a semicolon or simply use multiple quoted parameters. Dividing the patches into multiple supolicy calls is possible, but due to the expensive nature of the call, should not be done unless you have a very good reason to. Once the call returns, the policies are active. It should further be noted that having to patch policies is extremely rare. Ninetynine out of a hundred times you can accomplish what you want to do without patching any policies, so please thoroughly investigate if you need to patch policies at all. There has been some debate whether or not policy patching needs a special popup or notice in SuperSU . This is not happening because there is nothing special about patching policies. Any process running as root in the u:r:init:s0 context can do it, so if an app has been granted root, they could use their own code to patch the policies rather than using the supolicy tool, and the end user still wouldnt know about it. As a compromise, the supolicy tool does log all policy patches to the Android logs (logcat). 5.5.2. Default patches Aside from various small policy patches that open various communication paths between the su processes, the major changes to the stock policy supolicy makes is making init . initshell (v2.22), and recovery permissive . The logic behind this is that aside from su and the init and recovery processes themselves, nothing should be running as these contexts, so were not making anything else more exploitable than it already was (contrary to turning the entire system permissive ). If youre wondering why were not using the AOSP-standard su context, that is because it is filtered out on many retail firmwares. Starting v2.79-SR1 on Android 7.0, instead of the modifications listed above, everything related to SuperSU runs in its own supersu context instead. The init context is only modified enough to let the daemon switch to the supersu context as needed. 5.5.3. Use caution Relaxing security measures in theory always opens up a hole somewhere. The severity of such a hole must be carefully considered before making any changes - it is quite easy to open up major holes. As a rule of thumb, if youre adding allow policies with an app class as either source or target class, youre very likely to be doing something you shouldnt, and you should tread carefully. 5.5.4. Audits On most firmwares, if you try to do something that is blocked by SELinux, an audit message appears either in dmesg . logcat . or a log file somewhere on data. You can use these to track down policies you may need to patch, or at least to get hints where your apps problems lie. Note that audit messages are also produced for permissive contexts, even though nothing is really blocked. If something is not working as expected in your root app, audit messages are the first thing you should check. A typical audit message may look like this (example from StickMount ): The sdcard process, with source context u:r:sdcardd:s0 does not have the getattr permission (of class dir ) on an object ( datamedia0usbStoragesda1 ) with the u:objectr:unlabeled:s0 context. The four variables you need to read in this line are: source class: sdcardd (scontext. ) target class: unlabeled (tcontext. ) permission class: dir (tclass. ) permission: getattr ( ) 5.5.5. Allow The above example is from StickMount . a root app that allows you to mount USB sticks to a subdirectory of your internal storage. All internal storage reads and writes from 3rd party apps go through the sdcard daemon process, that runs in the sdcardd context. Most mounts are uneventful, as when you mount storage, you can tell the system which security label (context) to use for the files. However, if a filesystem is not supported by the kernel itself (in this case, exFAT on a Nexus 9), the filesystem needs to be mounted via FUSE, which may not support setting a security label. And thus, the files show up as unlabeled . which the sdcardd context is not allowed to touch. When we try to access the mounted directory with a file explorer, the audit message stated above is generated. What we want to do now is craft an allow policy statement that will fix this issue. We can do so without too much risk, as unlabeled files are not supposed to exist anywhere else on the system, and only sdcard runs as the sdcardd context (its not like were patching untrustedapp . which should generally be avoided). Allow policy statements take these form (if youre familiar with. te source policy files, its very similar): source-class . target-class . and permission (so not permission-class ) can be collections, as denoted by curly brackets: This is expanded to: In our example case, the allow statement becomes: And it can be applied like this: Trying again to access our mounted directory with a file explorer, results in the following audit message: Another missing permission ( read ) of the same class ( dir ), so we update our policy statement to: We can continue this process for some time, and well end up with a list of policies we need to patch. In this case, you might just want to add all permissions of class dir (and as you would later discover, file as well). But how do you find these You can go through the externalsepolicy folder in your AOSP source tree, which lists them all, or you can use the supolicy --dumpav command, which lists all current policies, and steal the permissions from there. In the end, these are the policies being applied by StickMount . 5.5.6. Other policy statements The other policy statements supported by supolicy at this time are: All parameters may be collections, aside from the permission-class parameter. The permission parameter may be to select all (v2.79-SR1). It is highly unlikely you will ever need any statement other than allow for anything other than testing purposes. That being said, should you come up with a valid reason to use any of these, then it is still advised to only use the statements that relax security ( allow . permissive . attradd ) rather than further enforce it ( deny . enforcing . attrdel ). With the latter, you may inadvertently break other root apps running on the device. If you are reading from the externalsepolicy folder of your AOSP tree, it is also worth noting that neverallow rules are a compile-time thing and these do not show up in the policy files. SELinux denies by default, and only allow s what you explicitly state should be allowed. Many of the source statements use collections that are ultimately expanded to a large set of rules. The neverallow statement just makes sure that if a certain allow statement exists, it is removed. The neverallow statement is not stored or applied in the resulting policy file. Theres no need to counter these other than allow ing whatever your app needs. 6. Embedding 6.1. Files All the files you need are in the latest SuperSU flashable ZIP. The latest stable build can always be retrieved from my server. for the latest beta release you need to check the beta thread in the SuperSU forums. The installation script inside the ZIP is META-INFcomgoogleandroidupdate-binary . This is not a binary as the name suggests, but a shell script, and the standard update ZIPs updater-script file is just a dummy. This script has comments which document which files go where on which API level, and what their file permissions, ownerhips, and security labels must be. If you have done this exactly right, SuperSU will not complain when you open the app after booting. 6.2. Custom ROMs It is non-trivial to include SuperSU exactly right on your own. It is therefore often easiest to include the latest SuperSU ZIP inside your own flashable ZIP, and chain its installation. Adding the latest SuperSU zip as supersusupersu. zip in your ROMs ZIP and appending the folowing lines to the end of your updater-script will do just that: An example ZIP can be downloaded here. which installs SuperSU v2.30 from inside the ZIP, tested with TWRP 2.8.2.1 on a Nexus 9 running Android 5.0. Additionally, you should see the section about the supolicy tool. as it describes which properties are set and which scripts are called after SuperSU is done patching policies, and root calls are from the unrestricted init context. 6.3. Exploits Over the past years, many exploits have installed SuperSU as their means of persistent root. Often the exploit leaves the system in an unstable state, and a proper and lengthy installation may not be possible. The APK can fix a partial install as long as basic root works. At the time of this writing, that means at least these files need to be present, and for the right architecture and amount of bits for the firmware (see the ZIP script for permissions and API levels): systemxbinsu systemxbindaemonsu systemxbinsupolicy systemlib(64)libsupol. so Furthermore, daemonsu --auto-daemon needs to be launched somehow on boot. This is generally done via install-recovery. sh . 99SuperSUDaemon . or hijacking appprocess(3264) . Alternatively, you can include the ZIP and run SuperSUs installation script. For this to work, at the time of this writing, the following commands need to be available on the PATH: Additionally, sh needs test support ( square brackets work in if statements). Aside from unzip . all of these should be present on a fully booted 4.3 Android device. If not, you can provide a (SELinux capable) toolbox or busybox and symlink these commands somewhere on the PATH. Last but not least, tmp should be writable. If all of these dependencies are met, you can install the ZIP as follows: Due to the script trying things in various ways to support different systems and recovery versions, it will throw errors at you regardless of if the installation is succesfull or not. Just ignore those, reboot, and see if the SuperSU GUI complains when you open it. X. Updates X.1. Gobbling On December 17 2012, libsuperuser GitHub has been updated with Gobblers to consume STDOUT and STDERR. These are nothing more than background threads that consume STDOUT and STDERR output as fast as possible. The exact how and why is a long story (if interested, read When Runtime. exec() wont JavaWorld ), but this avoids potential deadlocks when excess output occurs on STDOUT or STDERR. If you are using my library please make sure you are running the latest version. If youre not running my library it may be wise to read the linked article and see if there is a problem with your code. X.2. Full content logging SuperSU has a feature to log all su command content. While this works fine for most apps, some apps can run into unexpected problems when this feature is used. One example is terminal emulators - these will not show the command prompt if a su shell is started. SuperSU v0.97 (released November 29 2012) and newer support a way to let SuperSU know your app does not function well with full content logging enabled. If you use this method, SuperSU will not enable full content logging for your app if SuperSU has only been configured to log by default . If the user goes into app-specific configuration, the user can still enable full content logging for your app manually . The user will in that case be presented with a warning. To let SuperSU know your app is not fully compatible with full content logging, add the following to an Activity . Service . or BroadcastReceiver . Adding it to a single Activity . Service . or BroadcastReceiver . is enough to get the entire package excluded from full content logging. There is no need to add it multiple times. Please note that I will not tolerate abuse of this feature. Full content logging is there for the end-user, and it should not be disabled this way without good reason. I may resort to blacklisting your package from root access altogether if you purposely abuse this. As far as I know, since SuperSU v1.39 (released July 3 2013), there are no longer any issues with full content logging and certain apps. As such, this section may be obsolete. X.3. Parameters for su SuperSU originally took its parameter parsing from ChainsDDs Superusers su binary. On January 11 2012 modifications regarding parameter parsing were pushed to ChainsDDs GitHub fc7479fab2 GitHub. SuperSU has virtually identical updated parameter parsing from v1.00 . While this does allow for some interesting constructs in calling su . you must be aware that not all constructs possible with the original parameter parsing will be interpreted in the same way with the new parameter parsing. I would also like to point out specifically that (1) the command to execute, following the - c or --command parameter, should be a single parameter . (2) that parameter is not even supported by all su variants available in the wild, and (3) the most reliable way to execute commands as root still remains starting su as a shell and piping commands and output. Some su variants on some devices do not support anything else than being started as an interactive shell. Exact parameter parsing of the more functional su binaries differs by author and by version, sometimes very subtly. The older the version of Android your app can run on, the higher the chance of running into an exotic or incompatible su binary. Youd be surprised what your app can run into in the wild. As such, in my personal opinion, it is always wisest and most compatible to simply run su as an interactive shell and pipe commands and output. If you must deviate from this, you should at least thoroughly test your app with (1) the most recent Superuser, (2) a Superuser (and binary) from 2011, (3) SuperSU v0.99 or older, and (4) SuperSU v1.00 or newer. X.4. ACCESSSUPERUSER permission DEPRECATED Due to changes in Android 5.0 Lollipop, this permission has been deprecated and is completely ignored from SuperSU v2.30 onwards From SuperSU version 1.20 and onwards, the android. permission. ACCESSSUPERUSER permission is declared by SuperSU. All root apps should from now on declare this permission in their AndroidManifest. xml . If this permission is not present, SuperSU will present a warning in its superuser request popup (this is configurable in SuperSU settings). At the time of this writing this permission is not enforced, but it is expected that sometime in the future it will be, and apps requesting root that do not have this permission set will be silently denied. If this permission is declared, the user will be able to see in the app permissions list that the app requests superuser access. X.5. Tapjacking protection and overlays SuperSU v2.04 has introduced tapjacking protection to the superuser access prompt. This protection is used in many security-related dialogs in Android. What it comes down to is that the popup will not react to input of it is obscured by any other activity, view, overlay, etc. This prevents a malicious app from displaying a touch-transparent image on top of the popup that would for example switch around the accept and deny buttons. There are however some legitimate uses for overlays, a common use for them is to adjust display colors. An app displaying such overlays should hide the overlay when the SuperSU popup becomes visible, and show it again. To facilitate this, SuperSU will send a broadcast to apps that have previously been granted root access . So an app like this should indeed disable its overlays and request root access when it is first launchedconfigured, even if it does not require root The following BroadcastReceiver can be used to receive information on when to hide overlays. See libsuperuser. HideOverlaysReceiver. java GitHub for a base class explaining the details. Starting v2.22, after supolicy is called to patch SELinux policies, all executables in the systemsu. d and susu. d are executed. Both the directories and the containing scripts and binaries should be chmod 0700 . Some firmwares have a similar feature in system(etc)init. d . though execution of those scripts is both kernel-dependent and they may run before the SELinux policies are patched andor su is available. Starting v2.76, these scripts are executed before zygote is started, and are thus in time for most bind-mount purposes, unless the scripts run too long. These are the guarantees made for su. d . All SELinux patching is complete before su. d scripts are executed All scripts inside su. d are executed in alphabetical order (0-9a-z) Scripts are run serially. The next one in order is not started until the previous one has finished. Boot does not proceed until all scripts have been executed unless your boot image does not support exec (very rare) unless scripts run longer than the timeout (4 seconds originially, 60 seconds since v2.78-SR1) As the scripts are run serially, if your script does not need to delay the boot process, the script itself should make sure its actions are run asynchronously. For example: This example is for systemless root, which should use subinsush as shell interpreter. The () parenthesis cause a sub-process to be created that runs the commands inside them. The amp ampersand following the closing parenthesis causes this sub-process to run asynchronously. This allows all the other scripts in su. d to continue running and for boot to continue. echo done will be called after 5 minutes, at which time Android has probably long been up and running.