Commit c2295444 authored by Kourser's avatar Kourser
Browse files

fix: un mot de passe absent partait comme un mot de passe vide

Signalé depuis le simulateur : « identifiants refusés » sur
GET /ajax/library-info — une route qui ne nomme aucune bibliothèque,
donc rien à voir avec l'encodage du nom accentué. Le champ mot de passe
était vide à l'écran.

Le nom d'utilisateur vit dans UserDefaults, le mot de passe dans le
Keychain, et les deux ne survivent pas toujours ensemble : la
réinstallation d'un build non signé avait effacé l'entrée Keychain en
laissant le nom en place. `makeServer()` faisait alors
`password ?? ""` et construisait des identifiants avec une chaîne vide.
La réponse Digest produite est parfaitement formée — c'est une vraie
signature, sur un mauvais secret — donc le serveur la refuse comme il
refuserait un mauvais mot de passe.

Et le message disait « le mot de passe est bon et c'est la signature de
cette requête-là qui est rejetée ». Il n'en savait rien. Cette phrase a
fait chercher du côté du percent-encoding pendant que la vraie cause
était un champ vide. Une erreur n'a pas le droit d'affirmer ce qu'elle
n'a pas vérifié.

Donc : pas d'identifiants plutôt que des identifiants vides, et la
connexion le dit avant d'appeler le serveur, en nommant l'utilisateur
concerné. Au passage, choisir une bibliothèque ne jette plus le
challenge déjà appris — chaque changement repayait un refus, compté
comme un échec d'authentification côté Calibre.

Pour vérifier tout cela sans toucher au serveur de l'utilisateur ni à
ses identifiants, scripts/fake-calibre.py reproduit les règles de
calibre/srv/auth.py relevées dans sa source. LiveDigestTests y fait
passer le vrai client : bibliothèque accentuée dans le chemin, en
paramètre, requêtes enchaînées et simultanées. Hors ligne par défaut.

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

### Corrigé
- 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
  paraissait configuré et `makeServer()` signait une réponse Digest sur une
  chaîne vide. La signature était parfaitement formée, le serveur la refusait,
  et le message accusait la signature de la requête — alors qu'il n'y avait
  simplement pas de mot de passe. La connexion le dit maintenant avant
  d'appeler le serveur, en nommant l'utilisateur concerné.
- Le message « identifiants refusés » affirmait que le mot de passe était bon.
  Il ne pouvait pas le savoir, et c'est ce qui a envoyé chercher du côté de
  l'encodage pendant que le champ était vide.
- Choisir une bibliothèque reconstruisait le client sans le challenge déjà
  appris : chaque changement repayait un aller-retour de refus, compté comme
  un échec d'authentification côté Calibre.

