Bird
Raised Fist0
iOS Swiftmobile~20 mins

Keychain for secure storage in iOS Swift - Mini App: Build & Ship

Choose your learning style10 modes available
Build: Secure Storage
This screen lets the user save a secret text securely using the iOS Keychain and retrieve it later.
Target UI
-------------------------
| Secure Storage         |
|-----------------------|
| Secret: [__________]   |
|                       |
| [Save Secret] [Load]   |
|                       |
| Loaded Secret: _______ |
-------------------------
A TextField to enter a secret string.
A 'Save Secret' button that saves the entered text securely in the Keychain.
A 'Load' button that retrieves the saved secret from the Keychain and displays it below.
Use Apple's Keychain Services API for secure storage.
Handle errors gracefully and show alerts if saving or loading fails.
Starter Code
iOS Swift
import SwiftUI
import Security

struct SecureStorageView: View {
    @State private var secretText = ""
    @State private var loadedSecret = ""
    @State private var showingAlert = false
    @State private var alertMessage = ""

    var body: some View {
        VStack(spacing: 20) {
            TextField("Enter secret", text: $secretText)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .padding()

            HStack {
                Button("Save Secret") {
                    // TODO: Save secretText to Keychain
                }
                Button("Load") {
                    // TODO: Load secret from Keychain
                }
            }
            .padding()

            Text("Loaded Secret: \(loadedSecret)")
                .padding()
        }
        .alert(isPresented: $showingAlert) {
            Alert(title: Text("Error"), message: Text(alertMessage), dismissButton: .default(Text("OK")))
        }
        .navigationTitle("Secure Storage")
    }
}

struct SecureStorageView_Previews: PreviewProvider {
    static var previews: some View {
        SecureStorageView()
    }
}
Task 1
Task 2
Task 3
Solution
iOS Swift
import SwiftUI
import Security

struct SecureStorageView: View {
    @State private var secretText = ""
    @State private var loadedSecret = ""
    @State private var showingAlert = false
    @State private var alertMessage = ""

    let service = "com.example.SecureStorage"
    let account = "userSecret"

    var body: some View {
        VStack(spacing: 20) {
            TextField("Enter secret", text: $secretText)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .padding()

            HStack {
                Button("Save Secret") {
                    do {
                        try saveSecret(secretText)
                        loadedSecret = ""
                    } catch {
                        alertMessage = "Failed to save secret: \(error.localizedDescription)"
                        showingAlert = true
                    }
                }
                Button("Load") {
                    do {
                        loadedSecret = try loadSecret() ?? "(No secret found)"
                    } catch {
                        alertMessage = "Failed to load secret: \(error.localizedDescription)"
                        showingAlert = true
                    }
                }
            }
            .padding()

            Text("Loaded Secret: \(loadedSecret)")
                .padding()
        }
        .alert(isPresented: $showingAlert) {
            Alert(title: Text("Error"), message: Text(alertMessage), dismissButton: .default(Text("OK")))
        }
        .navigationTitle("Secure Storage")
    }

    func saveSecret(_ secret: String) throws {
        guard let data = secret.data(using: .utf8) else {
            throw NSError(domain: "InvalidString", code: -1, userInfo: nil)
        }

        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: account
        ]

        let attributes: [String: Any] = [
            kSecValueData as String: data
        ]

        let status = SecItemCopyMatching(query as CFDictionary, nil)
        if status == errSecSuccess {
            // Item exists, update it
            let updateStatus = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
            if updateStatus != errSecSuccess {
                throw NSError(domain: "KeychainError", code: Int(updateStatus), userInfo: nil)
            }
        } else if status == errSecItemNotFound {
            // Item does not exist, add it
            var newItem = query
            newItem[kSecValueData as String] = data
            let addStatus = SecItemAdd(newItem as CFDictionary, nil)
            if addStatus != errSecSuccess {
                throw NSError(domain: "KeychainError", code: Int(addStatus), userInfo: nil)
            }
        } else {
            throw NSError(domain: "KeychainError", code: Int(status), userInfo: nil)
        }
    }

    func loadSecret() throws -> String? {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: account,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]

        var item: CFTypeRef?
        let status = SecItemCopyMatching(query as CFDictionary, &item)

        if status == errSecSuccess {
            guard let data = item as? Data,
                  let secret = String(data: data, encoding: .utf8) else {
                throw NSError(domain: "KeychainError", code: -2, userInfo: nil)
            }
            return secret
        } else if status == errSecItemNotFound {
            return nil
        } else {
            throw NSError(domain: "KeychainError", code: Int(status), userInfo: nil)
        }
    }
}

This solution uses SwiftUI for the user interface and Apple's Keychain Services API to securely save and load a secret string.

The saveSecret function first checks if the secret already exists in the Keychain. If it does, it updates the stored data. If not, it adds a new item. Errors during these operations throw exceptions that are caught and shown as alerts.

The loadSecret function tries to find the secret in the Keychain and returns it as a string. If not found, it returns nil.

The UI has a TextField for input, two buttons to save and load, and a Text view to display the loaded secret. Alerts inform the user if something goes wrong.

Final Result
Completed Screen
-------------------------
| Secure Storage         |
|-----------------------|
| Secret: [mySecret123]  |
|                       |
| [Save Secret] [Load]   |
|                       |
| Loaded Secret: mySecret123 |
-------------------------
User types a secret in the text field.
Tapping 'Save Secret' stores the secret securely in the Keychain.
Tapping 'Load' retrieves the secret from the Keychain and shows it below.
If saving or loading fails, an alert pops up with an error message.
Stretch Goal
Add biometric authentication (Face ID / Touch ID) before loading the secret.
💡 Hint
Use the LocalAuthentication framework to request biometric authentication before calling loadSecret().

