Jailbreak Detection în aplicațiile iOS: esența, metodele de detectare și verificare

Ce este Jailbreak Detection?

Jailbreak Detection — procesul de identificare a dispozitivelor iOS pe care au fost eliminate restricțiile sistemului de operare. Jailbreak-ul modifică nucleul iOS, dezactivează semnarea codului, oferă acces la întregul sistem de fișiere și permite încărcarea de biblioteci neautorizate. Pentru o aplicație care rulează pe un astfel de dispozitiv, nu există garanții de integritate a mediului de execuție: orice proces poate citi memoria aplicației, poate intercepta traficul SSL/TLS prin instalarea propriilor certificate în depozitul sistemului și poate injecta cod prin Cydia Substrate sau Substitute.

Aplicațiile financiare pe iOS sunt obligate să implementeze Jailbreak Detection conform cerințelor standardului PCI DSS — pentru certificare, aplicația trebuie să demonstreze că nu rulează pe un dispozitiv compromis. OWASP Mobile Security (2024) clasifică lipsa Jailbreak Detection ca vulnerabilitate M8. Pentru aplicațiile din App Store, Apple nu interzice blocarea funcționalității pe dispozitivele cu jailbreak, însă recomandă combinarea verificărilor client-side și server-side pentru a nu se baza exclusiv pe codul clientului, care poate fi modificat.

Arhitectura Jailbreak Detection în iOS este mai complexă decât Root Detection în Android din cauza modelului sandbox. Pe Android, aplicația poate citi /proc pentru analiza sistemului. Sandbox-ul iOS blochează accesul direct la majoritatea indicatorilor de sistem. Dezvoltatorii sunt nevoiți să utilizeze tehnici de ocolire, cum ar fi verificarea disponibilității fișierelor în zone interzise prin API-ul canAccessFile sau lansarea proceselor copil prin fork() cu verificarea codului de ieșire. Verificările moderne se bazează pe încercarea de a executa acțiuni disponibile doar la jailbreak și analizarea rezultatului.

Metode de detectare a jailbreak-ului bazate pe fișiere

Cea mai simplă și istoric prima abordare — verificarea prezenței fișierelor și aplicațiilor care sunt instalate doar pe dispozitivele cu jailbreak. În ciuda simplității, verificările de fișiere rămân un strat de bază al protecției, deoarece ocolirea lor necesită acțiuni active din partea utilizatorului.

Verificarea pachetelor de jailbreak

Pe un dispozitiv cu jailbreak sunt prezente aplicațiile Cydia, Sileo, Zebra sau Installer. Prezența lor este verificată prin NSFileManager: [[NSFileManager defaultManager] fileExistsAtPath:@"/Applications/Cydia.app"]. Similar sunt verificate pachetele de la unc0ver, checkra1n, Taurine și Chimera. Aceste verificări sunt ocolite prin tweak-uri HideJB care interceptează apelurile NSFileManager.

Verificarea utilitarelor în /usr/bin

Jailbreak-ul instalează utilitare UNIX indisponibile în stock iOS: apt, dpkg, ssh, rsync, sftp, dd, readlink și altele. Se verifică existența /usr/bin/ssh, /bin/bash, /bin/sh și /usr/libexec/sftp-server. La detectarea cu succes a oricăruia dintre aceste fișiere, probabilitatea jailbreak-ului este ridicată. Pentru iOS 13–17 este relevantă și verificarea prezenței /var/jb — directorul rădăcină bootstrap pentru unc0ver și Taurine.

Verificarea bibliotecilor dinamice

MobileSubstrate (CydiaSubstrate.dylib) și Substitute — biblioteci pentru injectarea codului în procese. Prezența lor este verificată prin dlopen() cu flag-ul RTLD_NOLOAD. Dacă biblioteca este încărcată în spațiul de adrese — procesul rulează într-un mediu cu jailbreak. Aceasta este o verificare mai fiabilă, deoarece HideJB nu poate descărca o bibliotecă deja încărcată în proces.

- (BOOL)isJailbrokenByFiles {
    NSArray *paths = @[
        @"/Applications/Cydia.app",
        @"/Applications/Sileo.app",
        @"/Applications/Zebra.app",
        @"/usr/bin/ssh",
        @"/bin/bash",
        @"/var/jb",
        @"/etc/apt"
    ];

    for (NSString *path in paths) {
        if ([[NSFileManager defaultManager]
            fileExistsAtPath:path]) {
            return YES;
        }
    }
    return NO;
}

