iOS
Sécurité

Introduction

Transport Security utilisant SSL

Les applications iOS doivent être écrites de manière à sécuriser les données transportées sur le réseau.
SSL est le moyen le plus courant de le faire.

Chaque fois que l'application tente d'appeler des services Web pour extraire ou transférer des données vers des serveurs, elle doit utiliser le protocole SSL sur HTTP, c'est-à-dire HTTPS .
Pour ce faire, l' application doit appeler https://server.com/part tels services Web et non http://server.com/part .
Dans ce cas, l'application doit faire confiance au serveur server.com aide du certificat SSL.

Voici l'exemple de la validation de la confiance du serveur

Implémenter URLSessionDelegate tant que:

func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
    
    if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
        let serverTrust:SecTrust = challenge.protectionSpace.serverTrust!

        func acceptServerTrust() {
            let credential:URLCredential = URLCredential(trust: serverTrust)
            challenge.sender?.use(credential, for: challenge)
            completionHandler(.useCredential, URLCredential(trust: challenge.protectionSpace.serverTrust!))
        }
        
        let success = SSLTrustManager.shouldTrustServerTrust(serverTrust, forCert: "Server_Public_SSL_Cert")
        if success {
            acceptServerTrust()
            return
        }
    }
    else if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodClientCertificate {
        completionHandler(.rejectProtectionSpace, nil);
        return
    }
    completionHandler(.cancelAuthenticationChallenge, nil)
}

Voici le gestionnaire de confiance: (impossible de trouver le code Swift)

@implementation SSLTrustManager
+ (BOOL)shouldTrustServerTrust:(SecTrustRef)serverTrust forCert:(NSString*)certName {
// Load up the bundled certificate.
NSString *certPath = [[NSBundle mainBundle] pathForResource:certName ofType:@"der"];
NSData *certData = [[NSData alloc] initWithContentsOfFile:certPath];
CFDataRef certDataRef = (__bridge_retained CFDataRef)certData;
SecCertificateRef cert = SecCertificateCreateWithData(NULL, certDataRef);

// Establish a chain of trust anchored on our bundled certificate.
CFArrayRef certArrayRef = CFArrayCreate(NULL, (void *)&cert, 1, NULL);
SecTrustSetAnchorCertificates(serverTrust, certArrayRef);

// Verify that trust.
SecTrustResultType trustResult;
SecTrustEvaluate(serverTrust, &trustResult);

// Clean up.
CFRelease(certArrayRef);
CFRelease(cert);
CFRelease(certDataRef);

// Did our custom trust chain evaluate successfully?
return trustResult == kSecTrustResultUnspecified;
}
@end

Server_Public_SSL_Cert.der est la clé SSL publique des serveurs.

En utilisant cette approche, notre application peut s’assurer qu’elle communique avec le serveur prévu et que personne n’intercepte la communication avec le serveur d’application.

Sécurisation des données dans les sauvegardes iTunes

Si nous voulons que nos données d'application soient protégées contre les sauvegardes iTunes, nous devons ignorer les données de notre application pour les sauvegarder dans iTunes.
Chaque fois qu'un appareil iOS est sauvegardé à l'aide d'iTunes sur macOS, toutes les données stockées par toutes les applications sont copiées dans cette sauvegarde et stockées sur l'ordinateur de sauvegarde.

Mais nous pouvons exclure nos données d'application de cette sauvegarde en utilisant la clé URLResourceKey.isExcludedFromBackupKey .
Voici la structure de répertoire de notre application:
Remarque: les données généralement sensibles sont stockées dans le répertoire "Application Support".

Par exemple, si nous voulons exclure toutes nos données stockées dans le répertoire Application Support , nous pouvons utiliser les clés mentionnées ci-dessus comme suit:

    let urls = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)
    let baseURL = urls[urls.count-1];
    
    let bundleIdentifier = Bundle.main.object(forInfoDictionaryKey: "CFBundleIdentifier") as! String
    let pathURL = baseURL.appendingPathComponent(bundleIdentifier)
    let persistentStoreDirectoryPath = pathURL.path
    if !FileManager.default.fileExists(atPath: persistentStoreDirectoryPath) {
        do {
            try FileManager.default.createDirectory(atPath: path, withIntermediateDirectories: true, attributes: nil)  
        }catch {
            //handle error
        }
    }
    let dirURL = URL.init(fileURLWithPath: persistentStoreDirectoryPath, isDirectory: true)
    do {
        try (dirURL as NSURL).setResourceValue((true), forKey: .isExcludedFromBackupKey)
    } catch {
        //handle error
    }

De nombreux outils sont disponibles pour afficher les sauvegardes iTunes de toutes les données sauvegardées afin de vérifier si l’approche ci-dessus fonctionne ou non.
iExplorer est un bon outil pour explorer les sauvegardes iTunes.