Jak wykryć, że aplikacja na iOS działa na telefonie jailbroken?

+(BOOL)isJailbroken {
    NSURL* url = [NSURL URLWithString:@"cydia://package/com.example.package"];
    return [[UIApplication sharedApplication] canOpenURL:url];
}

Sprawdzanie ścieżki pliku {[1] } jest niedozwolone w normalnym telefonie? Nigdy nie słyszałem, aby Apple wykryło to i odrzuciło aplikację, ale Apple jest nieprzewidywalne. Cydia ma schemat URL cydia: / / , który można legalnie sprawdzić za pomocą UIApplication canOpenURL:

Sprawdzanie, czy jądro jest zepsute, nie jest bardziej zaangażowane.

Jailbreaking sprawia, że sprawdzanie podpisu jądra podpisanego kodu zawsze zgłasza, że kod jest podpisany poprawnie, nieprzerwane telefony nie mogą uruchomić kodu ze złym podpisem.

Więc dołącz do aplikacji osobny plik wykonywalny ze złym podpisem. Może to być po prostu 3-liniowy program, który ma main () i zwracaną wartość. Skompiluj plik wykonywalny bez podpisywania kodu (wyłącz go w Ustawieniach projektu- > Build) i podpisz go za pomocą inny klucz za pomocą narzędzia wiersza poleceń "codesign".

Niech twój Exec aplikacji będzie oddzielnym programem wykonywalnym. Jeśli twój program nie może uzyskać wartości zwracanej podczas uruchamiania oddzielnego pliku wykonywalnego ze złym sig, to na pewno jest uwięziony. Jeśli oddzielny plik wykonywalny zwróci-OK, telefon jest zdecydowanie jailbreak.

Jest to kod, który łączy kilka odpowiedzi, które znalazłem dla tej potrzeby, i daje znacznie wyższy wskaźnik sukcesu:

BOOL isJailbroken()
{
#if !(TARGET_IPHONE_SIMULATOR)

   if ([[NSFileManager defaultManager] fileExistsAtPath:@"/Applications/Cydia.app"] ||
       [[NSFileManager defaultManager] fileExistsAtPath:@"/Library/MobileSubstrate/MobileSubstrate.dylib"] ||
       [[NSFileManager defaultManager] fileExistsAtPath:@"/bin/bash"] ||
       [[NSFileManager defaultManager] fileExistsAtPath:@"/usr/sbin/sshd"] ||
       [[NSFileManager defaultManager] fileExistsAtPath:@"/etc/apt"] ||
       [[NSFileManager defaultManager] fileExistsAtPath:@"/private/var/lib/apt/"] ||
       [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"cydia://package/com.example.package"]])  {
         return YES;
   }

   FILE *f = NULL ;
   if ((f = fopen("/bin/bash", "r")) ||
      (f = fopen("/Applications/Cydia.app", "r")) ||
      (f = fopen("/Library/MobileSubstrate/MobileSubstrate.dylib", "r")) ||
      (f = fopen("/usr/sbin/sshd", "r")) ||
      (f = fopen("/etc/apt", "r")))  {
         fclose(f);
         return YES;
   }
   fclose(f);

   NSError *error;
   NSString *stringToBeWritten = @"This is a test.";
   [stringToBeWritten writeToFile:@"/private/jailbreak.txt" atomically:YES encoding:NSUTF8StringEncoding error:&error];
   [[NSFileManager defaultManager] removeItemAtPath:@"/private/jailbreak.txt" error:nil];
   if(error == nil)
   {
      return YES;
   }

#endif

   return NO;
}

BOOL isJailbroken()
{
#if TARGET_IPHONE_SIMULATOR
    return NO;
#else
    FILE *f = fopen("/bin/bash", "r");

    if (errno == ENOENT)
    {
        // device is NOT jailbroken
        fclose(f);
        return NO;
    }
    else {
        // device IS jailbroken
        fclose(f);
        return YES;
    }
#endif
}

Możesz wykryć, czy urządzenie jest JailBroken, czy nie, sprawdzając, czy:

• Cydia jest zainstalowana
• zweryfikuj niektóre ścieżki systemowe
• sprawdzenie integralności piaskownicy
• weryfikacja dowiązań symbolicznych
• Sprawdź, czy tworzysz i zapisujesz pliki poza piaskownicą

Istnieje biblioteka open source, którą stworzyłem z różnych artykułów i książek. Wypróbuj to na GitHub !

Przerobiłem W Swift 2.3 rozwiązanie dostarczone przez @Yossi

public static func jailbroken(application: UIApplication) -> Bool {
    guard let cydiaUrlScheme = NSURL(string: "cydia://package/com.example.package") else { return isJailbroken() }
    return application.canOpenURL(cydiaUrlScheme) || isJailbroken()
}


static func isJailbroken() -> Bool {

    if isSimulator {
        return false
    }

    let fileManager = NSFileManager.defaultManager()
    if fileManager.fileExistsAtPath("/Applications/Cydia.app") ||
        fileManager.fileExistsAtPath("/Library/MobileSubstrate/MobileSubstrate.dylib") ||
        fileManager.fileExistsAtPath("/bin/bash") ||
        fileManager.fileExistsAtPath("/usr/sbin/sshd") ||
        fileManager.fileExistsAtPath("/etc/apt") ||
        fileManager.fileExistsAtPath("/usr/bin/ssh") {
        return true
    }

    if canOpen("/Applications/Cydia.app") ||
        canOpen("/Library/MobileSubstrate/MobileSubstrate.dylib") ||
        canOpen("/bin/bash") ||
        canOpen("/usr/sbin/sshd") ||
        canOpen("/etc/apt") ||
        canOpen("/usr/bin/ssh") {
        return true
    }

    let path = "/private/" + NSUUID().UUIDString
    do {
        try "anyString".writeToFile(path, atomically: true, encoding: NSUTF8StringEncoding)
        try fileManager.removeItemAtPath(path)
        return true
    } catch {
        return false
    }
}