- (BOOL)isSubstrateLoaded {
    void *handle = dlopen(
        "/Library/MobileSubstrate/MobileSubstrate.dylib",
        RTLD_NOLOAD | RTLD_LAZY
    );
    if (handle) {
        dlclose(handle);
        return YES;
    }
    return NO;
}

Verificări dinamice în timp de execuție

Verificările dinamice execută acțiuni care sunt interzise în sandbox-ul iOS și analizează rezultatul. Dacă acțiunea nu este blocată — dispozitivul are cel mai probabil jailbreak.

Verificarea fork() și posix_spawn()

În stock iOS, apelul fork() returnează -1 cu errno = EPERM. Pe un dispozitiv cu jailbreak, fork() se poate executa, deoarece restricțiile sandbox-ului au fost eliminate. Această verificare este fiabilă, dar poate duce la alarme false pe unele versiuni de iOS. fork() poate fi înlocuit și cu posix_spawn() pentru verificarea posibilității de lansare a unui proces copil.

Verificarea semnăturii de sistem a sandbox-ului

Încercarea de citire a fișierelor în zone interzise: /etc/master.passwd, /var/log/system.log, /private/var/cache. În stock iOS, aceste citiri returnează eroare. Dacă aplicația citește cu succes aceste fișiere — sandbox-ul este dezactivat. Suplimentar, se verifică posibilitatea de scriere în /private/ — în sandbox, toate partițiile de sistem sunt montate ca read-only pentru aplicațiile obișnuite.

Verificarea simbolurilor de sistem

Jailbreak-ul modifică bibliotecile de sistem, inclusiv dyld shared cache. Verificarea hash-ului framework-urilor de sistem sau a simbolurilor individuale poate releva modificarea. Pentru iOS 14+ se verifică prezența simbolului jit_region_create sau a altor semne de funcționare Fugu14/checkra1n în spațiul de adrese al nucleului prin citirea sysctl kern.version.

- (BOOL)isJailbrokenByRuntime {
    // Verificarea fork()
    int pid = fork();
    if (pid == 0) {
        exit(0);
    }
    if (pid > 0) {
        waitpid(pid, NULL, 0);
        return YES;
    }

    // Verificarea accesului la fișierele de sistem
    FILE *f = fopen("/etc/master.passwd", "r");
    if (f) {
        fclose(f);
        return YES;
    }

    // Verificarea sysctl kern.version
    size_t size = 0;
    sysctlbyname("kern.version", NULL, &size, NULL, 0);
    if (size > 0) {
        char *version = malloc(size);
        sysctlbyname("kern.version", version, &size, NULL, 0);
        NSString *str = [NSString stringWithUTF8String:version];
        free(version);
        if ([str containsString:"pwned"]) {
            return YES;
        }
    }

    return NO;
}

Implementare nativă în Objective-C

Codul Swift este ușor de dezasamblat și ocolit prin Substrate. Implementarea nativă în Objective-C cu apeluri directe libobjc și funcții de sistem C face verificările semnificativ mai rezistente la ocolire.

Utilizarea stat() în loc de NSFileManager

Apelul stat() din libc nu poate fi interceptat la nivel de Objective-C. Tweak-urile HideJB care interceptează metodele NSFileManager nu afectează stat(). Verificarea nativă cu stat() detectează indicatorii de fișiere chiar și pe dispozitive cu module HideJB instalate. Combinarea stat() pentru fișiere și dlopen() cu RTLD_NOLOAD pentru biblioteci oferă două canale de detectare care nu se suprapun.

Verificarea integrității semnăturii codului

Funcția nativă SecStaticCodeCheckValidity verifică semnătura codului aplicației pentru conformitatea cu certificatul Apple. Pe un dispozitiv cu jailbreak, această verificare poate fi substituită prin kernel-patch. Pentru a evita substituirea, verificarea trebuie efectuată din codul nativ cu apel prin dlopen() din Security.framework, nu prin Swift Bridge.

#import <sys/stat.h>
#import <dlfcn.h>

