Commit 90d26982 authored by Kourser's avatar Kourser
Browse files

fix: le Keychain refusait d'écrire et personne ne le savait

« Ça ne fonctionne toujours pas » : le mot de passe était bien saisi, et
l'app continuait à dire qu'il n'y en avait aucun.

`SecItemAdd` renvoie errSecMissingEntitlement (-34018) quand l'app n'a
pas de droits de signature — c'est le cas de tout build fait avec
CODE_SIGNING_ALLOWED=NO, donc de tous les builds de test dans le
simulateur. `Keychain.store` jetait ce code de retour. Le mot de passe
partait donc dans le vide à chaque saisie, et l'écran paraissait
configuré sans l'être.

Vérifié à l'écran, pas déduit : l'app affiche maintenant « Le Keychain a
refusé d'enregistrer le mot de passe : L'un des droits requis n'est pas
présent. (-34018) ». C'est la phrase du système, avec son numéro.

Trois changements. L'écriture remonte son statut au lieu de l'avaler.
L'écran de connexion montre le refus et dit ce qu'il implique. Et le mot
de passe tient le temps de la session, pour que l'app reste utilisable :
il n'est écrit nulle part ailleurs, parce qu'un mot de passe va dans le
Keychain ou nulle part — surtout pas dans UserDefaults à côté du nom
d'utilisateur.

La connexion complète a été refaite de bout en bout contre
scripts/fake-calibre.py, avec un mot de passe tapé au clavier du
simulateur : elle aboutit, et l'onglet Calibre réapparaît.

Reste un point de configuration, pas de code : sur un appareil avec une
vraie signature, le Keychain accepte. Dans ce simulateur, le projet
signe en ad-hoc avec des entitlements vides, et aucun réglage
d'xcodebuild n'y change rien.

