Jailbreak Detection iOS-alkalmazásokban: lényeg, észlelési módszerek és ellenőrzés

Mi az a Jailbreak Detection?

Jailbreak Detection — azon iOS-eszközök azonosításának folyamata, amelyekről eltávolították az operációs rendszer korlátozásait. A jailbreak módosítja az iOS kernelt, kikapcsolja a kódaláírást, hozzáférést biztosít a teljes fájlrendszerhez, és lehetővé teszi nem engedélyezett könyvtárak betöltését. Az ilyen eszközön futó alkalmazás számára nincs garancia a végrehajtási környezet integritására: bármely folyamat olvashatja az alkalmazás memóriáját, elfoghatja az SSL/TLS-forgalmat saját tanúsítványok rendszertárba telepítésével, és kódot injektálhat a Cydia Substrate vagy Substitute segítségével.

A pénzügyi iOS-alkalmazások kötelesek bevezetni a Jailbreak Detection-t a PCI DSS szabvány előírásai szerint — a tanúsításhoz az alkalmazásnak bizonyítania kell, hogy nem feltört eszközön fut. Az OWASP Mobile Security (2024) a Jailbreak Detection hiányát M8-as sebezhetőségként osztályozza. Az App Store alkalmazásai esetében az Apple nem tiltja a funkcionalitás blokkolását jailbreakelt eszközökön, azonban javasolja az ügyféloldali és szerveroldali ellenőrzések kombinálását, hogy ne csak a módosítható klienskódra hagyatkozzon.

A Jailbreak Detection architektúrája iOS-ben bonyolultabb, mint a Root Detection Androidban a homokozó modell miatt. Androidon az alkalmazás olvashatja a /proc fájlt a rendszer elemzéséhez. Az iOS homokozó (sandbox) blokkolja a közvetlen hozzáférést a legtöbb rendszerindikátorhoz. A fejlesztők kénytelenek megkerülő technikákat alkalmazni, mint például a fájlok elérhetőségének ellenőrzése tiltott zónákban a canAccessFile API-n keresztül, vagy gyermekfolyamatok indítása fork() segítségével a kilépési kód ellenőrzésével. A modern ellenőrzések olyan műveletek végrehajtásának kísérletén alapulnak, amelyek csak jailbreak esetén érhetők el, és az eredmény elemzésén.

Fájlalapú jailbreak-észlelési módszerek

A legegyszerűbb és történelmileg első megközelítés — azon fájlok és alkalmazások jelenlétének ellenőrzése, amelyek csak jailbreakelt eszközökre települnek. Az egyszerűség ellenére a fájlellenőrzések alapvető védelmi réteget képeznek, mivel megkerülésük aktív felhasználói beavatkozást igényel.

Jailbreak-csomagok ellenőrzése

A jailbreakelt eszközön jelen vannak a Cydia, Sileo, Zebra vagy Installer alkalmazások. Ezek meglétét az NSFileManager segítségével ellenőrzik: [[NSFileManager defaultManager] fileExistsAtPath:@"/Applications/Cydia.app"]. Hasonlóan ellenőrzik az unc0ver, checkra1n, Taurine és Chimera csomagjait. Ezek az ellenőrzések a HideJB csomagokkal megkerülhetők, amelyek elfogják az NSFileManager hívásait.

Segédprogramok ellenőrzése a /usr/bin-ben

A jailbreak olyan UNIX segédprogramokat telepít, amelyek a stock iOS-ben nem érhetők el: apt, dpkg, ssh, rsync, sftp, dd, readlink és mások. Ellenőrzik a /usr/bin/ssh, /bin/bash, /bin/sh és /usr/libexec/sftp-server létezését. Bármelyik fájl sikeres észlelése esetén a jailbreak valószínűsége magas. iOS 13–17 esetén ajánlott a /var/jb — az unc0ver és Taurine bootstrap gyökérkönyvtárának meglétét is ellenőrizni.

Dinamikus könyvtárak ellenőrzése