- (BOOL)nativeCheckForJailbreak {
    // stat() ocolire hook NSFileManager
    struct stat st;
    if (stat("/Applications/Cydia.app", &st) == 0) {
        return YES;
    }

    // dlopen pentru verificarea Substrate fără încărcare
    void *substrate = dlopen(
        "/Library/MobileSubstrate/MobileSubstrate.dylib",
        RTLD_NOLOAD
    );
    if (substrate) {
        dlclose(substrate);
        return YES;
    }

    return NO;
}

Metode de ocolire a Jailbreak Detection

Înțelegerea tehnicilor de ocolire este necesară pentru construirea unei protecții durabile. Instrumentele moderne de ocolire se dezvoltă activ, iar un set static de verificări devine ineficient în câteva luni.

HideJB și Shadow

HideJB — un tweak care interceptează apelurile NSFileManager, stat(), dlopen() și fork() și substituie valorile returnate. HideJB funcționează la nivelul Cydia Substrate, interceptând atât funcțiile Objective-C, cât și pe cele C. Versiunea HideJB pentru iOS 15–16 (Shadow) utilizează metodologia de hook-uri la nivel de kernel. Contramăsura: efectuarea verificării într-un proces separat cu transmiterea rezultatului prin IPC, ceea ce rupe lanțul de hook-uri.

Choicy și Liberty Lite

Choicy permite dezactivarea Substrate pentru procese specifice. Utilizatorul pur și simplu dezactivează injecția pentru aplicația protejată — toate verificările de biblioteci returnează false. Liberty Lite — ocolire complexă care acoperă majoritatea verificărilor din bibliotecile populare de protecție. Contramăsura: verificarea pe server prin DeviceCheck și App Attest — pe server se verifică că dispozitivul are un certificat Apple valid care nu poate fi falsificat pe un dispozitiv cu jailbreak.

Ocolirea prin Fugu14 și KFD

Exploit-urile de nucleu, cum ar fi Fugu14 și KFD, execută cod în spațiul nucleului (kernel-space), ceea ce permite interceptarea apelurilor de sistem înainte ca aplicația să le vadă. La acest nivel, verificările stat() și fork() devin ineficiente. Singura contramăsură fiabilă — atestarea pe server cu verificarea că dispozitivul a trecut de procedura Apple Attestation. Acest protocol se bazează pe chei criptografice în interiorul Secure Enclave, care sunt inaccesibile la citire chiar și în cazul unui exploit la nivel de nucleu.

Arhitectura de securitate iOS și rolul jailbreak-ului

Pentru construirea unui Jailbreak Detection eficient, este necesar să se înțeleagă care mecanisme de securitate iOS sunt dezactivate la jailbreak.

Secure Boot Chain

iOS se încarcă printr-o secvență de verificări de semnături: Boot ROM → iBoot → iOS Kernel. Dacă jailbreak-ul utilizează un exploit bootrom (checkra1n), întregul Secure Boot Chain este compromis — verificările la nivel de aplicație sunt inutile. Dacă se utilizează un exploit software-only (unc0ver, Taurine, Fugu14), lanțul de încărcare nu este încălcat, iar serviciile Apple, cum ar fi App Attest, rămân de încredere.

Kernel Patch Protection (KPP)

Începând cu iOS 10, Apple a implementat KPP — o protecție hardware care reverifică integritatea nucleului la fiecare 200 ms. Toate jailbreak-urile moderne (iOS 14–17) utilizează ocolirea KTRR prin PAC sau APRR, dar KPP lasă urme sub formă de tabele de sistem sysctl modificate. Verificarea kern.version pentru prezența șirurilor pwned, prod sau xnu cu o versiune non-standard poate releva prezența unui patch de nucleu.

Integritatea Sandbox-ului

Sandbox-ul iOS funcționează la nivelul TrustedBSD, utilizând entitlements. Jailbreak-ul înlocuiește profilul sandbox-ului cu allow-all. Aplicația poate verifica sandbox-ul prin încercarea de a citi orice fișier în afara directorului său Documents. Dacă reușește — sandbox-ul a fost modificat. Integritatea Sandbox-ului — unul dintre puținii indicatori care nu poate fi falsificat fără un exploit la nivel de nucleu, deoarece verificarea permisiunilor se execută în nucleu înainte de a putea fi interceptată.