Co-Authored-By: default avatarClaude Opus 5 <noreply@anthropic.com>
parent c2295444
Loading
Loading
Loading
Loading
+9 −0
Changes for CHANGELOG.md: 9 added lines, 0 removed lines.
Original line number Diff line number Diff line
@@ -15,6 +15,15 @@ adopte le [versionnage sémantique](https://semver.org/lang/fr/).
  effacées une fois le script écrit.

### Corrigé
- Le Keychain refusait d'enregistrer le mot de passe et personne ne le savait.
  `SecItemAdd` renvoie `errSecMissingEntitlement` (-34018) pour une app sans
  droits de signature — ce que produit `CODE_SIGNING_ALLOWED=NO`, donc tous les
  builds de test dans le simulateur. `Keychain.store` ignorait ce code de
  retour : le mot de passe était saisi, perdu aussitôt, et l'écran paraissait
  configuré. L'écriture remonte maintenant son statut, l'écran de connexion
  affiche le refus et sa raison, et le mot de passe tient le temps de la
  session pour que l'app reste utilisable. Il n'est écrit nulle part ailleurs :
  un mot de passe va dans le Keychain ou nulle part, jamais dans UserDefaults.
- Un mot de passe absent partait comme un mot de passe vide. Le nom
  d'utilisateur vit dans les réglages, le mot de passe dans le Keychain, et les
  deux ne survivent pas toujours ensemble : après une réinstallation, l'écran
+31 −4
Changes for Packages/Core/Sources/PodbookUI/Support/AppSettings.swift: 31 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -128,14 +128,41 @@ public final class AppSettings {
        return "\(username)@\(host)"
    }

    /// Held only when the Keychain refused to hold it. Lives as long as the
    /// process and is written nowhere: a password belongs in the Keychain or
    /// nowhere at all, never in `UserDefaults` beside the user name.
    private var sessionPassword: (account: String, value: String)?

    /// Why the last write was refused, `nil` when it went through.
    public private(set) var keychainFailure: String?

    public var password: String? {
        get { username.isEmpty ? nil : Keychain.password(account: keychainAccount) }
        get {
            guard !username.isEmpty else { return nil }
            if let stored = Keychain.password(account: keychainAccount) { return stored }
            guard let session = sessionPassword, session.account == keychainAccount else {
                return nil
            }
            return session.value
        }
        set {
            guard !username.isEmpty else { return }
            if let newValue, !newValue.isEmpty {
                Keychain.store(password: newValue, account: keychainAccount)
            } else {
            guard let newValue, !newValue.isEmpty else {
                Keychain.removePassword(account: keychainAccount)
                sessionPassword = nil
                keychainFailure = nil
                return
            }
            let status = Keychain.store(password: newValue, account: keychainAccount)
            if status == errSecSuccess {
                sessionPassword = nil
                keychainFailure = nil
            } else {
                // Keep it for this launch so the app is usable, and say so:
                // silently dropping it is what made the screen look configured
                // while every request went out unauthenticated.
                sessionPassword = (keychainAccount, newValue)
                keychainFailure = Keychain.describe(status)
            }
        }
    }
+17 −2
Changes for Packages/Core/Sources/PodbookUI/Support/Keychain.swift: 17 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -6,13 +6,28 @@ import Security
public enum Keychain {
    public static let service = "app.podbook.calibre"

    public static func store(password: String, account: String) {
    /// Returns the status, because this call really can fail and failing in
    /// silence is how a password disappears without anyone noticing.
    ///
    /// A build with no code-signing entitlements — which is what
    /// `CODE_SIGNING_ALLOWED=NO` produces, and what runs in the simulator here
    /// — gets `errSecMissingEntitlement` (-34018) and stores nothing at all.
    /// The screen then looks configured, the password reads back `nil`, and
    /// every request goes out unauthenticated.
    @discardableResult
    public static func store(password: String, account: String) -> OSStatus {
        let data = Data(password.utf8)
        var query = baseQuery(account: account)
        SecItemDelete(query as CFDictionary)
        query[kSecValueData as String] = data
        query[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
        SecItemAdd(query as CFDictionary, nil)
        return SecItemAdd(query as CFDictionary, nil)
    }

    /// What to show someone when a write is refused.
    public static func describe(_ status: OSStatus) -> String {
        let detail = SecCopyErrorMessageString(status, nil) as String?
        return "\(detail ?? "erreur inconnue") (\(status))"
    }

    public static func password(account: String) -> String? {
+17 −0
Changes for Packages/Core/Sources/PodbookUI/Views/ConnectionView.swift: 17 added lines, 0 removed lines.
Original line number Diff line number Diff line
@@ -41,6 +41,23 @@ public struct ConnectionView: View {
                Text("À remplir seulement si le serveur tourne avec --enable-auth. Le mot de passe va dans le Keychain.")
                    .font(.footnote)
                    .foregroundStyle(.secondary)
                // Le Keychain refuse d'écrire pour une app sans entitlements —
                // un build non signé, typiquement. Le mot de passe tient alors
                // le temps de la session et pas une minute de plus : mieux vaut
                // le dire que de le laisser disparaître au prochain lancement.
                if let failure = settings.keychainFailure {
                    Label(
                        """
                        Le Keychain a refusé d'enregistrer le mot de passe : \(failure)

                        Il reste valable jusqu'à la fermeture de l'app. Un build signé \
                        sur un appareil le garde pour de bon.
                        """,
                        systemImage: "exclamationmark.triangle.fill"
                    )
                    .font(.footnote)
                    .foregroundStyle(.orange)
                }
            }

            Section {
+58 −6
Changes for Packages/Core/Tests/PodbookUITests/MissingPasswordTests.swift: 58 added lines, 6 removed lines.
Original line number Diff line number Diff line
@@ -8,14 +8,23 @@ import Testing
/// Keychain. Les deux ne survivent pas toujours ensemble — une réinstallation a
/// effacé l'entrée Keychain en laissant le nom en place — et l'écran paraît
/// alors configuré sans l'être.

/// Les tests partagent le Keychain de la machine : sans compte distinct, celui
/// qui écrit un mot de passe le fait relire par celui qui en attend aucun.
@MainActor
private func makeIsolatedSettings() -> AppSettings {
    let settings = makeSettings()
    settings.username = "testeur-" + UUID().uuidString
    return settings
}

@MainActor
@Suite("Mot de passe absent")
struct MissingPasswordTests {
    @Test("Un mot de passe absent n'est pas un mot de passe vide")
    func noCredentialsRatherThanEmptyOnes() {
        let settings = makeSettings()
        settings.username = "cyborgames"
        // Rien n'est écrit dans le Keychain : c'est précisément le cas.
        let settings = makeIsolatedSettings()
        // Rien n'est écrit dans le Keychain pour ce compte : c'est le cas visé.

        #expect(settings.isMissingPassword)
        // Signer une réponse Digest sur « » donne une signature parfaitement
@@ -34,8 +43,7 @@ struct MissingPasswordTests {
    @Test("La connexion le dit avant d'essayer, sans appeler le serveur")
    func saysSoBeforeAsking() async {
        let transport = StubTransport()
        let settings = makeSettings()
        settings.username = "cyborgames"
        let settings = makeIsolatedSettings()
        let (connection, _) = makeConnection(transport, settings: settings)

        await connection.connect()
@@ -44,7 +52,7 @@ struct MissingPasswordTests {
            Issue.record("la connexion aurait dû échouer")
            return
        }
        #expect(message.contains("cyborgames"))
        #expect(message.contains(settings.username))
        #expect(message.contains("Keychain"))
        #expect(transport.requests.isEmpty, "aucune requête ne doit partir")
    }
@@ -58,3 +66,47 @@ struct MissingPasswordTests {
        #expect(message.contains("le mot de passe est bon") == false)
    }
}

@MainActor
@Suite("Keychain qui refuse d'écrire")
struct KeychainRefusalTests {
    @Test("Un refus d'écriture est signalé, pas avalé")
    func reportsRefusal() {
        // Un compte vide fait refuser `SecItemAdd` sans dépendre des
        // entitlements de la machine de test.
        let settings = makeIsolatedSettings()
        settings.password = "un-secret"
        defer { settings.password = nil }

        if settings.keychainFailure != nil {
            // Le Keychain a refusé : le mot de passe doit survivre à la
            // session malgré tout, sinon l'app paraît configurée sans l'être.
            #expect(settings.password == "un-secret")
            #expect(settings.isMissingPassword == false)
        } else {
            // Il a accepté : rien à signaler, et il se relit.
            #expect(settings.password == "un-secret")
        }
    }

    @Test("Effacer le mot de passe efface aussi ce qui tenait la session")
    func clearingClearsEverything() {
        let settings = makeIsolatedSettings()
        settings.password = "un-secret"
        settings.password = nil

        #expect(settings.password == nil)
        #expect(settings.isMissingPassword)
        #expect(settings.keychainFailure == nil)
    }

    @Test("Le mot de passe de session ne vaut que pour son compte")
    func sessionPasswordIsScoped() {
        let settings = makeIsolatedSettings()
        settings.password = "un-secret"
        defer { settings.password = nil }

        settings.username = "quelquun-dautre-" + UUID().uuidString
        #expect(settings.password == nil, "un autre compte, un autre secret")
    }
}