### Ajouté
- `scripts/fake-calibre.py` : un calibre-server en réduction qui applique les
  règles de `srv/auth.py` (signature sur l'uri telle qu'envoyée, comparaison du
  chemin décodé, nonce périmé au bout d'une heure, `nc` non vérifié). Les tests
  `LiveDigestTests` passent le vrai client dessus, sans serveur ni identifiants
  réels. Hors ligne par défaut.

- Le délai d'attente d'un modèle était de cinq minutes pour tout le monde. Or
  `timeoutIntervalForRequest` compte le silence, et une complétion non streamée
  n'envoie rien tant qu'elle n'est pas finie : toute la lecture du bloc plus
+30 −4
Changes for Packages/Core/Sources/PodbookUI/Stores/ConnectionStore.swift: 30 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -29,6 +29,9 @@ public final class ConnectionStore {
    public private(set) var capabilities: ServerCapabilities = .none
    public private(set) var libraries: [LibraryChoice] = []
    public private(set) var client: CalibreClient?
    /// Kept for the life of the connection, so picking a library does not
    /// throw away the challenge and buy another refusal from the server.
    private var authentication = AuthenticationCache()

    public init(
        settings: AppSettings,
@@ -70,11 +73,29 @@ public final class ConnectionStore {
            status = .failed("Adresse de serveur invalide")
            return
        }
        // Said before the request rather than after the refusal: a server that
        // asks for a password cannot be reached without one, and a 401 here
        // would name the wrong culprit.
        if settings.isMissingPassword {
            status = .failed(
                """
                Aucun mot de passe enregistré pour « \(settings.username) » sur ce serveur.

                Le nom d'utilisateur est gardé dans les réglages, le mot de passe \
                dans le Keychain : les deux ne survivent pas toujours ensemble. \
                Saisis-le à nouveau ci-dessus.
                """
            )
            client = nil
            capabilities = .none
            return
        }
        status = .connecting
        // Un seul cache d'authentification pour la sonde et pour le client
        // final : le challenge appris en se connectant servait, sinon, à rien,
        // et chaque session repayait un aller-retour de refus.
        let credentials = AuthenticationCache()
        authentication = AuthenticationCache()
        let credentials = authentication
        let probe = CalibreClient(
            server: server,
            transport: makeTransport(server),
@@ -126,7 +147,11 @@ public final class ConnectionStore {
        guard settings.libraryID != id else { return }
        settings.libraryID = id
        guard let server = settings.makeServer() else { return }
        client = CalibreClient(server: server, transport: makeTransport(server))
        client = CalibreClient(
            server: server,
            transport: makeTransport(server),
            authentication: authentication
        )
    }

    public func disconnect() {
@@ -145,8 +170,9 @@ public final class ConnectionStore {
                Identifiants refusés sur cette requête :
                \(origin)

                Si la connexion a pourtant abouti, le mot de passe est bon et \
                c'est la signature de cette requête-là qui est rejetée.
                Vérifie le nom d'utilisateur et le mot de passe. Si d'autres \
                requêtes passent et pas celle-ci, c'est sa signature qui est \
                en cause, pas le mot de passe.
                """
            case .notFound(let origin):
                "Serveur joignable, mais l'API attendue est absente à cette adresse.\n\(origin)"
+17 −2
Changes for Packages/Core/Sources/PodbookUI/Support/AppSettings.swift: 17 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -140,11 +140,26 @@ public final class AppSettings {
        }
    }

    /// A user is named but the Keychain has nothing for them.
    ///
    /// This is not a rare corner: the user name lives in `UserDefaults` and the
    /// password in the Keychain, and the two do not always survive together —
    /// reinstalling wiped the Keychain entry here while the name stayed put.
    /// The screen then looks configured and is not.
    public var isMissingPassword: Bool {
        !username.isEmpty && (password ?? "").isEmpty
    }

    public func makeServer() -> CalibreServer? {
        guard let url = Self.normalizedURL(from: serverURLText) else { return nil }
        var credentials: CalibreServer.Credentials?
        if !username.isEmpty {
            credentials = .init(username: username, password: password ?? "")
        // An absent password is **not** an empty password. Signing a Digest
        // response over "" produces a perfectly well-formed signature that the
        // server rejects, which reads exactly like a wrong password and sends
        // the search in the wrong direction entirely. It also counts as a
        // failed login on the server's side.
        if !username.isEmpty, let password, !password.isEmpty {
            credentials = .init(username: username, password: password)
        }
        return CalibreServer(baseURL: url, credentials: credentials, defaultLibraryID: libraryID)
    }
+68 −0
Changes for Packages/Core/Tests/CalibreKitTests/LiveDigestTests.swift: 68 added lines, 0 removed lines.
Original line number Diff line number Diff line
import Foundation
import Testing
@testable import CalibreKit

/// Le client complet contre un vrai serveur HTTP qui applique les règles de
/// `calibre/srv/auth.py` : signature sur l'uri telle qu'envoyée, comparaison du
/// chemin décodé, nonce périmé au bout d'une heure, `nc` non vérifié.
///
/// Hors ligne par défaut : ces tests ne tournent que si `PODBOOK_FAKE_CALIBRE`
/// désigne un serveur, parce qu'ils dépendent d'un processus extérieur. Les
/// lancer :
///
///     python3 -I scripts/fake-calibre.py 8099 &
///     PODBOOK_FAKE_CALIBRE=http://127.0.0.1:8099 swift test --filter LiveDigest
@Suite("Digest contre un serveur réel", .enabled(if: ProcessInfo.processInfo.environment["PODBOOK_FAKE_CALIBRE"] != nil))
struct LiveDigestTests {
    private var baseURL: URL {
        URL(string: ProcessInfo.processInfo.environment["PODBOOK_FAKE_CALIBRE"]!)!
    }

    private func makeClient(library: String?) -> CalibreClient {
        CalibreClient(server: CalibreServer(
            baseURL: baseURL,
            credentials: .init(username: "testeur", password: "mot-de-passe-de-test"),
            defaultLibraryID: library
        ))
    }

    @Test("Une route qui ne nomme aucune bibliothèque passe")
    func libraryInfo() async throws {
        let info = try await makeClient(library: nil).libraryInfo()
        #expect(info.defaultLibrary == "Bibliothèque_calibre")
    }

    @Test("Une route qui nomme une bibliothèque accentuée passe aussi")
    func accentedLibraryInPath() async throws {
        // C'est ici que la signature se joue : le chemin part percent-encodé,
        // et le serveur compare sa forme décodée à celle qu'il a servie.
        let page = try await makeClient(library: "Bibliothèque_calibre").search()
        #expect(page.bookIDs == [1])
    }

    @Test("Une route qui porte la bibliothèque en paramètre passe aussi")
    func accentedLibraryInQuery() async throws {
        let client = makeClient(library: "Bibliothèque_calibre")
        let books = try await client.books(ids: [1])
        #expect(books[1]?.title == "Un livre accentué")
    }

    @Test("Plusieurs requêtes de suite réutilisent le même challenge")
    func severalRequests() async throws {
        let client = makeClient(library: "Bibliothèque_calibre")
        for _ in 0 ..< 5 {
            _ = try await client.search()
        }
    }

    @Test("Des requêtes simultanées passent toutes")
    func concurrentRequests() async throws {
        let client = makeClient(library: "Bibliothèque_calibre")
        try await withThrowingTaskGroup(of: Void.self) { group in
            for _ in 0 ..< 12 {
                group.addTask { _ = try await client.search() }
            }
            try await group.waitForAll()
        }
    }
}
+60 −0
Changes for Packages/Core/Tests/PodbookUITests/MissingPasswordTests.swift: 60 added lines, 0 removed lines.
Original line number Diff line number Diff line
import CalibreKit
import CalibreKitTestSupport
import Foundation
import Testing
@testable import PodbookUI

/// Le nom d'utilisateur vit dans les réglages, le mot de passe dans le
/// 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.
@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.

        #expect(settings.isMissingPassword)
        // Signer une réponse Digest sur « » donne une signature parfaitement
        // formée que le serveur rejette : ça se lit comme un mauvais mot de
        // passe et ça envoie chercher au mauvais endroit.
        #expect(settings.makeServer()?.credentials == nil)
    }

    @Test("Sans nom d'utilisateur, rien ne manque")
    func noUsernameIsNotMissing() {
        let settings = makeSettings()
        #expect(settings.isMissingPassword == false)
        #expect(settings.makeServer()?.credentials == nil)
    }

    @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 (connection, _) = makeConnection(transport, settings: settings)

        await connection.connect()

        guard case .failed(let message) = connection.status else {
            Issue.record("la connexion aurait dû échouer")
            return
        }
        #expect(message.contains("cyborgames"))
        #expect(message.contains("Keychain"))
        #expect(transport.requests.isEmpty, "aucune requête ne doit partir")
    }

    @Test("Le message d'identifiants refusés n'affirme plus que le mot de passe est bon")
    func messageDoesNotVouchForThePassword() {
        let message = ConnectionStore.message(
            for: CalibreError.unauthorized(request: "GET https://exemple/ajax/library-info")
        )
        #expect(message.contains("GET https://exemple/ajax/library-info"))
        #expect(message.contains("le mot de passe est bon") == false)
    }
}
Loading