iOS
Sicurezza

introduzione

Sicurezza del trasporto con SSL

Le app iOS devono essere scritte in modo da fornire sicurezza ai dati che vengono trasportati sulla rete.
SSL è il modo comune per farlo.

Ogni volta che l'app tenta di chiamare i servizi Web per estrarre o inviare dati ai server, dovrebbe utilizzare SSL su HTTP, ovvero HTTPS .
Per fare ciò, l' app deve chiamare https://server.com/part tali servizi Web e non http://server.com/part .
In questo caso, l'app deve considerare attendibile il server server.com utilizzando il certificato SSL.

Ecco l'esempio di convalida della fiducia del server

Implementa URLSessionDelegate come:

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

Ecco il gestore di fiducia: (impossibile trovare il codice 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 è la chiave SSL pubblica dei server.

Utilizzando questo approccio la nostra app può assicurarsi che stia comunicando con il server previsto e nessuno stia intercettando la comunicazione app-server.

Protezione dei dati nei backup di iTunes

Se vogliamo che i nostri dati delle app siano protetti dai backup di iTunes, dobbiamo saltare i nostri dati delle app dal backup su iTunes.
Ogni volta che il dispositivo iOS esegue il backup utilizzando iTunes su macOS, tutti i dati memorizzati da tutte le app vengono copiati in quel backup e archiviati sul computer di backup.

Ma possiamo escludere i dati delle nostre app da questo backup utilizzando la chiave URLResourceKey.isExcludedFromBackupKey .
Ecco la struttura delle directory della nostra app:
Nota: i dati generalmente sensibili sono memorizzati nella directory 'Application Support'.

Ad esempio, se vogliamo escludere tutti i nostri dati memorizzati nella directory del supporto applicativo , possiamo utilizzare la suddetta chiave come segue:

    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
    }

Ci sono molti strumenti disponibili per vedere i backup di iTunes per tutti i dati di backup per confermare se l'approccio sopra funziona o meno.
iExplorer è buono per esplorare i backup di iTunes.