Root Detection în aplicațiile mobile — esența, metodele de detectare și principiul de funcționare

Ce este Root Detection?

Root Detection — mecanism software care determină prezența accesului root pe un dispozitiv Android. Accesul root oferă control complet asupra sistemului de operare, permițând aplicațiilor și scripturilor să execute comenzi cu UID 0. Pe un dispozitiv rootat, izolarea aplicațiilor (Android Sandbox) se pierde, făcând posibilă interceptarea intrărilor de la tastatură, citirea bazelor de date SQLite ale altor aplicații, injectarea de cod în procese și substituirea certificatelor SSL în depozitul de încredere.

Pentru aplicațiile financiare și corporative, rularea pe un dispozitiv rootat reprezintă un risc inacceptabil: atacatorul obține acces la tokenuri, chei de sesiune și date personale. Autoritățile de reglementare, inclusiv PCI Security Standards Council, solicită aplicațiilor de plată detectarea și reacția la accesul root. Ca răspuns, dezvoltatorii Android integrează Root Detection ca parte a strategiei de protecție proactivă.

Există două abordări de detectare: statică, care analizează sistemul de fișiere și pachetele instalate, și dinamică, care efectuează verificări în runtime. Abordarea combinată este considerată cea mai fiabilă, deoarece acoperă diferiți vectori de ocolire. Conform cercetării NowSecure (2025), 76% dintre aplicațiile bancare din top 100 Google Play conțin o formă sau alta de Root Detection.

Metode statice de detectare root

Metodele statice se execută la pornirea aplicației și verifică semnele accesului root lăsate de instrumentele de rootare în sistemul de fișiere. Aceste metode nu necesită executarea de comenzi privilegiate și funcționează în contextul unei aplicații obișnuite.

Verificarea existenței binarului su

Principalul semn al accesului root — prezența fișierului executabil su în căile standard: /system/bin/su, /system/xbin/su, /sbin/su, /su/bin/su. Aplicația verifică existența fișierului prin File.exists() sau implementarea nativă access() din libc. Suplimentar, se poate încerca executarea su --version sau su -c id și verificarea codului de ieșire.

Căutarea managerilor de root

Aplicații tipice pentru gestionarea accesului root: Superuser, SuperSU, Magisk Manager, KingRoot. Prezența lor se verifică prin PackageManager.getPackageInfo() sau citirea directorului /data/app/. Pachete de verificat: com.topjohnwu.magisk, eu.chainfire.supersu, com.noshufou.android.su, com.thirdparty.superuser, com.koushikdutta.superuser, com.zacharee1.systemuituner.

Verificarea proprietăților de sistem

Android stochează informații despre starea sistemului în proprietăți de sistem accesibile prin System.getProperty și Build.TAGS. Dacă valoarea Build.TAGS conține test-keys în loc de release-keys — aceasta indică un firmware personalizat, adesea cu acces root. Suplimentar, se verifică ro.build.tags, ro.debuggable și ro.secure prin citirea /system/build.prop.

public class RootDetectionChecker {
    private static final String[] SU_PATHS = {
        "/system/bin/su",
        "/system/xbin/su",
        "/sbin/su",
        "/su/bin/su",
        "/system/sd/xbin/su"
    };

    public boolean checkRootByFiles() {
        for (String path : SU_PATHS) {
            if (new File(path).exists()) {
                return true;
            }
        }
        return false;
    }

    public boolean checkRootByPackages(Context ctx) {
        String[] packages = {
            "com.topjohnwu.magisk",
            "eu.chainfire.supersu",
            "com.noshufou.android.su",
            "com.koushikdutta.superuser"
        };
        for (String pkg : packages) {
            try {
                ctx.getPackageManager().getPackageInfo(pkg, 0);
                return true;
            } catch (PackageManager.NameNotFoundException e) {
                // pachetul nu a fost găsit
            }
        }
        return false;
    }
}

Metode dinamice de verificare

Metodele dinamice se execută în timpul funcționării aplicației și analizează mediul de execuție. Spre deosebire de cele statice, pot detecta rootarea ascunsă prin Magisk Hide sau Zygisk, deoarece verifică comportamentul sistemului, nu doar structura fișierelor.

Verificarea punctelor de montare

La acces root, unele partiții de sistem sunt montate cu flagul rw (read-write) în loc de ro (read-only). Aplicația citește /proc/mounts și verifică dacă /system este montat ca ro. Dacă /system este montat ca rw — acesta este un semn de sistem modificat. Suplimentar, se verifică prezența montării /su prin Magisk.

Testul modului sigur

Android Safe Mode dezactivează aplicațiile terțe, inclusiv managerii de root. O implementare corectă a Root Detection poate verifica dacă dispozitivul funcționează în modul sigur. Dacă aplicația detectează că managerii de root nu sunt vizibili, dar binarul su există — acesta este un semn de Magisk Hide.

Verificarea executării comenzilor

Încercarea de a executa su -c id prin ProcessBuilder sau Runtime.exec — un test direct al accesului root. Cu toate acestea, Magisk poate intercepta această apelare. O opțiune mai fiabilă — verificarea prin cod nativ: deschiderea /proc/1/limits sau /proc/self/maps și analiza UID-ului proceselor în execuție. Dacă aplicația poate obține UID 0 sau poate citi fișiere accesibile doar root — dispozitivul este compromis.