static func canOpen(path: String) -> Bool {
    let file = fopen(path, "r")
    guard file != nil else { return false }
    fclose(file)
    return true
}

Najbardziej wyrafinowaną metodą jaką znam jest użycie objc_copyImageNames() funkcji. Zwraca listę aktualnie załadowanych bibliotek, a ponieważ większość ludzi ma MobileSubstrate na urządzeniach jailbroken, a większość narzędzi IAP crack zależy od tego, przynajmniej niektóre biblioteki MobileSubstrate pojawią się.

Proponuję poszukać plików, których nie ma na" waniliowym " iPhonie. Wszystkie zestawy jailbreak widziałem zainstalować ssh. To może być dobry wskaźnik telefonu jailbreak.

Spróbuj znaleźć plik, który Cydia lub jailbroken device utworzyć. Lub spróbuj zapisać w pliku poza czarną skrzynką aplikacji. Jeśli uda ci się to zrobić, urządzenie jest zagrożone / jailbroken:)

- (BOOL)jailbroken
{
    NSFileManager * fileManager = [NSFileManager defaultManager];
    return [fileManager fileExistsAtPath:@"/private/var/lib/apt/"];
}

Spróbuj wykonać niepodpisany kod za pośrednictwem aplikacji.

Urządzenia jailbroken zazwyczaj mają następujące cechy:

• Uruchom unsigned code
• czy Cydia jest zainstalowana
• mA pliki jailbreak
• pełny dostęp r / W do całego systemu plików
• niektóre pliki systemowe zostaną zmodyfikowane (zawartość i tak sha1 nie pasuje do oryginalnych plików)
• przyklejony do konkretnej wersji (Wersja jailbreakable)

Tylko sprawdzam istnienie pliku dla wykrywanie jailbreak jest skazane na niepowodzenie. Te kontrole są łatwe do obejścia.

Nie jestem świadomy żadnych "API", które istnieją w tym celu. Gdyby tak było, to produkt maskujący jailbreak szybko by je zatuszował.

Jak wiele osób wskazuje, jest to gra z kotem i myszką. A gdy obaj gracze staną się ekspertami, wszystko sprowadza się do tego, kto dostanie pierwszy ruch. (Osoba trzymająca urządzenie.)

Znalazłem wiele dobrych propozycji wykrywania jailbreak w nowej książce Zdziarskiego "Hacking and Securing iOS Apps". (Osobiście zapłaciłem więcej za ebooka O ' Reilly, ponieważ umożliwiają kopiowanie i wklejanie.)

Nie, Nie jestem związany z wydawcami. Ale uważam, że to dobra książka. Nie lubię po prostu publikować błędów hakerów, żeby mogli je naprawić, więc pomyślałem, że wskażę książkę.

Co zrobiliśmy, mamy już kanał RSS do komunikowania się z naszymi użytkownikami ( akcje na żywo ), umieściliśmy element wiadomości, który stwierdza coś takiego:

Niektóre urządzenia jailbroken mają problemy bla bla bla, zrobiliśmy hack, aby rozwiązać te problemy, ale musimy wiedzieć, czy to urządzenie jailbroken, czy nie, naciśnij tutaj, aby aplikacja rozwiązuje problem. Jeśli kiedykolwiek powrócić do normy, czyli usunięte jailbreak, naciśnij tutaj.

Następnie przetwarzasz interakcję z użytkownikiem i robisz to, co jest odpowiednie, np. zachowując się inaczej itp...

Niektóre popularne pliki do sprawdzenia: /Library/MobileSubstrate/MobileSubstrate.dylib

/Applications/Cydia.app

/var/cache/apt

/var/lib/apt

/var/lib/cydia

/var/log/syslog

/var/tmp/cydia.log

/bin/bash

/bin/sh

/usr/sbin/sshd

/usr/libexec/ssh-keysign

/etc/ssh/sshd_config

/etc/apt

Większość sprawdza pliki związane z Cydią.

Będziesz podążać za ruchomym celem, ale możesz spróbować śledzić postępy tych zasobów, aby zobaczyć, jak skuteczna jest twoja technika:

• https://www.theiphonewiki.com/wiki/Bypassing_Jailbreak_Detection
• https://www.theiphonewiki.com/wiki/XCon

Oto moje rozwiązania:

extension UIDevice {
    func isJailBroken() -> Bool {
        var jailBroken = false
        let cydiaPath = "/Applications/Cydia.app"
        let aptPath = "/private/var/lib/apt/"
        if FileManager.default.fileExists(atPath: cydiaPath) {
            jailBroken = true
        }
        if FileManager.default.fileExists(atPath: aptPath) {
            jailBroken = true
        }
        return jailBroken
    }
}

I wywołaj go wewnątrz viewDidLoad() wewnątrz kontrolera widoku ekranu startowego (lub dowolnego VC, do którego dzwonisz po raz pierwszy):

    if UIDevice.current.isJailBroken() {
       // show a blank screen or some other view controller
       let jailbreakVC = JailBrokenViewController()
       self.navigationController?.present(jailbreakVC, animated: true, completion:nil)
    } else {
     // continue executing your next View controller
     let nextVC = NextViewController()
     self.navigationController?.present(nextVC, animated: true, completion:nil)
    }

Spróbuj Uzyskać Dostęp Do / Aplikacji / Preferencji.app / ogólne.plist Powinieneś być w stanie to zrobić na jailbroken iPhone Na telefonie innym niż JB nie będziesz mieć do niego dostępu