Swift Academy · Lekcja

Ochrona danych i szyfrowanie

Chroń pliki i poznaj podstawy CryptoKit.

Ochrona danych i szyfrowanie to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Data Protection w iOS

System iOS domyślnie szyfruje pliki na dysku, ale można określić, kiedy zawartość pliku może zostać odszyfrowana, korzystając z klas Data Protection. Uzależniają one dostęp do plików od stanu blokady urządzenia, podobnie jak klasy dostępności Keychain w przypadku sekretów.

import Foundation
// File-level protection ties decryption to lock state.
// Set a protection class when writing sensitive files.

Klasy ochrony

Główne poziomy ochrony plików to .complete (nie można odczytać podczas blokady), .completeUnlessOpen (pozostaje możliwy do odczytu, jeśli plik był już otwarty w chwili zablokowania), .completeUntilFirstUserAuthentication (można odczytać po pierwszym odblokowaniu) oraz .none.

import Foundation
// FileProtectionType:
//   .complete
//   .completeUnlessOpen
//   .completeUntilFirstUserAuthentication (default)
//   .none
let level = FileProtectionType.complete
_ = level

Zapisywanie chronionego pliku

Przekazanie .completeFileProtection w opcjach zapisu oznacza plik jako w pełni chroniony. Gdy urządzenie jest zablokowane, system uniemożliwia dostęp do jego zawartości nawet własnej aplikacji.

import Foundation
func writeSecure(_ data: Data, to url: URL) throws {
    try data.write(
        to: url,
        options: [.completeFileProtection])
}

Ustawianie ochrony istniejących plików

Po utworzeniu pliku można zmienić jego ochronę, ustawiając atrybut FileAttributeKey.protectionKey za pomocą FileManager. Jest to przydatne przy zaostrzaniu ochrony plików otrzymanych lub migrowanych.

import Foundation
func protect(_ url: URL) throws {
    try FileManager.default.setAttributes(
        [.protectionKey: FileProtectionType.complete],
        ofItemAtPath: url.path)
}

Szyfrowanie w aplikacji za pomocą CryptoKit

Gdy trzeba samodzielnie zaszyfrować dane — przed ich przesłaniem albo aby dodać warstwę ochrony do szyfrowania dysku — należy użyć CryptoKit. Udostępnia on nowoczesne, odporne na błędne użycie prymitywy z bezpiecznymi ustawieniami domyślnymi i bez ręcznego zarządzania IV w szyfrach AEAD.

import CryptoKit
// CryptoKit offers hashing, symmetric & public-key
// crypto with safe, hard-to-misuse APIs.

Haszowanie za pomocą SHA-256

Na potrzeby sprawdzania integralności i tworzenia odcisków SHA256 generuje skrót o stałym rozmiarze. Należy pamiętać, że haszowanie jest jednokierunkowe i nie zastępuje szyfrowania — hasła można haszować wyłącznie z użyciem soli i powolnego KDF.

import CryptoKit
import Foundation
func fingerprint(_ data: Data) -> String {
    let digest = SHA256.hash(data: data)
    return digest.map { String(format: "%02x", $0) }
        .joined()
}

Klucze symetryczne

Szyfrowanie symetryczne korzysta z jednego wspólnego klucza. SymmetricKey(size: .bits256) generuje silny losowy klucz. Klucz należy przechowywać w Keychain — nigdy obok szyfrogramu, który chroni.

import CryptoKit
let key = SymmetricKey(size: .bits256)
// Persist this key in the Keychain, not in a file.
_ = key

Szyfrowanie za pomocą AES-GCM

AES.GCM zapewnia szyfrowanie uwierzytelniane: szyfruje dane i wykrywa ich modyfikację. seal zwraca zapieczętowany obiekt zawierający szyrogram, nonce i znacznik uwierzytelniania połączone w całość.

import CryptoKit
import Foundation
func encrypt(_ data: Data, key: SymmetricKey)
    throws -> Data {
    let sealed = try AES.GCM.seal(data, using: key)
    return sealed.combined! // nonce + ciphertext + tag
}

Odszyfrowywanie i weryfikowanie

Aby odszyfrować dane, należy odtworzyć obiekt SealedBox z połączonych danych i wywołać open. Jeśli szyrogram lub znacznik zostanie zmieniony, open zgłosi błąd — znacznik uwierzytelniania gwarantuje integralność, więc uszkodzone dane nigdy nie zostaną odszyfrowane bez sygnalizacji.

import CryptoKit
import Foundation
func decrypt(_ combined: Data, key: SymmetricKey)
    throws -> Data {
    let box = try AES.GCM.SealedBox(combined: combined)
    return try AES.GCM.open(box, using: key)
}

Wyprowadzanie kluczy z haseł

Nigdy nie należy używać surowego hasła jako klucza. Należy wyprowadzić klucz za pomocą HKDF (w przypadku danych wejściowych o wysokiej entropii) lub KDF opartego na haśle. HKDF z CryptoKit rozciąga i dodaje sól do materiału kluczowego, tworząc właściwy klucz symetryczny.

import CryptoKit
import Foundation
func deriveKey(from secret: Data, salt: Data)
    -> SymmetricKey {
    return HKDF<SHA256>.deriveKey(
        inputKeyMaterial: SymmetricKey(data: secret),
        salt: salt,
        outputByteCount: 32)
}

Warstwowe zabezpieczenia

Bezpieczne aplikacje łączą wiele warstw: Data Protection szyfruje dane w spoczynku, uzależniając dostęp od stanu blokady, Keychain chroni klucze za pomocą biometrii, a CryptoKit dodaje szyfrowanie na poziomie aplikacji dla danych przesyłanych lub przechowywanych w chmurze. Każda warstwa zachowuje bezpieczeństwo nawet w przypadku awarii pozostałych.

import CryptoKit
import Foundation
// 1. Key lives in Keychain (biometric-gated)
// 2. Plaintext file written with .completeFileProtection
// 3. Uploads encrypted with AES.GCM before leaving device
let layers = "defense in depth"
_ = layers

Szybkie sprawdzenie

Proszę przypomnieć sobie, dlaczego AES-GCM jest preferowane do szyfrowania na poziomie aplikacji.

Podsumowanie

Poznali Państwo ochronę danych i szyfrowanie:

Klasy Data Protection dla plików (.complete, .completeUntilFirstUserAuthentication) wiążą deszyfrowanie dysku ze stanem blokady.
CryptoKit zapewnia haszowanie SHA-256, generowanie SymmetricKey oraz uwierzytelniane szyfrowanie AES-GCM za pomocą seal/open.
Klucze należy wyprowadzać za pomocą HKDF i przechowywać w Keychain — nigdy obok szyfrogramu.
Należy łączyć warstwy Data Protection, Keychain i CryptoKit, aby uzyskać ochronę wielowarstwową.

Często zadawane pytania

Czy lekcja „Ochrona danych i szyfrowanie” jest bezpłatna?

Tak — pełny tekst „Ochrona danych i szyfrowanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Ochrona danych i szyfrowanie”?

Chroń pliki i poznaj podstawy CryptoKit. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Ochrona danych i szyfrowanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy