iOS
Veiligheid

Invoering

Transportbeveiliging met SSL

iOS-apps moeten zodanig zijn geschreven dat gegevens worden beveiligd die via het netwerk worden getransporteerd.
SSL is de gebruikelijke manier om dit te doen.

Wanneer een app probeert webservices op te roepen om gegevens naar servers te halen of te pushen, moet deze SSL gebruiken via HTTP, dat wil zeggen HTTPS .
Om dit te doen, moet de app https://server.com/part dergelijke webservices aanroepen en niet http://server.com/part .
In dit geval moet de app de server server.com vertrouwen met behulp van een SSL-certificaat.

Hier is het voorbeeld van het valideren van serververtrouwen

Implementeer URLSessionDelegate als:

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

Hier is trust manager: (kon Swift-code niet vinden)

@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 is de openbare SSL-sleutel van servers.

Met deze aanpak kan onze app ervoor zorgen dat deze communiceert met de beoogde server en dat niemand de app-servercommunicatie onderschept.

Gegevens beveiligen in iTunes-back-ups

Als we willen dat onze app-gegevens worden beschermd tegen iTunes-back-ups, moeten we onze app-gegevens overslaan zodat er geen back-up in iTunes wordt gemaakt.
Wanneer een iOS-apparaat een back-up maakt met iTunes op macOS, worden alle gegevens die zijn opgeslagen door alle apps gekopieerd in die back-up en opgeslagen op de back-upcomputer.

Maar we kunnen onze app-gegevens van deze back-up uitsluiten met de URLResourceKey.isExcludedFromBackupKey sleutel.
Hier is de mappenstructuur van onze app:
Opmerking: algemeen gevoelige gegevens worden opgeslagen in de map 'Application Support'.

Als we bijvoorbeeld al onze gegevens die zijn opgeslagen in de Application Support- map willen uitsluiten, kunnen we de bovengenoemde sleutel als volgt gebruiken:

    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
    }

Er zijn veel tools beschikbaar om iTunes-back-ups te bekijken voor alle back-upgegevens om te bevestigen of bovenstaande aanpak werkt of niet.
iExplorer is een goede manier om iTunes-back-ups te verkennen.