Swift Academy · Lezione

Controllo degli accessi al portachiavi

Proteggi gli elementi tramite dati biometrici e sblocco del dispositivo.

Controllo degli accessi al portachiavi è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Controllare quando i segreti sono leggibili

Memorizzare un segreto è solo metà del lavoro: deve controllare quando può essere letto. Il Keychain offre classi di accessibilità e flag di controllo degli accessi che proteggono gli elementi richiedendo lo sblocco del dispositivo, il codice o i dati biometrici. In questo modo i dati sono protetti anche in caso di smarrimento del dispositivo.

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

La chiave kSecAttrAccessible

kSecAttrAccessible imposta la classe di accessibilità durante l'aggiunta dell'elemento. Stabilisce se l'elemento è sempre disponibile, se lo è solo dopo il primo sblocco oppure solo mentre il dispositivo è sbloccato. Scelga il livello più restrittivo consentito dalla funzionalità.

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 rende l'elemento leggibile solo mentre il dispositivo è sbloccato. Le attività in background eseguite quando il dispositivo è bloccato non possono accedervi. È l'impostazione predefinita più sensata per la maggior parte dei token di sessione.

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

AfterFirstUnlock

kSecAttrAccessibleAfterFirstUnlock mantiene l'elemento leggibile dal primo sblocco dopo l'avvio fino al riavvio successivo, anche quando in seguito il dispositivo è bloccato. Lo utilizzi per i segreti necessari a un processo in background, ad esempio un token per la gestione delle notifiche push.

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

Varianti ThisDeviceOnly

Ogni classe di accessibilità dispone di una variante ...ThisDeviceOnly. Questi elementi sono esclusi dai backup crittografati e non vengono mai trasferiti su un nuovo dispositivo. Li utilizzi per le chiavi che non devono mai lasciare questo hardware.

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

Quando è impostato il codice

kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly memorizza l'elemento solo se l'utente ha impostato un codice e lo elimina se il codice viene rimosso. Garantisce che il segreto sia sempre protetto dal codice.

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

SecAccessControl per la presenza dell'utente

Oltre allo stato di blocco, SecAccessControlCreateWithFlags crea una policy che richiede l'autenticazione attiva dell'utente, tramite dati biometrici o codice, al momento della lettura. La associa tramite kSecAttrAccessControl, al posto della chiave di accessibilità o insieme a essa.

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

Flag di controllo degli accessi

I flag precisano il requisito: .userPresence consente i dati biometrici o il fallback al codice; .biometryCurrentSet invalida l'elemento se cambiano le impronte digitali o i volti registrati; .devicePasscode impone l'inserimento del codice. Li combini per esprimere i requisiti di sicurezza.

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

Aggiungere un elemento protetto

Per memorizzare un segreto protetto dalla biometria, inserisca l'oggetto SecAccessControl sotto kSecAttrAccessControl. Ogni lettura successiva chiederà all'utente di autenticarsi prima di restituire i dati.

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
}

La lettura richiede l'autenticazione dell'utente

La lettura di un elemento protetto attiva automaticamente l'interfaccia di autenticazione. Può fornire una stringa che spiega il motivo tramite kSecUseOperationPrompt, così la richiesta chiarisce perché l'accesso è necessario. La lettura resta in attesa finché l'utente non esegue l'autenticazione o annulla l'operazione.

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
}

Scegliere il livello corretto

Abbini la policy al livello di rischio:

Token di sessione utilizzato in background: AfterFirstUnlock.
Token utilizzato solo dall'interfaccia: WhenUnlocked.
Segreto di grande valore: SecAccessControl con .userPresence e una classe ThisDeviceOnly.

Un livello più restrittivo è più sicuro, ma impedisce l'accesso in background: occorre trovare il giusto equilibrio.

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

Verifica rapida

Ricordi quale classe di accessibilità è adatta a un segreto necessario in background.

Riepilogo

Ha imparato a controllare l'accesso agli elementi del Keychain:

kSecAttrAccessible imposta la disponibilità in base allo stato di blocco: WhenUnlocked, AfterFirstUnlock e le varianti ...ThisDeviceOnly, che escludono gli elementi dai backup.
WhenPasscodeSetThisDeviceOnly vincola l'elemento alla presenza di un codice.
SecAccessControl con flag come .userPresence o .biometryCurrentSet richiede l'autenticazione al momento della lettura.
Scelga il livello più restrittivo che consenta comunque il modello di accesso necessario.

Domande Frequenti

La lezione «Controllo degli accessi al portachiavi» è gratuita?

Sì — il testo completo di «Controllo degli accessi al portachiavi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Controllo degli accessi al portachiavi»?

Proteggi gli elementi tramite dati biometrici e sblocco del dispositivo. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Controllo degli accessi al portachiavi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Memorizzazione dei segreti nel portachiavi
Controllo degli accessi al portachiavi
Autenticazione biometrica
Protezione dei dati e crittografia

← Torna a Swift Academy