iOS
Bezpieczeństwo

Wprowadzenie

Bezpieczeństwo transportu przy użyciu protokołu SSL

Aplikacje na iOS muszą być napisane w sposób zapewniający bezpieczeństwo danych transportowanych przez sieć.
SSL jest powszechnym sposobem na to.

Ilekroć aplikacja próbuje wywołać usługi sieciowe w celu pobrania lub wypchnięcia danych do serwerów, powinna używać SSL przez HTTP, tj . HTTPS .
Aby to zrobić, aplikacja musi wywoływać https://server.com/part takie usługi sieciowe, a nie http://server.com/part .
W takim przypadku aplikacja musi zaufać serwerowi server.com za pomocą certyfikatu SSL.

Oto przykład sprawdzania poprawności zaufania serwera

Zaimplementuj URLSessionDelegate jako:

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

Oto menedżer zaufania: (nie można znaleźć kodu 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 to publiczny klucz SSL serwerów.

Korzystając z tego podejścia, nasza aplikacja może upewnić się, że komunikuje się z zamierzonym serwerem i nikt nie przechwytuje komunikacji między serwerem aplikacji a serwerem.

Zabezpieczanie danych w kopiach zapasowych iTunes

Jeśli chcemy, aby dane naszej aplikacji były chronione przed kopiami zapasowymi iTunes, musimy pominąć tworzenie kopii zapasowej danych aplikacji w iTunes.
Za każdym razem, gdy urządzenie iOS tworzy kopię zapasową za pomocą iTunes na macOS, wszystkie dane przechowywane przez wszystkie aplikacje są kopiowane do tej kopii zapasowej i przechowywane na komputerze kopii zapasowej.

Ale możemy wykluczyć dane naszej aplikacji z tej kopii zapasowej za pomocą klucza URLResourceKey.isExcludedFromBackupKey .
Oto struktura katalogów naszej aplikacji:
Uwaga: Ogólnie wrażliwe dane są przechowywane w katalogu „Obsługa aplikacji”.

np. jeśli chcemy wykluczyć wszystkie nasze dane przechowywane w katalogu wsparcia aplikacji , możemy użyć wyżej wymienionego klucza w następujący sposób:

    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
    }

Dostępnych jest wiele narzędzi umożliwiających przeglądanie kopii zapasowych iTunes dla wszystkich danych z kopii zapasowej w celu potwierdzenia, czy powyższe podejście działa, czy nie.
iExplorer jest dobrym narzędziem do przeglądania kopii zapasowych iTunes.