Practice

(1/5)
1. What is the primary purpose of using the iOS Keychain in app development?
easy
A. To store large media files for offline use
B. To securely store sensitive data like passwords and tokens
C. To cache images for faster loading
D. To manage app user interface layouts

Solution

  1. Step 1: Understand Keychain's role

    The Keychain is designed to securely store sensitive information such as passwords, tokens, and certificates.
  2. Step 2: Differentiate from other storage

    It is not meant for large files, caching images, or UI management, which are handled by other systems.
  3. Final Answer:

    To securely store sensitive data like passwords and tokens -> Option B
  4. Quick Check:

    Keychain = Secure sensitive data [OK]
Hint: Keychain is for secrets, not files or UI [OK]
Common Mistakes:
  • Thinking Keychain stores large files
  • Confusing Keychain with cache or UI storage
  • Using Keychain for non-sensitive data
2. Which Swift code snippet correctly converts a String to Data for saving in Keychain?
easy
A. let data = myString.toData()
B. let data = Data(myString)
C. let data = myString.data(using: .utf8)
D. let data = Data.fromString(myString)

Solution

  1. Step 1: Identify correct String to Data conversion

    In Swift, String has a method data(using:) that converts it to Data using a specified encoding like UTF-8.
  2. Step 2: Check method validity

    Options B, C, and D use invalid or non-existent methods for this conversion.
  3. Final Answer:

    let data = myString.data(using: .utf8) -> Option C
  4. Quick Check:

    String.data(using:) = correct conversion [OK]
Hint: Use .data(using: .utf8) to convert String to Data [OK]
Common Mistakes:
  • Using non-existent methods like toData()
  • Trying to initialize Data directly with String
  • Forgetting to specify encoding
3. Given the following Swift code snippet, what will be the output if the keychain item exists and contains the string "secret123"?
let query: [String: Any] = [
  kSecClass as String: kSecClassGenericPassword,
  kSecAttrAccount as String: "userKey",
  kSecReturnData as String: true
]
var item: CFTypeRef?
let status = SecItemCopyMatching(query as CFDictionary, &item)
if status == errSecSuccess, let data = item as? Data, let password = String(data: data, encoding: .utf8) {
  print(password)
} else {
  print("No data found")
}
medium
A. Error: Keychain item missing
B. No data found
C. nil
D. secret123

Solution

  1. Step 1: Understand SecItemCopyMatching behavior

    If the keychain item with key "userKey" exists, SecItemCopyMatching returns errSecSuccess and the data is assigned to item.
  2. Step 2: Convert data to String

    The code safely unwraps the data and converts it to a UTF-8 string, then prints it.
  3. Final Answer:

    secret123 -> Option D
  4. Quick Check:

    Keychain item found = print stored string [OK]
Hint: If status is success, data prints as stored string [OK]
Common Mistakes:
  • Assuming print shows 'No data found' when item exists
  • Not casting item to Data before conversion
  • Ignoring status check before unwrapping
4. Identify the error in this Swift code snippet that tries to save a password to Keychain:
let password = "mypassword"
let data = password.data(using: .utf8)
let query: [String: Any] = [
  kSecClass as String: kSecClassGenericPassword,
  kSecAttrAccount as String: "userKey",
  kSecValueData as String: data
]
let status = SecItemAdd(query as CFDictionary, nil)
if status == errSecSuccess {
  print("Saved")
} else {
  print("Failed")
}
medium
A. data is optional and should be unwrapped before use
B. kSecAttrAccount key is incorrect
C. SecItemAdd requires a non-nil second parameter
D. kSecClassGenericPassword is not a valid class

Solution

  1. Step 1: Check data conversion

    The data(using:) method returns an optional Data?. It must be safely unwrapped before use.
  2. Step 2: Identify usage error

    Passing optional data directly to kSecValueData can cause runtime issues or failure to save.
  3. Final Answer:

    data is optional and should be unwrapped before use -> Option A
  4. Quick Check:

    Optional Data must be unwrapped before Keychain save [OK]
Hint: Always unwrap optional Data before saving to Keychain [OK]
Common Mistakes:
  • Passing optional Data without unwrapping
  • Misusing Keychain attribute keys
  • Assuming SecItemAdd second parameter cannot be nil
5. You want to update an existing password stored in Keychain for the account "userKey". Which approach correctly updates the password securely?
hard
A. Use SecItemUpdate with a query matching the account and provide new kSecValueData
B. Call SecItemAdd again with the same account and new password
C. Delete the old item with SecItemDelete then add a new item with SecItemAdd
D. Modify the stored password directly by changing the Keychain file

Solution

  1. Step 1: Understand Keychain update method

    The correct way to update an existing Keychain item is to use SecItemUpdate with a query to find the item and attributes to change.
  2. Step 2: Evaluate alternatives

    Using SecItemAdd with the same key will fail because the item exists. Deleting then adding works but is less efficient. Direct file modification is unsafe and unsupported.
  3. Final Answer:

    Use SecItemUpdate with a query matching the account and provide new kSecValueData -> Option A
  4. Quick Check:

    Update Keychain = SecItemUpdate [OK]
Hint: Use SecItemUpdate to change existing Keychain data [OK]
Common Mistakes:
  • Trying to add duplicate items with SecItemAdd
  • Deleting then adding instead of updating
  • Attempting unsafe direct file edits
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard