Come posso rilevare che un'app iOS è in esecuzione su un telefono con jailbreak?

Question

Se voglio che la mia app si comporti in modo diverso su un iPhone con jailbreak, come farei per determinarlo?

Answer 1

Dipende da cosa intendi per jailbreak. Nel caso semplice, dovresti essere in grado di vedere se Cydia è installato e procedere così - qualcosa del genere

NSString *filePath = @"/Applications/Cydia.app";
if ([[NSFileManager defaultManager] fileExistsAtPath:filePath])
{
   // do something useful
}

Per i kernel compromessi, è un po '(molto) più coinvolto.

Answer 2

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

Il controllo del percorso del file /Applications/Cydia.app non è consentito su un normale telefono? Non ho mai sentito parlare di Apple che rileva questo e rifiuta un'app per esso, ma Apple è imprevedibile. Cydia ha uno schema URL cydia: // che può essere legalmente verificato con UIApplication canOpenURL:

Answer 3

Questo è un codice che combina alcune risposte che ho trovato per questa esigenza e ti darà un tasso di successo molto più alto:

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

Answer 4

Controllare se il kernel è rotto non è molto più coinvolto.

Il jailbreak fa in modo che il controllo della firma del kernel del codice firmato riferisca sempre che il codice è firmato correttamente, i telefoni ininterrotti non possono eseguire il codice con una firma errata.

Quindi, includi un eseguibile separato nell'app con una cattiva firma. Potrebbe essere solo un programma a 3 righe con main () e un valore di ritorno. Compilare l'eseguibile senza la firma del codice (disattivarlo in Impostazioni progetto- > Build) e firmarlo con una chiave diversa utilizzando il " codesign " utilità da riga di comando.

Chiedi alla tua app di eseguire l'eseguibile separato. Se il tuo programma non è in grado di ottenere il valore restituito durante l'esecuzione dell'eseguibile separato con il bad sign, è sicuramente imprigionato. Se l'eseguibile separato restituisce A-OK, il telefono è sicuramente jailbreak.

Answer 5

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
}

Answer 6

È possibile rilevare se un dispositivo è JailBroken o meno verificando quanto segue:

• Cydia è installato
• Verifica alcuni dei percorsi di sistema
• Esegui un controllo di integrità sandbox
• Esegue la verifica del collegamento simbolico
• Verifica se crei e scrivi file all'esterno di Sandbox

Esiste una libreria open source che ho creato da vari articoli e libri. Provalo su GitHub !

Answer 7

Ho rielaborato in Swift 2.3 la soluzione fornita da @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
}

Answer 8

Il metodo più sofisticato che conosco sta usando la funzione objc_copyImageNames () . Restituisce un elenco delle librerie attualmente caricate e poiché la maggior parte delle persone ha MobileSubstrate su dispositivi jailbroken e la maggior parte degli strumenti di crack iAP dipendono da esso, almeno alcune librerie MobileSubstrate verranno visualizzate.

Answer 9

Non sono a conoscenza di alcuna "API" che esiste per questo. Se ci fosse, allora un prodotto di mascheramento del jailbreak li coprirebbe rapidamente.

Come molte persone sottolineano, è un gioco gatto e topo. E dopo che entrambi i giocatori diventano esperti, tutto dipende da chi ottiene la prima mossa. (Persona che detiene il dispositivo.)

Ho trovato molti buoni suggerimenti per rilevare il jailbreak nel nuovo libro di Zdziarski "Attacco e protezione delle app iOS". (Personalmente, ho pagato di più per l'eBook O'Reilly perché consentono il copia e incolla.)

No, non sono affiliato con gli editori. Ma l'ho trovato un buon libro. Non mi piace solo pubblicare gli errori degli hacker in modo che possano risolverli, quindi ho pensato di indicare il libro.

Answer 10

Prova a eseguire codice non firmato tramite l'applicazione.

Un dispositivo jailbroken di solito ha le seguenti caratteristiche:

• esegui codice senza segno
• ha installato Cydia
• ha file di jailbreak
• pieno accesso r / w all'intero filesystem
• alcuni file di sistema saranno stati modificati (contenuto e quindi sha1 non corrisponde ai file originali)
• bloccato su una versione specifica (versione jailbreakable)

Il solo controllo dell'esistenza del file per il rilevamento del jailbreak è destinato a fallire. Questi controlli sono facili da aggirare.

Answer 11

Alcuni file comuni da verificare per: /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

La maggior parte controlla i file correlati a Cydia.

Answer 12

Suggerirei di cercare file che non sono presenti su un " vanilla " i phone. Tutti i kit di jailbreak che ho visto installare ssh. Potrebbe essere un buon indicatore di un telefono con jailbreak.

Answer 13

Quello che abbiamo fatto è che abbiamo già un feed RSS per comunicare con i nostri utenti ( Azioni in diretta ), inseriamo una notizia che afferma qualcosa del genere:

  

Alcuni dispositivi con jailbreak hanno problemi bla bla bla, abbiamo fatto un hack per risolvere quei problemi ma dobbiamo sapere se questo è un dispositivo jailbreak o no, premi qui in modo che l'app risolva il problema. Se dovessi tornare alla normalità, ad esempio rimosso il jailbreak, premi qui.

Quindi elabori l'interazione dell'utente e fai ciò che è appropriato, come comportarti in modo diverso, ecc ...

Answer 14

Prova a trovare un file creato da Cydia o dispositivo jailbreak. Oppure prova a scrivere in un file all'esterno della blackbox dell'app. Se riesci a farlo, il dispositivo è compromesso / jailbreak :)

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

Answer 15

Stai seguendo un bersaglio mobile, ma potresti provare a seguire l'avanzamento di queste risorse per vedere quanto è efficace la tua tecnica:

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

Answer 16

Ecco le mie soluzioni:

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

e chiamalo all'interno di viewDidLoad () all'interno del controller di visualizzazione della schermata di avvio (o di qualsiasi VC che chiami per la prima volta):

    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)
    }

Answer 17

Prova ad accedere a /Application/Preferences.app/General.plist Dovresti essere in grado di farlo su un iPhone con jailbreak Su un telefono non Jb non sarai in grado di accedervi