Swift Academy · Lekcja

Kontrola dostępu do Keychain

Ochrona elementów za pomocą biometrii i odblokowania urządzenia.

Kontrola dostępu do Keychain to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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.

Kontrolowanie, kiedy sekrety są dostępne do odczytu

Przechowywanie sekretu to tylko połowa zadania — należy kontrolować, kiedy można go odczytać. Keychain udostępnia klasy dostępności i flagi kontroli dostępu, które uzależniają dostęp do elementów od odblokowania urządzenia, kodu lub biometrii. Chroni to dane w przypadku utraty urządzenia.

import Security
// Two layers of control:
//   kSecAttrAccessible  -> when readable (lock state)
//   SecAccessControl    -> user presence / biometrics

Klucz kSecAttrAccessible

kSecAttrAccessible ustawia klasę dostępności podczas dodawania elementu. Określa, czy element jest dostępny zawsze, dopiero po pierwszym odblokowaniu, czy tylko wtedy, gdy urządzenie jest odblokowane. Należy wybrać najbardziej restrykcyjny poziom, na jaki pozwala dana funkcja.

import Security
let query: [String: Any] = [
    kSecClass as String: kSecClassGenericPassword,
    kSecAttrAccount as String: "user",
    kSecValueData as String: Data("secret".utf8),
    kSecAttrAccessible as String:
        kSecAttrAccessibleWhenUnlocked
]
_ = query

WhenUnlocked

kSecAttrAccessibleWhenUnlocked sprawia, że element można odczytać wyłącznie wtedy, gdy urządzenie jest odblokowane. Zadania w tle uruchomione podczas blokady nie mogą uzyskać do niego dostępu. Jest to rozsądne ustawienie domyślne dla większości tokenów sesji.

import Security
// Readable only while unlocked; blocked when locked.
let level = kSecAttrAccessibleWhenUnlocked
_ = level

AfterFirstUnlock

kSecAttrAccessibleAfterFirstUnlock zapewnia dostęp do elementu od pierwszego odblokowania po uruchomieniu aż do następnego ponownego uruchomienia — nawet podczas późniejszej blokady. Należy używać go w przypadku sekretów wymaganych przez proces działający w tle, takich jak token obsługi powiadomień push.

import Security
// Available after the first unlock post-boot,
// including while subsequently locked.
let level = kSecAttrAccessibleAfterFirstUnlock
_ = level

Warianty ThisDeviceOnly

Każda klasa dostępności ma wariant ...ThisDeviceOnly. Elementy te są wyłączone z zaszyfrowanych kopii zapasowych i nigdy nie są przenoszone na nowe urządzenie. Należy używać ich w przypadku kluczy, które nigdy nie powinny opuścić tego urządzenia.

import Security
// Never backed up, never migrated:
let local = kSecAttrAccessibleWhenUnlockedThisDeviceOnly
_ = local

Gdy ustawiony jest kod

kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly przechowuje element tylko wtedy, gdy użytkownik ma ustawiony kod, i usuwa go po usunięciu kodu. Gwarantuje to, że sekret jest zawsze chroniony kodem.

import Security
let level =
    kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly
// Item vanishes if the user disables their passcode.
_ = level

SecAccessControl na potrzeby obecności użytkownika

Poza stanem blokady funkcja SecAccessControlCreateWithFlags tworzy zasady wymagające aktywnego uwierzytelnienia użytkownika — za pomocą biometrii lub kodu — w chwili odczytu. Zasady te dołącza się za pomocą kSecAttrAccessControl zamiast klucza dostępności lub razem z nim.

import Security
func makeControl() -> SecAccessControl? {
    return SecAccessControlCreateWithFlags(
        nil,
        kSecAttrAccessibleWhenUnlockedThisDeviceOnly,
        .userPresence,
        nil)
}

Flagi kontroli dostępu

Flagi doprecyzowują wymagania: .userPresence pozwala użyć biometrii lub kodu jako rozwiązania zastępczego; .biometryCurrentSet unieważnia element po zmianie zarejestrowanych odcisków palców lub twarzy; .devicePasscode wymusza wpisanie kodu. Można je łączyć, aby wyrazić wymagania bezpieczeństwa.

import Security
// .userPresence        -> biometric OR passcode
// .biometryAny         -> any enrolled biometric
// .biometryCurrentSet  -> invalidate on biometric change
// .devicePasscode      -> passcode only
let flags: SecAccessControlCreateFlags = [.userPresence]
_ = flags

Dodawanie chronionego elementu

Aby przechować sekret chroniony biometrią, należy umieścić obiekt SecAccessControl pod kluczem kSecAttrAccessControl. Każdy późniejszy odczyt poprosi użytkownika o uwierzytelnienie przed zwróceniem danych.

import Security
func saveProtected(_ data: Data, account: String,
                   control: SecAccessControl) -> Bool {
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecValueData as String: data,
        kSecAttrAccessControl as String: control]
    return SecItemAdd(query as CFDictionary, nil)
        == errSecSuccess
}

Odczyt wyświetla monit użytkownikowi

Odczyt chronionego elementu automatycznie wyświetla interfejs uwierzytelniania. Za pomocą kSecUseOperationPrompt można przekazać tekst uzasadnienia, aby monit wyjaśniał, dlaczego potrzebny jest dostęp. Odczyt blokuje wykonanie do czasu uwierzytelnienia użytkownika albo anulowania operacji.

import Security
func readProtected(account: String) -> Data? {
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecReturnData as String: true,
        kSecUseOperationPrompt as String:
            String(localized: "Unlock your saved key")]
    var out: CFTypeRef?
    return SecItemCopyMatching(query as CFDictionary,
        &out) == errSecSuccess ? out as? Data : nil
}

Wybór właściwego poziomu

Poziom zasad należy dopasować do ryzyka:

Token sesji używany w tle: AfterFirstUnlock.
Token używany wyłącznie w interfejsie: WhenUnlocked.
Sekret o wysokiej wartości: SecAccessControl z .userPresence oraz klasą ThisDeviceOnly.

Większa restrykcyjność zwiększa bezpieczeństwo, ale uniemożliwia dostęp w tle — należy zachować równowagę.

import Security
// High-value: biometric-gated, device-bound, no backup
let control = SecAccessControlCreateWithFlags(
    nil,
    kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
    .userPresence, nil)
_ = control

Szybkie sprawdzenie

Proszę przypomnieć sobie, która klasa dostępności pasuje do sekretu wymaganego w tle.

Podsumowanie

Poznali Państwo sposoby ograniczania dostępu do elementów Keychain:

kSecAttrAccessible określa dostępność zależną od stanu blokady: WhenUnlocked, AfterFirstUnlock oraz warianty ...ThisDeviceOnly, które pomijają kopie zapasowe.
WhenPasscodeSetThisDeviceOnly uzależnia element od ustawienia kodu.
SecAccessControl z flagami takimi jak .userPresence lub .biometryCurrentSet wymaga uwierzytelnienia podczas odczytu.
Należy wybrać najbardziej restrykcyjny poziom, który nadal pozwala na wymagany sposób dostępu.

Często zadawane pytania

Czy lekcja „Kontrola dostępu do Keychain” jest bezpłatna?

Tak — pełny tekst „Kontrola dostępu do Keychain” 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 „Kontrola dostępu do Keychain”?

Ochrona elementów za pomocą biometrii i odblokowania urządzenia. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Kontrola dostępu do Keychain”?

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