A MobileSubstrate (CydiaSubstrate.dylib) és Substitute — könyvtárak kód injektálásához folyamatokba. Meglétüket a dlopen() segítségével ellenőrzik RTLD_NOLOAD flaggel. Ha a könyvtár betöltődött a címtérbe — a folyamat jailbreak környezetben fut. Ez megbízhatóbb ellenőrzés, mivel a HideJB nem tudja kirakni a már betöltött könyvtárat a folyamatból.

- (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;
}

Dinamikus futásidejű ellenőrzések

A dinamikus ellenőrzések olyan műveleteket hajtanak végre, amelyek az iOS homokozóban tiltottak, és elemzik az eredményt. Ha a művelet nincs blokkolva — az eszköz nagy valószínűséggel jailbreakelt.

A fork() és posix_spawn() ellenőrzése

A stock iOS-ben a fork() hívás -1-et ad vissza errno = EPERM-mel. Jailbreakelt eszközön a fork() végrehajtódhat, mivel a homokozó korlátozásai megszűntek. Ez az ellenőrzés megbízható, de téves pozitív eredményeket adhat egyes iOS-verziókon. A fork() helyettesíthető posix_spawn()-nal is a gyermekfolyamat indításának lehetőségének ellenőrzésére.

A homokozó rendszer aláírásának ellenőrzése

Fájlok olvasásának kísérlete tiltott zónákban: /etc/master.passwd, /var/log/system.log, /private/var/cache. Stock iOS-ben ezek az olvasások hibát adnak vissza. Ha az alkalmazás sikeresen beolvassa ezeket a fájlokat — a homokozó ki van kapcsolva. Ezenkívül ellenőrzik a /private/-ba írás lehetőségét — a homokozóban az összes rendszerpartíció csak olvashatóként van csatolva a szokásos alkalmazások számára.

Rendszerszimbólumok ellenőrzése

A jailbreak módosítja a rendszerkönyvtárakat, beleértve a dyld shared cache-t. A rendszerkeretrendszerek hash-ének vagy egyes szimbólumoknak az ellenőrzése felfedheti a módosítást. iOS 14+ esetén a jit_region_create szimbólum vagy más Fugu14/checkra1n jelek jelenlétét ellenőrzik a kernel címtartományában a sysctl kern.version olvasásával.

- (BOOL)isJailbrokenByRuntime {
    // A fork() ellenőrzése
    int pid = fork();
    if (pid == 0) {
        exit(0);
    }
    if (pid > 0) {
        waitpid(pid, NULL, 0);
        return YES;
    }

    // Rendszerfájlokhoz való hozzáférés ellenőrzése
    FILE *f = fopen("/etc/master.passwd", "r");
    if (f) {
        fclose(f);
        return YES;
    }

    // A sysctl kern.version ellenőrzése
    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;
}

Natív implementáció Objective-C-ben

A Swift kód könnyen diszassemblálható és megkerülhető a Substrate segítségével. A natív Objective-C implementáció a libobjc és C rendszerfüggvények közvetlen hívásával jelentősen ellenállóbbá teszi az ellenőrzéseket a megkerüléssel szemben.

A stat() használata NSFileManager helyett

A libc-ből származó stat() hívás nem fogható el Objective-C szinten. Az NSFileManager metódusait elfogó HideJB csomagok nem befolyásolják a stat()-ot. A stat() natív ellenőrzése észleli a fájlin dikátorokat még HideJB modulokkal rendelkező eszközökön is. A stat() kombinációja fájlokhoz és a dlopen() RTLD_NOLOAD-dal könyvtárakhoz két nem átfedő észlelési csatornát biztosít.

A kód aláírás integritásának ellenőrzése

A SecStaticCodeCheckValidity natív függvény ellenőrzi az alkalmazás kód aláírásának megfelelőségét az Apple tanúsítványhoz. Jailbreakelt eszközön ez az ellenőrzés kernel-patch segítségével helyettesíthető. A helyettesítés elkerülése érdekében az ellenőrzést natív kódból kell végrehajtani a Security.framework-ből dlopen()-en keresztüli hívással, nem pedig Swift Bridge-en keresztül.

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

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

    // dlopen a Substrate ellenőrzéséhez betöltés nélkül
    void *substrate = dlopen(
        "/Library/MobileSubstrate/MobileSubstrate.dylib",
        RTLD_NOLOAD
    );
    if (substrate) {
        dlclose(substrate);
        return YES;
    }

    return NO;
}

A Jailbreak Detection megkerülésének módszerei

A megkerülési technikák megértése szükséges a tartós védelem kiépítéséhez. A modern megkerülő eszközök aktívan fejlődnek, és a statikus ellenőrzési készlet néhány hónapon belül hatástalanná válik.

HideJB és Shadow

HideJB — egy csomag, amely elfogja az NSFileManager, stat(), dlopen() és fork() hívásokat, és helyettesíti a visszatérési értékeket. A HideJB a Cydia Substrate szintjén működik, ezért mind az Objective-C, mind a C függvényeket elfogja. Az iOS 15–16-ra szánt HideJB verzió (Shadow) kernel szintű hook-ok módszertanát használja. Ellenintézkedés: az ellenőrzés végrehajtása külön folyamatban az eredmény IPC-n keresztüli átadásával, ami megszakítja a hook-láncot.

Choicy és Liberty Lite

A Choicy lehetővé teszi a Substrate kikapcsolását bizonyos folyamatokhoz. A felhasználó egyszerűen kikapcsolja az injektálást a védett alkalmazáshoz — az összes könyvtár-ellenőrzés false-t ad vissza. Liberty Lite — átfogó megkerülés, amely a népszerű védelmi könyvtárak legtöbb ellenőrzését lefedi. Ellenintézkedés: szerveroldali ellenőrzés DeviceCheck és App Attest segítségével — a szerveren ellenőrzik, hogy az eszköz rendelkezik-e érvényes Apple tanúsítvánnyal, amely nem hamisítható jailbreakelt eszközön.

Megkerülés Fugu14 és KFD segítségével

A kernel-exploitok, mint a Fugu14 és a KFD, kódot hajtanak végre a kernel térben (kernel-space), ami lehetővé teszi a rendszerhívások elfogását még mielőtt az alkalmazás látná azokat. Ezen a szinten a stat() és fork() ellenőrzések hatástalanná válnak. Az egyetlen megbízható ellenintézkedés — szerveroldali tanúsítás annak ellenőrzésével, hogy az eszköz átesett az Apple Attestation eljáráson. Ez a protokoll a Secure Enclave-ben lévő kriptográfiai kulcsokon alapul, amelyek még kernel szintű exploit esetén sem olvashatók.

Az iOS biztonsági architektúrája és a jailbreak szerepe

A hatékony Jailbreak Detection kiépítéséhez meg kell érteni, hogy az iOS mely biztonsági mechanizmusai kapcsolódnak ki jailbreak esetén.

Secure Boot Chain

Az iOS aláírás-ellenőrzések sorozatán keresztül indul: Boot ROM → iBoot → iOS Kernel. Ha a jailbreak bootrom exploitot (checkra1n) használ, a teljes Secure Boot Chain sérül — az alkalmazás szintű ellenőrzések haszontalanok. Ha software-only exploitot (unc0ver, Taurine, Fugu14) használnak, a boot-lánc nem sérül, és az Apple-szolgáltatások, mint a App Attest, megbízhatóak maradnak.

Kernel Patch Protection (KPP)

Az iOS 10-től kezdve az Apple bevezette a KPP-t — egy hardveres védelmet, amely 200 ms-onként újraellenőrzi a kernel integritását. Az összes modern jailbreak (iOS 14–17) a KTRR megkerülését használja PAC vagy APRR segítségével, de a KPP nyomokat hagy a módosított sysctl rendszertáblák formájában. A kern.version ellenőrzése a pwned, prod vagy nem szabványos verziójú xnu sztringek jelenlétére felfedheti a kernel patch jelenlétét.

Homokozó integritás

Az iOS homokozó a TrustedBSD szintjén működik entitlements segítségével. A jailbreak a homokozó profilját allow-all-ra cseréli. Az alkalmazás ellenőrizheti a homokozót bármely fájl olvasásának kísérletével a saját Documents könyvtárán kívül. Ha sikerül — a homokozó módosítva van. Homokozó integritás — azon kevés indikátor egyike, amely nem hamisítható kernel szintű exploit nélkül, mivel a jogosultságellenőrzés a kernelben történik, mielőtt elfogható lenne.