public boolean checkRootDynamically() {
    // Verificarea flagurilor de compilare
    String buildTags = Build.TAGS;
    if (buildTags != null && buildTags.contains("test-keys")) {
        return true;
    }

    // Verificarea montării /system
    try {
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(new FileInputStream("/proc/mounts"))
        );
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.contains("/system")
                && line.contains("rw")) {
                reader.close();
                return true;
            }
        }
        reader.close();
    } catch (IOException e) {
        // eroare la citirea montării
    }

    return false;
}

Implementarea nativă a Root Detection în C++

Root Detection implementat în Java este ușor de ocolit prin module Xposed sau Frida, care interceptează metodele Java și substituie valorile returnate. Implementarea nativă în C++ prin JNI este semnificativ mai rezistentă: instrumentele de analiză dinamică care funcționează la nivel Java nu văd apelurile native libc, cum ar fi stat, access, popen și dlopen.

#include <unistd.h>
#include <sys/stat.h>
#include <cstring>
#include <vector>

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_example_checker_RootCheck_nativeCheck(
    JNIEnv* env, jobject instance) {

    std::vector<const char*> paths = {
        "/system/bin/su",
        "/system/xbin/su",
        "/sbin/su",
        "/data/local/su"
    };

    struct stat st;
    for (const char* path : paths) {
        if (stat(path, &st) == 0) {
            return JNI_TRUE;
        }
    }
    return JNI_FALSE;
}

Verificarea nativă nu folosește Java API, ceea ce o face invizibilă pentru instrumentele de ocolire care funcționează la nivel Dalvik/ART. Pentru protecție suplimentară, se recomandă stocarea constantelor (lista de căi) nu în secțiunea read-only, ci calcularea lor prin funcții simple reversibile. Apelul stat din libc se adresează direct nucleului Linux, ocolind wrapper-ele Java, și nu poate fi interceptat prin Xposed.

Metode de ocolire a Root Detection

Dezvoltatorii de securitate trebuie să înțeleagă metodele existente de ocolire pentru a construi un sistem de detectare rezistent. Fiecare metodă de ocolire necesită o contra-măsură la nivelul corespunzător.

Ocolirea prin Magisk Hide și Zygisk

Magisk — cel mai popular instrument de rootare pe Android 9–14. Magisk Hide ascunde prezența su din /proc și substituie rezultatele verificării căilor. Magisk funcționează la nivel de nucleu și interceptează stat() și access() înainte ca aplicația să le vadă. Contra-măsură: verificarea prezenței Magisk însuși prin existența /sbin/.magisk sau verificarea prin citirea propriilor maps — Magisk își încorporează biblioteca în fiecare proces.

Ocolirea prin Frida

Frida — instrument de instrumentație dinamică care poate intercepta funcții native prin Ptrace sau Dobby. Frida înlocuiește valoarea returnată a oricărei verificări, substituind rezultatul stat cu ENOENT. Contra-măsură: verificarea integrității funcțiilor native prin calcularea sumei de control a instrucțiunilor în memorie și detectarea Frida prin analiza /proc/self/maps pentru prezența frida-agent.so sau frida-helper.

Ocolirea prin patch APK

Root Detection implementat în Java este eliminat în 2–3 minute: APK este despachetat prin apktool, în codul smali se modifică valoarea returnată a metodei la false, APK este reasamblat și semnat. Contra-măsură: mutarea logicii critice în cod nativ și verificarea semnăturii digitale a aplicației în runtime prin Signature API sau compararea hash-ului APK cu etalonul pe server.

Recomandări pentru o protecție fiabilă

Root Detection eficient se bazează pe o arhitectură multistrat. Nicio metodă individuală nu asigură un nivel suficient de protecție. Combinația de verificări statice și dinamice, cod nativ și verificare pe server oferă o rezistență maximă.

Verificare pe server

Nu vă bazați doar pe verificarea client-side. Trimiteți pe server rezultatele Root Detection împreună cu un token de sesiune unic. Serverul ia decizia de blocare sau limitare a funcționalității. Acest lucru previne atacurile la nivel API, unde aplicația client poate fi modificată, iar serverul rămâne partea de încredere.

Ofuscarea codului de verificare

Codul Root Detection trebuie ofuscat. Dacă atacatorul vede în jadx o succesiune clară de verificări a căilor su — ocolirea va dura minute. Utilizați ProGuard sau DexGuard pentru a complica fluxul de control și a cripta șirurile de caractere. Ofuscarea crește timpul de analiză a codului de securitate de la câteva minute la câteva ore.

Actualizarea regulată a semnăturilor

Lista căilor, pachetelor și indicatorilor verificați trebuie actualizată cu fiecare versiune a aplicației. Noi instrumente de rootare și ocolire apar lunar. O listă statică neschimbată timp de un an nu detectează metodele moderne. Se recomandă încărcarea semnăturilor actuale de pe server la pornirea aplicației înainte de efectuarea verificărilor.