Comment puis-je détecter qu'une application iOS fonctionne sur un téléphone jailbroken?

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

Vérifier le chemin du fichier /Applications/Cydia.app n'est pas autorisé sur un téléphone normal? Je n'ai jamais entendu parler D'Apple détecter cela et rejeter une application pour elle, mais Apple est imprévisible. Cydia a un schéma D'URL cydia: / / qui peut être légalement vérifié avec UIApplication canOpenURL:

vérifier si le noyau est cassé n'est pas beaucoup plus impliqué.

Jailbreaking rend la vérification de la signature du code signé par le noyau toujours signaler que le code est signé correctement, les téléphones intacts ne peuvent pas exécuter le code avec une mauvaise signature.

Donc, inclure un exécutable séparé dans l'application avec une mauvaise signature. Il peut s'agir simplement d'un programme à trois lignes qui a main() et une valeur de retour. Compiler l'exécutable sans signature de code (l'éteindre dans le projet Settings - > Build) et le signer avec une clé différente en utilisant l'utilitaire de ligne de commande" codesign".

avoir votre application exec l'exécutable séparé. Si votre programme ne peut pas obtenir la valeur de retour lors de l'exécution de l'exécutable séparé avec le sig bad, il est définitivement emprisonné. Si l'exécutable séparé retourne A-OK, le téléphone est définitivement bloqué.

c'est un code qui combine quelques réponses que j'ai trouvé pour ce besoin, et vous donnera un taux de succès beaucoup plus élevé:

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
}

vous pouvez détecter si un appareil est Bloqué ou non en vérifiant ce qui suit:

• Cydia est installé
• vérifier certaines des trajectoires du système
• effectuer une vérification de l'intégrité du bac à sable
• effectuer la vérification symlink
• vérifiez si vous créez et écrivez des fichiers à l'extérieur de votre bac à sable

Il y a une bibliothèque open source je créés à partir de divers articles et livres. l'Essayer sur GitHub !

j'ai retravaillé dans Swift 2.3 la solution fournie par @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
}

la méthode la plus sophistiquée que je connaisse utilise la fonction objc_copyImageNames() . Il retourne une liste des bibliothèques actuellement chargées et comme la plupart des gens ont MobileSubstrate sur des périphériques jailbroken et que la plupart des outils IAP crack en dépendent, au moins certaines bibliothèques MobileSubstrate apparaîtront.

je suggère de chercher des fichiers qui ne sont pas présents sur un iPhone" vanilla". Tous les kits jailbreak que j'ai vu installent ssh. Cela pourrait être un bon indicateur d'un téléphone jailbreaké.

essayez de trouver un fichier créé par cydia ou jailbroken device. Ou essayez d'écrire dans un fichier en dehors de la blackbox de l'application. Si vous réussissez à faire cela, l'appareil est compromis / jailbroken:)

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

essayez d'exécuter du code non signé à travers votre application.

a les dispositifs jailbroken ont généralement les caractéristiques suivantes:

• lancer du code non signé
• a Cydia installé
• a jailbreak fichiers
• accès r/w complet à l'ensemble du système de fichiers
• certains fichiers système auront été modifiés (le contenu et donc sha1 ne correspond pas avec les fichiers originaux)
• collé à la version spécifique (version jailbreakable)

le simple fait de vérifier l'existence d'un fichier pour détecter une évasion est voué à l'échec. Ces vérifications sont faciles à contourner.

Je n'ai connaissance d'aucun" APIs " qui existe pour cela. S'il y en avait un, un produit de masquage des évasions les couvrirait rapidement.

Comme beaucoup de gens, du chat et de la souris jeu. Et une fois que les deux joueurs sont devenus experts, tout se résume à qui obtient le premier coup. (Personne titulaire de l'appareil.)

j'ai trouvé de nombreuses bonnes suggestions pour détecter les évasions de prison dans le nouveau livre de Zdziarski"Hacking and Securing iOS Apps". (Personnellement, j'ai payé plus pour L'eBook O'Reilly parce qu'ils permettent la copie-et-coller.)

Non, Je ne suis pas affilié aux éditeurs. Mais je l'ai trouvé un bon livre. Je n'aime pas publier les erreurs des hackers pour qu'ils puissent les réparer, alors j'ai pensé pointer vers le livre.

ce que nous avons fait, c'est que nous avons déjà un flux RSS pour communiquer avec nos utilisateurs ( Stocks Live ), nous avons mis un article qui dit quelque chose comme ceci:

certains appareils jailbroken ont des problèmes bla bla bla, nous avons fait un hack pour résoudre ces problèmes, mais nous avons besoin de savoir si c'est un appareil jailbroken ou non, Appuyez ici pour que l'application corrige le problème. Si jamais vous retourner à la normale, c'est à dire supprimé le jailbreak, appuyez ici.

ensuite, vous traitez l'interaction de l'utilisateur et de faire ce qui est approprié, comme se comporter différemment, etc...

quelques fichiers communs à vérifier: /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 plupart des fichiers associés à Cydia.

vous allez suivre une cible mobile, mais vous pourriez essayer de suivre l'évolution de ces ressources pour voir à quel point votre technique est efficace:

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

Voici mes solutions:

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

et appelez-le à l'intérieur de viewDidLoad() à l'intérieur de votre contrôleur de vue d'écran de lancement(ou quel que soit le VC que vous appelez pour la première fois):

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

Essayez D'Accéder/Application / Préférences.app / General.plist Vous devriez être en mesure De le faire sur un iPhone jailbreaké Sur un téléphone non-Jb vous ne pourrez pas y accéder