From a6b7f2002b335912ffb3927550642e6ac48fb31b Mon Sep 17 00:00:00 2001 From: m Date: Mon, 21 Sep 2026 19:59:52 +0200 Subject: [PATCH] fix backend audit findings (auth, upload, sync, data, ocr, contract) --- FEEDBACK.md | 297 ++++++++++++++++++ TASKS_PARALLELES.md | 137 ++++++++ backend/cmd/server/main.go | 53 +++- backend/cmd/server/router_test.go | 22 +- backend/config/config.go | 44 ++- backend/config/config_test.go | 44 ++- .../000007_resources_user_ownership.down.sql | 22 +- .../000007_resources_user_ownership.up.sql | 32 +- .../migrations/000008_operation_uuid.down.sql | 23 +- ...00011_resources_owner_updated_idx.down.sql | 1 + .../000011_resources_owner_updated_idx.up.sql | 7 + .../000012_ocr_jobs_status_created.down.sql | 1 + .../000012_ocr_jobs_status_created.up.sql | 4 + .../000013_operations_payload_hash.down.sql | 2 + .../000013_operations_payload_hash.up.sql | 10 + backend/db/migrations_test.go | 27 ++ backend/handlers/auth.go | 87 ++++- backend/handlers/auth_test.go | 73 ++++- backend/handlers/devices.go | 66 +++- backend/handlers/files.go | 67 +++- backend/handlers/files_test.go | 63 +++- backend/handlers/lot6_contract_test.go | 126 ++++++++ backend/handlers/middleware.go | 34 +- backend/handlers/middleware_test.go | 60 ++++ backend/handlers/ocr_test.go | 1 + backend/handlers/router.go | 6 +- backend/handlers/share_links.go | 12 +- backend/handlers/store.go | 10 +- backend/handlers/sync.go | 41 ++- backend/handlers/sync_test.go | 14 + backend/ocr/tesseract.go | 93 +++++- backend/ocr/tesseract_test.go | 52 +++ backend/pkg/api/response.go | 14 +- backend/pkg/auth/auth.go | 22 +- backend/pkg/auth/auth_test.go | 60 ++++ backend/pkg/passwd/passwd.go | 30 +- backend/repository/devices.go | 16 +- backend/repository/devices_test.go | 10 + backend/repository/ocr_jobs.go | 61 +++- backend/repository/ocr_jobs_test.go | 90 ++++++ backend/repository/operations.go | 166 +++++++++- backend/repository/operations_test.go | 133 +++++++- backend/repository/resources.go | 170 +++++++--- backend/repository/resources_test.go | 150 +++++++++ backend/repository/shares.go | 33 +- backend/repository/users.go | 57 +++- backend/repository/users_test.go | 24 +- backend/service/bootstrap.go | 4 +- backend/service/bootstrap_test.go | 26 ++ backend/service/folders.go | 14 - backend/service/move.go | 34 -- backend/service/move_test.go | 62 ---- backend/service/ocr.go | 92 +++++- backend/service/ocr_test.go | 70 +++++ backend/service/resources.go | 208 ++++++++++-- backend/service/resources_test.go | 202 ++++++++++++ backend/service/services.go | 33 +- backend/service/sync.go | 203 +++++++++--- backend/service/sync_test.go | 292 ++++++++++++++++- backend/service/upload.go | 19 -- 60 files changed, 3414 insertions(+), 412 deletions(-) create mode 100644 FEEDBACK.md create mode 100644 TASKS_PARALLELES.md create mode 100644 backend/db/migrations/000011_resources_owner_updated_idx.down.sql create mode 100644 backend/db/migrations/000011_resources_owner_updated_idx.up.sql create mode 100644 backend/db/migrations/000012_ocr_jobs_status_created.down.sql create mode 100644 backend/db/migrations/000012_ocr_jobs_status_created.up.sql create mode 100644 backend/db/migrations/000013_operations_payload_hash.down.sql create mode 100644 backend/db/migrations/000013_operations_payload_hash.up.sql create mode 100644 backend/handlers/lot6_contract_test.go create mode 100644 backend/handlers/middleware_test.go create mode 100644 backend/ocr/tesseract_test.go delete mode 100644 backend/service/folders.go delete mode 100644 backend/service/move.go delete mode 100644 backend/service/move_test.go delete mode 100644 backend/service/upload.go diff --git a/FEEDBACK.md b/FEEDBACK.md new file mode 100644 index 0000000..53303a9 --- /dev/null +++ b/FEEDBACK.md @@ -0,0 +1,297 @@ +# FEEDBACK — Audit backend Kazier + +Date : 2026-09-21 +Scope : `backend/` (Go, Gin, Postgres, Paseto, Tesseract) +Mode : lecture seule, vérifié dans le code. +But : autre agent relit et complète ci-dessous (voir § À compléter). + +## Haute priorité + +1. **Route `GET /files/folders` masquée** — `backend/handlers/router.go:29-32` + `GET /files/:id` déclaré avant `GET /files/folders`. Gin peut capter `folders` comme `id="folders"` → 404 au lieu de la liste. + +2. **`move_resource` sans check de cycle** — `backend/service/sync.go:204-219` + Seul `toFolder == resourceID` rejeté. Déplacer un parent dans son enfant crée un cycle, casse les CTE récursives (`depth<100`). + +3. **`create_link` non-idempotent** — `backend/service/sync.go:337` → `backend/repository/shares.go` (`CreateLink` INSERT simple sur PK `token`) + Rejeu même `operation_id` (crash entre apply et `Record`) → violation PK classée `INVALID_REQUEST` terminale, bloque tout l'outbox. Prévoir `ON CONFLICT DO NOTHING` comme `Operations.Record`. + +4. **`AUTH_SECRET` défaut faible** — `backend/config/config.go:49` + `backend/pkg/auth/auth.go` + Défaut `dev-secret-change-me`, juste `SHA256`, pas de check longueur/entropie → tokens paseto v4-local forgeables sur déploiements par défaut. + +5. **Upload : extension non sanitisée** — `backend/service/resources.go:148-154` + `filepath.Ext(file.Filename)` client tel quel → `destPath = /.`. Cas `""` → fichier `id.`, cas `../../`, `/`, très long → traversal / orphelins / ambiguïté `Glob(id.*)` pour OCR. + +6. **Orphelins + stale bytes au re-upload** — `backend/service/resources.go:161-162` + `backend/service/ocr.go` + `UpdatePhysical` ne supprime pas l'ancien `.`. `Glob` prend le premier match → OCR sur bytes périmés + fuite disque. Échec `GetFile` après `InsertFile` réussi laisse aussi le fichier. + +7. **`ApplyBatch` non-atomique** — `backend/service/sync.go:103-125` + `Applied() → apply → Record()` sans transaction. TOCTOU sur batches concurrents même `(device_id,operation_id)`, replay après crash, `Record` en 500 avec `applied` inconnu. + +8. **Fuite d'erreurs internes** — `backend/handlers/store.go:20-33` + `backend/service/sync.go:87-98` + Défaut `500 err.Error()` / `INVALID_REQUEST err.Error()` expose SQL/FS/paths au client. + +9. **`Count()` bloque le bootstrap** — `backend/repository/users.go` + `backend/service/bootstrap.go` + Compte les soft-deleted. Tous users supprimés → plus jamais de nouvel admin, lock définitif. Devrait filtrer `WHERE deleted_at IS NULL`. + +10. **Migrations destructives / irréversibles** + - `backend/db/migrations/000007_resources_user_ownership.up.sql:7` fait `DELETE FROM resources` à l'upgrade (wipe prod). + - `backend/db/migrations/000008_operation_uuid.down.sql` fait `operation_id::bigint` → casse dès que des IDs 32-hex avec `a-f` existent. + +11. **Stubs dangereux** — `backend/service/services.go`, `move.go`, `upload.go`, `folders.go` + `UserCan*` toujours `true`, no-ops. Si jamais câblés = bypass auth total. À supprimer. + +12. **Oracle `INVALID_DEVICE_ID` au login** — `backend/handlers/auth.go:55-81` + Check device après `VerifyTimedEqual`. Creds valides + device inconnu → 400 vs 401 → oracle + pas de rate-limit. + +## Priorité moyenne (phase 2) + +- `DeviceID` login non validé `^[0-9a-f]{32}$` (`backend/handlers/auth.go:50` vs `devices.go:23`), `folderId/fileId/token` jamais validés hex avant DB. +- `POST /sync/ops` non borné (`backend/handlers/sync.go`) : pas de `MaxBytesReader`, pas de cap batch (client=20) → DoS OOM. +- `ParentResourceID/ToFolder` non validés hex → mal classés `NOT_FOUND`. +- `UpdateNameByID`, `TouchResource` non scopés owner (reposent que sur l'appelant) — TOCTOU. +- `Revoke/RevokeLink` : erreurs swallow `_ =` → masque vraies pannes (`backend/service/sync.go:306-309,359-361`). +- OCR : `Create` owner-only mais `GetFileOcr` viewer+, `Get` job scopé `device_id` → 2e device du même user = 404. PDF ignore `ctx`, pas de cap taille/pages, stderr (avec paths) exposé (`backend/ocr/tesseract.go:47-66`). +- `passwd.Verify` parse `m=` du hash stocké sans cap → ligne DB compromise = OOM Argon2 au login (`backend/pkg/passwd/passwd.go:74-88`). +- `POST /devices` public sans rate-limit → remplissage table. `MarkUser` permet à n'importe qui de claim n'importe quel `device_id` (`backend/repository/devices.go:36-42`). +- `getInt` sans range check (PORT/WORKERS/MAX négatifs acceptés) (`backend/config/config.go:64-70`). +- `ChangePassword` ne révoque pas les tokens (fenêtre 7j) (`backend/handlers/auth.go:113-151`). +- `expiresAt` passé accepté pour shares/links → grants instantanément expirés. +- `Snapshot/ListOwned` `LIMIT 10000` sans pagination → troncation silencieuse (`backend/repository/shares.go:199`, `resources.go:547`). +- Positif : pas d'injection SQL trouvée (tout en `$n`, `sortClause` whitelist). + +## Plan proposé + +1. **P0 robustesse** : ordre routes, cycle move, idempotence `CreateLink`, transaction `ApplyBatch`, secret requis en prod, sanit `extension` + cleanup orphelins. +2. **P1 data** : fix `Count()` soft-deleted, corriger migrations 000007/000008, supprimer stubs, mapper erreurs sans fuite. +3. **P2 durcissement** : validation hex systématique, cap `sync/ops`, rate-limit login/devices, cap Argon2 + PDF/OCR, scope `Touch/UpdateName`, pagination snapshot. + +## À compléter (pour le relecteur) + +- Ajouter nouveaux bugs ci-dessous avec `fichier:ligne`, sévérité, explication courte. +- Ne pas supprimer les entrées existantes, juste append ou annoter. +- Idées à creuser : `handlers/files.go` (`intParam`, `q` non borné), `service/resources.go:164` (filename brut comme `name`, mime verbatim), `repository/resources.go` (parent check puis UPDATE non-atomique → FK 500), `cmd/server/main.go` (double pool, `conn` jamais `Close`, worker OCR non attendu), `pkg/auth` (TTL 7j sans refresh/révocation). + +### Ajouts relecteur (2026-09-21, vérifié en lecture) + +> Nota : entrées existantes conservées. Ci-dessous uniquement des ajouts. +> Annotation §1 : `GET /files/folders` vs `GET /files/:id` — Gin privilégie +> les segments statiques sur `:param` dans son arbre, donc l'ordre de +> déclaration (`router.go:29-32`) ne masque pas forcément `folders` en +> pratique. Reste fragile (dépend du routeur) : à verrouiller par un test +> `GET /files/folders → 200` + `GET /files/<32hex> → 200/404`, pas par l'ordre. + +#### A1 — CRITIQUE : bypass dummy-password + panic nil-deref au login +- `backend/pkg/passwd/passwd.go:37-43,98-103` + `backend/handlers/auth.go:55-83` +- `VerifyTimedEqual("", dummy)` vérifie contre `Hash("kazier-constantime-dummy")` + en dur. `username= + password="kazier-constantime-dummy"` → `Verify` + retourne `nil` → suite du handler avec `user == nil` → `user.ID:83` panic + (Gin recovery → 500). Effets : DoS à la demande + oracle 500 vs 401 qui casse + l'indistinguabilité revendiquée + préimage hardcodée en source. Fix : + dummy aléatoire par boot (ou hash du mot fourni à sel fixe) + ne jamais + toucher `user` si `userErr != nil`. + +#### A2 — Upload : `file.Size` fait confiance au header, `io.Copy` illimité +- `backend/service/resources.go:135,178-195` (service) vs `backend/handlers/files.go:119-133` (handler) +- Le handler protège le transport (`MaxBytesReader`), mais l'invariant + service est absent : header menteur → écriture disque illimitée. Envelopper + `src` dans `io.LimitReader` + re-contrôler les octets écrits. + +#### A3 — Upload non-atomique, torn reads OCR +- `backend/service/resources.go:154-157,178-195` +- `os.Create(dest)` + `io.Copy` direct, overwrite sur place pour + `targetExisting`. `service/ocr.go` (`Glob`) peut lire un fichier à moitié + écrit. Fix : temp + `Rename` (+ `Fsync`). + +#### A4 — Fichiers world-readable +- `backend/service/resources.go:149-150` : `MkdirAll 0755`, `os.Create` → 0644 + selon umask. Données user lisibles sur hôte partagé. Passer en `0700/0600`. +- Positif vérifié : pas de traversal via `ownerID/resourceID` (32-hex issus + token/serveur), `UPLOAD_DIR` = config admin. + +#### A5 — `NewID()` panic sur échec entropie +- `backend/repository/resources.go:23-29` : `panic` si `crypto/rand` échoue → + crash serveur entier. Retourner `(string,error)`. + +#### A6 — `ShareLinkGet` compare avec `==` au lieu de `errors.Is` +- `backend/handlers/share_links.go:23` (tous les autres handlers via + `writeError` utilisent `errors.Is`) : `ErrNotFound` wrappé → 500 au lieu de + 404, sur endpoint public non-authentifié → oracle 500/404. + +#### A7 — Incohérences contrat / parsing silencieux (mineurs mais réels) +- `backend/handlers/auth.go:94-96` : `ExpiresAt = Now()+TTL` seconde lecture + d'horloge, pas le `exp` du token (dérive ms). +- `backend/handlers/auth.go:90` : code `TOKEN_ERROR` non-standard. +- `backend/handlers/files.go:114-117,50-53` : 32-hex malformé → `404`, vs + `backend/handlers/devices.go:23-26` → `400 INVALID_DEVICE_ID`. +- `backend/handlers/files.go:13-22` + `backend/handlers/sync.go:43-47` : + `intParam` invalide/négatif → `fallback` silencieux ; `after` garbage → + `0` = full snapshot au lieu de 400. `Atoi` 32-bit overflow pour epoch-ms. +- `backend/handlers/middleware.go:29` : préfixe `Bearer ` case-sensitive. + +#### A8 — Sémantiques silencieuses outbox (désync grantees + fuite d'existence) +- `backend/service/sync.go:180-202` : `update_metadata` cible absente → `nil` + marqué *applied* (client croit le rename fait) vs `` + `Fsync` + `Rename`. Pas d'overwrite direct. +4. #6 : au `UpdatePhysical` : lister `Glob(id.*)` ancien, `Remove` les autres ext. Sur `Insert` fail → `Remove(destPath)`. Sur `GetFile` fail après insert → tenter cleanup, au moins log. +5. A4 : `MkdirAll 0700`, fichier `0600` (`OpenFile` + `Chmod`). Vérifier umask. +6. A16-part : `file.Filename` → `name` : `TrimSpace`, cap 255, rejeter vide/`/`/`\n`. `Content-Type` : whitelist ou fallback `application/octet-stream`. `intParam/page/pageSize` : cap + 400 si négatif (pas fallback silencieux), `q` : `MaxLen 200`. + +**Acceptance :** tests service upload : header menteur, ext vide/malicieuse, re-upload change ext → un seul fichier physique, perms 0600/0700. + +--- + +## LOT 3 — SYNC core (#3, #7, A8, A9) +**Fichiers exclusifs :** +- `backend/service/sync.go` +- `backend/repository/operations.go` +- `backend/repository/shares.go` + +**Tâches :** +1. #7 : rendre `ApplyBatch` atomique par op : `SELECT ... FOR UPDATE` ou transaction `Applied→apply→Record`. `Record` fail → retourner `applied:i` explicite, pas 500 nu. +2. #3 : `CreateLink` idempotent : `ON CONFLICT (id) DO NOTHING` + vérifier owner identique, sinon `NAME_CONFLICT`. +3. A9 : stocker `payload_hash (sha256)` dans `operations`, au replay même `(device,op)` comparer hash : différent → `INVALID_REQUEST` (pas skip silencieux). Migration `000011`. +4. A8 : uniformiser sémantiques : `update_metadata` absent → `NOT_FOUND` halt (pas no-op applied) ; `move/delete` non-owned → `NOT_FOUND` (pas applied silencieux) ; documenter choix. `create` : `ExistsOwner` + `Insert` en transaction ou `ON CONFLICT DO NOTHING` + check owner. +5. `classifySyncError` : ne plus fuir `err.Error()` brut (#8-part) : messages génériques + log interne. + +**Ne pas toucher :** `repository/resources.go` (LOT 4) — si besoin, exposer interface, pas d'édit direct. + +**Acceptance :** tests `service/sync_test.go` : replay même op, replay payload muté, create_link rejoué, move/delete grantee. + +--- + +## LOT 4 — DATA ownership + migrations (#9, #10, A10, + parent-check) +**Fichiers exclusifs :** +- `backend/repository/users.go` +- `backend/repository/resources.go` +- `backend/repository/devices.go` +- `backend/service/bootstrap.go` +- `backend/db/migrations/*` +- `backend/db/db.go` (lecture seule sauf si besoin migration) + +**Tâches :** +1. #9+A10 : `Count()` → `WHERE deleted_at IS NULL`. `UpdatePassword/MarkDeleted/GetByID` : ajouter `AND deleted_at IS NULL` + check `RowsAffected` → `ErrNotFound` si 0. +2. #10 : `000007` : supprimer `DELETE FROM resources` (backfill `owner_id` via user admin ou colonne nullable + migration douce). `000008 down` : down sans `::bigint` (ex. recréer colonne bigint + drop text, ou marquer irréversible avec message clair). +3. Parent-check atomique : `InsertFolder/InsertFile/MoveResource` : `INSERT ... SELECT` ou transaction `SELECT parent FOR SHARE → INSERT`, FK 500 → mapper `NOT_FOUND`. +4. `TouchResource/UpdateNameByID` : ajouter variantes scopées `TouchOwned(ownerID,...)`, `UpdateNameOwned(...)`, laisser anciennes en `deprecated` (LOT 3 migrera ensuite). +5. `NewID()` (A5) : retourner `(string,error)` OU `MustNewID` + `NewIDErr`. Choisir une signature, mettre à jour appelants **uniquement dans ces fichiers**. + +**Acceptance :** `go test ./repository/... ./service/... ./db/...` + test soft-deleted login/bootstrap. + +--- + +## LOT 5 — OCR + INFRA (A11, A12-part, A13, A14, #11) +**Fichiers exclusifs :** +- `backend/service/ocr.go` +- `backend/repository/ocr_jobs.go` +- `backend/ocr/*` +- `backend/cmd/server/main.go` +- `backend/service/services.go`, `move.go`, `upload.go`, `folders.go` (suppression) + +**Tâches :** +1. #11 : supprimer les 4 stubs `UserCan*` toujours-true. +2. A11 : transitions gardées : `Complete/ Fail WHERE status='processing'`, `TouchProcessing WHERE status='queued'`, check `RowsAffected`. `ResetStaleProcessing` sur horloge DB (`now() - interval`), inclure `started_at IS NULL`. Ajouter index `(status,created_at)` (migration `000012` — coordonner nom avec LOT 4 pour éviter collision : LOT 5 prend `000012`, LOT 4 prend `000011`, LOT 3 payload_hash prend `000013`). +3. A13 : `Fail` avec `err`, `Complete` vérifie `UpdateOcrText RowsAffected`, sinon `Fail`. `tesseract.go` : `context.WithTimeout` par job (ex. 120s), `LimitReader` stdout/stderr (ex. 2MB), cap pages PDF (ex. 50) + erreur si tronqué, pas `continue` silencieux. +4. A12-part : `physicalPath` : `Lstat`, `IsRegular`, `EvalSymlinks` ∈ `UPLOAD_DIR`. `OCR_LANG` : whitelist `^[a-z+]{2,20}$`. +5. A14 : `main.go` : un seul pool (réutiliser `conn` pour migrate), `defer conn.Close()`, worker OCR avec `WaitGroup` + shutdown 5s documenté. Bootstrap : retry duplicate `username_normalized` ou `ON CONFLICT DO NOTHING`. + +**Acceptance :** `go test ./ocr/... ./service/... ./repository/...` + test double-complete, stale requeue. + +--- + +## LOT 6 — CONTRACT + DEVICE (A6, A7, §1 route, devices, secret-doc) +**Fichiers exclusifs :** +- `backend/handlers/router.go` +- `backend/handlers/share_links.go` +- `backend/handlers/sync.go` +- `backend/handlers/devices.go` +- `backend/handlers/health.go` (tests seulement si besoin) +- `backend/cmd/server/router_test.go` +- `backend/pkg/api/response.go` (messages génériques seulement) + +**Tâches :** +1. §1 : réordonner `GET /files/folders` avant `GET /files/:id` + test `folders→200`, `:id=folders→404` (verrouille, même si Gin priorise statique). +2. A6 : `ShareLinkGet` : `errors.Is(err, ErrNotFound)`. +3. A7 : `ExpiresAt` : utiliser `exp` du token (retourner `Auth` ou parser), pas `Now()+TTL`. `TOKEN_ERROR` → `INTERNAL`. 32-hex malformé → `400 INVALID_REQUEST` partout (aligner `files.go` sur `devices.go`). `intParam/after` : 400 si garbage/négatif (pas fallback 0), `Atoi` 64-bit pour epoch-ms. `Bearer` : accepter `bearer` case-insensitive (option). +4. Devices : `POST /devices` : rate-limit/TODO + doc. `MarkUser` : check `RowsAffected` (device supprimé → 404). +5. `response.go` : messages génériques côté client, détail en log serveur (#8-part lot 6). + +**Acceptance :** `router_test.go` étendu + tests handlers 400/404 cohérents. + +--- + +## Ordre et dépendances + +- Démarrage immédiat possible : LOT 1, LOT 2, LOT 5, LOT 6 (aucune dépendance mutuelle). +- LOT 3 et LOT 4 se touchent via `repository/resources.go` : LOT 4 seul l'édite. LOT 3 utilise l'interface existante, migrera vers `*Owned` au tour suivant. +- Migrations : LOT 4 = `000011`, LOT 5 = `000012`, LOT 3 = `000013`. Ne pas réutiliser un numéro. +- `NewID()` signature (LOT 4) : prévenir LOT 2/LOT 3 après merge, pas avant. + +## Besoins inter-lots (ne pas éditer, juste signaler) + +- LOT 3 → LOT 4 : besoin `TouchOwned/UpdateNameOwned`, `INSERT ... SELECT` parent. +- LOT 5 → LOT 2 : `physicalPath` safe partagé après merge LOT 2. +- Tous → LOT 6 : après uniformisation 400/404, aligner messages d'erreur. diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index e7c5ec5..3109175 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -8,6 +8,7 @@ import ( "net/http" "os" "os/signal" + "sync" "syscall" "time" @@ -41,14 +42,19 @@ func main() { log.Fatalln(err) } + // Migrations AVANT l'ouverture du pool applicatif : un seul *sql.DB vit à + // la fois (MigrateDatabase ouvre/ferme sa propre connexion éphémère). + // Inter-lots : pour partager strictement le même pool, db doit exposer + // Migrate(conn *sql.DB) — fichier LOT 4 (db/db.go), non édité ici. + if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil { + log.Fatalf("migrations postgres: %v", err) + } + conn, err := db.Open(cfg.DatabaseURL) if err != nil { log.Fatalf("connexion postgres: %v", err) } - - if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil { - log.Fatalf("migrations postgres: %v", err) - } + defer conn.Close() authManager, err := auth.NewManager(cfg.AuthSecret) if err != nil { @@ -59,8 +65,19 @@ func main() { repo := repository.NewRepository(conn) // Premier admin (users vide) — refus de démarrer si identifiants absents. + // Concurrence au boot (2 instances, users vide) : le perdant de l'INSERT + // reçoit ErrNameConflict (UNIQUE username_normalized) → recompte avant de + // refuser de démarrer (retry logique, sans toucher bootstrap.go — LOT 4). if err := service.EnsureAdmin(repo, cfg.AdminUsername, cfg.AdminPassword); err != nil { - log.Fatalln(err) + if errors.Is(err, repository.ErrNameConflict) { + if n, cerr := repo.Users.Count(); cerr == nil && n > 0 { + log.Println("bootstrap admin: compte créé par une instance concurrente, démarrage poursuivi") + } else { + log.Fatalln(err) + } + } else { + log.Fatalln(err) + } } handlers.Store = service.NewResources( @@ -74,7 +91,15 @@ func main() { defer stop() // Worker OCR borné (OCR_WORKERS) : file `ocr_jobs`, hors request handlers. - go handlers.Ocr.Run(ctx, cfg.OcrWorkers) + // WaitGroup + budget d'arrêt partagé (5s, voir shutdown plus bas) : le + // worker finit le job en cours ; passé le délai, le process sort et le job + // resté `processing` sera requeue au prochain boot (ResetStaleProcessing). + var ocrWg sync.WaitGroup + ocrWg.Add(1) + go func() { + defer ocrWg.Done() + handlers.Ocr.Run(ctx, cfg.OcrWorkers) + }() log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers) srv := &http.Server{ @@ -95,5 +120,19 @@ func main() { if err := srv.Shutdown(shutdownCtx); err != nil { log.Printf("shutdown: %v", err) } + // Le worker OCR dispose du même budget de 5s : on attend la fin du job en + // cours, passé ce délai le process sort (job resté `processing` → requeue + // au prochain boot via ResetStaleProcessing, jamais de job perdu). + ocrDone := make(chan struct{}) + go func() { + ocrWg.Wait() + close(ocrDone) + }() + select { + case <-ocrDone: + log.Println("worker OCR arrêté") + case <-shutdownCtx.Done(): + log.Println("worker OCR: budget 5s écoulé, arrêt forcé (jobs `processing` requeues au prochain boot)") + } log.Println("arrêt propre") -} \ No newline at end of file +} diff --git a/backend/cmd/server/router_test.go b/backend/cmd/server/router_test.go index 6266d2e..be93659 100644 --- a/backend/cmd/server/router_test.go +++ b/backend/cmd/server/router_test.go @@ -13,11 +13,11 @@ var expectedRoutes = []string{ "GET /api/v1/shares/links/:token", "GET /api/v1/files", + "GET /api/v1/files/search", + "GET /api/v1/files/folders", "GET /api/v1/files/:id", "GET /api/v1/files/:id/ocr", "DELETE /api/v1/files/:id", - "GET /api/v1/files/search", - "GET /api/v1/files/folders", "POST /api/v1/files/upload", "GET /api/v1/users/resolve", @@ -44,3 +44,21 @@ func TestRoutesMatchClientContract(t *testing.T) { } } + +// TestStaticFileRoutesListedBeforeParam (LOT 6 §1) : verrouille que les routes +// statiques /files/search et /files/folders restent déclarées avant +// /files/:id dans le contrat. Gin priorise déjà le statique sur le paramétré +// à l'exécution, mais l'ordre source documente l'intention ("/files/folders +// ne doit jamais être avalé par FilesGet avec id="folders"). Le comportement +// réel est couvert côté handlers (folders→200, :id="folders"→404). +func TestStaticFileRoutesListedBeforeParam(t *testing.T) { + index := map[string]int{} + for i, r := range expectedRoutes { + index[r] = i + } + for _, static := range []string{"GET /api/v1/files/search", "GET /api/v1/files/folders"} { + if index[static] > index["GET /api/v1/files/:id"] { + t.Errorf("contrat: %q doit rester listé avant %q (ordre §1)", static, "GET /api/v1/files/:id") + } + } +} diff --git a/backend/config/config.go b/backend/config/config.go index 84d1fb5..ef84e51 100644 --- a/backend/config/config.go +++ b/backend/config/config.go @@ -1,8 +1,10 @@ package config import ( + "fmt" "os" "strconv" + "strings" "github.com/joho/godotenv" ) @@ -19,6 +21,21 @@ type ApplicationConfig struct { AdminPassword string } +// Sécurité AUTH_SECRET (FEEDBACK #4) : +// - valeur par défaut DEV UNIQUEMENT (jamais en production : refusée au boot +// si APP_ENV/ENV vaut "prod"/"production") ; +// - longueur minimale 32 caractères partout (dev comme prod) : le secret ne +// sert qu'à dériver la clé paseto v4-local (SHA256), un secret court ou +// deviné = tokens forgeables. +// +// NOTE inter-lots (LOT 6 « secret-doc ») : aligner backend/.env.example — +// documenter « ≥ 32 caractères, ex. `openssl rand -hex 32` » et ne plus +// suggérer une valeur copiable telle quelle. +const ( + defaultAuthSecret = "dev-secret-change-me-please-set-in-prod" + minAuthSecretLen = 32 +) + func LoadApplicationConfig() (*ApplicationConfig, error) { // .env optionnel — les défauts suffisent pour le dev local. @@ -28,16 +45,33 @@ func LoadApplicationConfig() (*ApplicationConfig, error) { if err != nil { return nil, err } + if port < 1 || port > 65535 { + return nil, fmt.Errorf("PORT hors plage 1-65535: %d", port) + } maxSize, err := getInt("MAX_FILE_SIZE_MB", 50) if err != nil { return nil, err } + if maxSize < 1 || maxSize > 1024 { + return nil, fmt.Errorf("MAX_FILE_SIZE_MB hors plage 1-1024: %d", maxSize) + } ocrWorkers, err := getInt("OCR_WORKERS", 2) if err != nil { return nil, err } + if ocrWorkers < 1 || ocrWorkers > 16 { + return nil, fmt.Errorf("OCR_WORKERS hors plage 1-16: %d", ocrWorkers) + } + + authSecret := get("AUTH_SECRET", defaultAuthSecret) + if isProduction() && (authSecret == "" || authSecret == defaultAuthSecret) { + return nil, fmt.Errorf("AUTH_SECRET doit être défini en production (pas de défaut)") + } + if len(authSecret) < minAuthSecretLen { + return nil, fmt.Errorf("AUTH_SECRET trop court (min %d caractères)", minAuthSecretLen) + } return &ApplicationConfig{ Port: port, @@ -46,13 +80,21 @@ func LoadApplicationConfig() (*ApplicationConfig, error) { MaxFileSizeMB: int64(maxSize), OcrLang: get("OCR_LANG", "fra+eng"), OcrWorkers: ocrWorkers, - AuthSecret: get("AUTH_SECRET", "dev-secret-change-me"), + AuthSecret: authSecret, AdminUsername: get("ADMIN_USERNAME", ""), AdminPassword: get("ADMIN_PASSWORD", ""), }, nil } +func isProduction() bool { + env := strings.ToLower(strings.TrimSpace(os.Getenv("APP_ENV"))) + if env == "" { + env = strings.ToLower(strings.TrimSpace(os.Getenv("ENV"))) + } + return env == "production" || env == "prod" +} + func get(name string, defaultValue string) string { value := os.Getenv(name) if value == "" { diff --git a/backend/config/config_test.go b/backend/config/config_test.go index 1bf7faf..c5866ef 100644 --- a/backend/config/config_test.go +++ b/backend/config/config_test.go @@ -10,6 +10,7 @@ func clearEnv(t *testing.T) { for _, name := range []string{ "PORT", "DATABASE_URL", "UPLOAD_DIR", "MAX_FILE_SIZE_MB", "OCR_LANG", "OCR_WORKERS", "AUTH_SECRET", "ADMIN_USERNAME", "ADMIN_PASSWORD", + "APP_ENV", "ENV", } { t.Setenv(name, "") } @@ -40,9 +41,12 @@ func TestLoadApplicationDefaults(t *testing.T) { if cfg.OcrWorkers != 2 { t.Errorf("OcrWorkers = %d, attendu 2", cfg.OcrWorkers) } - if cfg.AuthSecret != "dev-secret-change-me" { + if cfg.AuthSecret != defaultAuthSecret { t.Errorf("AuthSecret défaut inattendu: %q", cfg.AuthSecret) } + if len(cfg.AuthSecret) < minAuthSecretLen { + t.Errorf("AuthSecret défaut trop court pour le minimum %d: %q", minAuthSecretLen, cfg.AuthSecret) + } if cfg.AdminUsername != "" || cfg.AdminPassword != "" { t.Errorf("identifiants admin doivent être vides par défaut: %+v", cfg) } @@ -56,7 +60,7 @@ func TestLoadApplicationEnvOverrides(t *testing.T) { t.Setenv("UPLOAD_DIR", "/tmp/up") t.Setenv("OCR_LANG", "eng") t.Setenv("OCR_WORKERS", "4") - t.Setenv("AUTH_SECRET", "super-secret") + t.Setenv("AUTH_SECRET", "super-secret-0123456789abcdef01234567") t.Setenv("ADMIN_USERNAME", "root") t.Setenv("ADMIN_PASSWORD", "toor") @@ -65,12 +69,46 @@ func TestLoadApplicationEnvOverrides(t *testing.T) { t.Fatalf("LoadApplicationConfig: %v", err) } if cfg.Port != 9090 || cfg.MaxFileSizeMB != 120 || cfg.DatabaseURL != "postgres://u:p@host:5433/db?sslmode=disable" || - cfg.UploadDir != "/tmp/up" || cfg.OcrLang != "eng" || cfg.OcrWorkers != 4 || cfg.AuthSecret != "super-secret" || + cfg.UploadDir != "/tmp/up" || cfg.OcrLang != "eng" || cfg.OcrWorkers != 4 || cfg.AuthSecret != "super-secret-0123456789abcdef01234567" || cfg.AdminUsername != "root" || cfg.AdminPassword != "toor" { t.Errorf("overrides non appliqués: %+v", cfg) } } +func TestLoadApplicationRejectsShortSecret(t *testing.T) { + clearEnv(t) + t.Setenv("AUTH_SECRET", "too-short") + if _, err := LoadApplicationConfig(); err == nil { + t.Error("AUTH_SECRET court : attendu une erreur (min 32)") + } + + // Le défaut dev passe en dev mais est refusé en production. + clearEnv(t) + if _, err := LoadApplicationConfig(); err != nil { + t.Errorf("défaut dev en dev : inattendu %v", err) + } + for _, env := range []string{"prod", "production", "PROD"} { + clearEnv(t) + t.Setenv("APP_ENV", env) + if _, err := LoadApplicationConfig(); err == nil { + t.Errorf("défaut dev avec APP_ENV=%q : attendu une erreur", env) + } + clearEnv(t) + t.Setenv("ENV", env) + if _, err := LoadApplicationConfig(); err == nil { + t.Errorf("défaut dev avec ENV=%q : attendu une erreur", env) + } + } + + // Un secret long et explicite passe en production. + clearEnv(t) + t.Setenv("APP_ENV", "prod") + t.Setenv("AUTH_SECRET", "prod-secret-0123456789abcdef01234567") + if _, err := LoadApplicationConfig(); err != nil { + t.Errorf("secret prod valide : inattendu %v", err) + } +} + func TestLoadApplicationRejectsInvalidInt(t *testing.T) { clearEnv(t) diff --git a/backend/db/migrations/000007_resources_user_ownership.down.sql b/backend/db/migrations/000007_resources_user_ownership.down.sql index 89f374a..9bd2110 100644 --- a/backend/db/migrations/000007_resources_user_ownership.down.sql +++ b/backend/db/migrations/000007_resources_user_ownership.down.sql @@ -1,9 +1,21 @@ --- Reverse de 000007. Réversible SEULEMENT sur base vide (les ressources sont --- détruites dans les deux sens : sans device associé, il n'y a rien à --- préserver). -DELETE FROM resources; +-- Reverse de 000007. Chemin TESTS uniquement : ne jamais down en production +-- avec des données. +-- Les ressources retrouvent leur device d'origine via devices.user_id +-- (premier device trouvé en cas de multi-device — mapping non bijectif +-- assumé) ; les orphelines (user_id NULL, ou user sans device, ou valeur ne +-- correspondant à aucun device) sont détruites car owner_id est NOT NULL +-- avec FK vers devices. +UPDATE resources r + SET user_id = d.device_id + FROM devices d + WHERE d.user_id = r.user_id; + +DELETE FROM resources + WHERE user_id IS NULL + OR user_id NOT IN (SELECT device_id FROM devices); ALTER TABLE resources DROP CONSTRAINT resources_user_id_fkey; ALTER TABLE resources RENAME COLUMN user_id TO owner_id; +ALTER TABLE resources ALTER COLUMN owner_id SET NOT NULL; ALTER TABLE resources ADD CONSTRAINT resources_owner_id_fkey - FOREIGN KEY (owner_id) REFERENCES devices(device_id) ON DELETE CASCADE; \ No newline at end of file + FOREIGN KEY (owner_id) REFERENCES devices(device_id) ON DELETE CASCADE; diff --git a/backend/db/migrations/000007_resources_user_ownership.up.sql b/backend/db/migrations/000007_resources_user_ownership.up.sql index 4b8a163..8340b4b 100644 --- a/backend/db/migrations/000007_resources_user_ownership.up.sql +++ b/backend/db/migrations/000007_resources_user_ownership.up.sql @@ -1,15 +1,35 @@ -- Bascule ownership device → user (étapes 6-10 de la tranche identité). --- Destructif ASSUMÉ : à ce stade aucune release V1, la base de dev est RESET --- (DELETE trivial sur une table vide ; PAS de user marqueur). Le modele --- resources reste parfaitement identique par ailleurs. -DELETE FROM resources; +-- Migration DOUCE et non destructive (cf. #10) : AUCUNE suppression de +-- ressources (l'ancien DELETE FROM resources est supprimé). +-- Le device d'origine est résolu vers son dernier utilisateur connu +-- (devices.user_id) ; les ressources orphelines (device sans user connu ou +-- device inconnu) gardent user_id NULL — visibles par personne mais +-- conservées — et user_id reste donc NULLABLE après cette migration. ALTER TABLE resources DROP CONSTRAINT resources_owner_id_fkey; ALTER TABLE resources RENAME COLUMN owner_id TO user_id; + +-- La colonne hérite du NOT NULL de owner_id : on l'assouplit AVANT le +-- backfill pour accueillir les orphelines. +ALTER TABLE resources ALTER COLUMN user_id DROP NOT NULL; + +-- Backfill : device → dernier utilisateur connu. +UPDATE resources r + SET user_id = d.user_id + FROM devices d + WHERE r.user_id = d.device_id + AND d.user_id IS NOT NULL; + +-- Orphelines : tout ce qui ne référence toujours pas un user existant → NULL. +UPDATE resources + SET user_id = NULL + WHERE user_id IS NOT NULL + AND user_id NOT IN (SELECT id FROM users); + ALTER TABLE resources ADD CONSTRAINT resources_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE; -- Les index créés en 000003 (idx_resources_owner, idx_resources_root_name --- sur owner_id) suivent le renommage Intrinsèquement : ils portent désormais +-- sur owner_id) suivent le renommage intrinsèquement : ils portent désormais -- sur user_id. L'unicité racine devient donc « 1 nom par USER » (multi-device --- possible pour le même compte). \ No newline at end of file +-- possible pour le même compte). diff --git a/backend/db/migrations/000008_operation_uuid.down.sql b/backend/db/migrations/000008_operation_uuid.down.sql index 317964f..7ae361b 100644 --- a/backend/db/migrations/000008_operation_uuid.down.sql +++ b/backend/db/migrations/000008_operation_uuid.down.sql @@ -1,4 +1,23 @@ +-- Down de 000008 : retour operation_id TEXT 32-hex → BIGINT. +-- PERTES ASSUMÉES, chemin TESTS uniquement (migrate down complet) : seules +-- les valeurs exclusivement numériques sur ≤ 18 chiffres significatifs +-- (traces héritées paddées par le up, p.ex. '0000…0042' → 42) survivent ; +-- les vrais 32-hex client-generated (contenant a-f, ou > 18 chiffres pour +-- éviter tout overflow bigint) ne sont pas convertibles et leurs lignes +-- sont supprimées. L'ancien `USING operation_id::bigint` échouait sur ces +-- valeurs. Ne jamais down en production avec des données V1 : recréer la +-- base plutôt que `migrate down`. ALTER TABLE operations DROP CONSTRAINT operations_operation_id_hex_check; -ALTER TABLE operations - ALTER COLUMN operation_id TYPE BIGINT USING operation_id::bigint; \ No newline at end of file +ALTER TABLE operations ADD COLUMN operation_id_bigint BIGINT; + +UPDATE operations + SET operation_id_bigint = operation_id::bigint + WHERE operation_id ~ '^0*[0-9]{1,18}$'; + +DELETE FROM operations WHERE operation_id_bigint IS NULL; + +ALTER TABLE operations DROP COLUMN operation_id; +ALTER TABLE operations RENAME COLUMN operation_id_bigint TO operation_id; +ALTER TABLE operations ALTER COLUMN operation_id SET NOT NULL; +ALTER TABLE operations ADD CONSTRAINT operations_unique_per_device UNIQUE (device_id, operation_id); diff --git a/backend/db/migrations/000011_resources_owner_updated_idx.down.sql b/backend/db/migrations/000011_resources_owner_updated_idx.down.sql new file mode 100644 index 0000000..15102c2 --- /dev/null +++ b/backend/db/migrations/000011_resources_owner_updated_idx.down.sql @@ -0,0 +1 @@ +DROP INDEX IF EXISTS idx_resources_owner_updated_active; diff --git a/backend/db/migrations/000011_resources_owner_updated_idx.up.sql b/backend/db/migrations/000011_resources_owner_updated_idx.up.sql new file mode 100644 index 0000000..4fdf236 --- /dev/null +++ b/backend/db/migrations/000011_resources_owner_updated_idx.up.sql @@ -0,0 +1,7 @@ +-- LOT 4 (DATA ownership) : index snapshot delta — ListOwned filtre +-- (user_id, updated_at) WHERE deleted_at IS NULL. Numéro réservé au LOT 4 +-- par le plan TASKS_PARALLELES.md (LOT 5 = 000012, LOT 3 = 000013) : cette +-- migration bouche aussi le trou de version (golang-migrate refuse les gaps +-- au `Up` une fois 000012/000013 présentes). +CREATE INDEX IF NOT EXISTS idx_resources_owner_updated_active + ON resources(user_id, updated_at) WHERE deleted_at IS NULL; diff --git a/backend/db/migrations/000012_ocr_jobs_status_created.down.sql b/backend/db/migrations/000012_ocr_jobs_status_created.down.sql new file mode 100644 index 0000000..a6fa060 --- /dev/null +++ b/backend/db/migrations/000012_ocr_jobs_status_created.down.sql @@ -0,0 +1 @@ +DROP INDEX IF EXISTS idx_ocr_jobs_status_created; diff --git a/backend/db/migrations/000012_ocr_jobs_status_created.up.sql b/backend/db/migrations/000012_ocr_jobs_status_created.up.sql new file mode 100644 index 0000000..d7d1748 --- /dev/null +++ b/backend/db/migrations/000012_ocr_jobs_status_created.up.sql @@ -0,0 +1,4 @@ +-- Index composite pour la file OCR : ClaimNext filtre `status = 'queued'` et +-- trie par `created_at, job_id` (FIFO). L'index simple (status) de 000005 +-- est conservé (LOT 4 reste propriétaire du schéma historique). +CREATE INDEX IF NOT EXISTS idx_ocr_jobs_status_created ON ocr_jobs(status, created_at); diff --git a/backend/db/migrations/000013_operations_payload_hash.down.sql b/backend/db/migrations/000013_operations_payload_hash.down.sql new file mode 100644 index 0000000..0e4d6ad --- /dev/null +++ b/backend/db/migrations/000013_operations_payload_hash.down.sql @@ -0,0 +1,2 @@ +ALTER TABLE operations DROP CONSTRAINT IF EXISTS operations_payload_hash_hex_check; +ALTER TABLE operations DROP COLUMN IF EXISTS payload_hash; diff --git a/backend/db/migrations/000013_operations_payload_hash.up.sql b/backend/db/migrations/000013_operations_payload_hash.up.sql new file mode 100644 index 0000000..0a83e24 --- /dev/null +++ b/backend/db/migrations/000013_operations_payload_hash.up.sql @@ -0,0 +1,10 @@ +-- Trace outbox : hash du payload (A9, LOT 3). +-- Au rejeu du même (device_id, operation_id) avec un payload différent, le +-- serveur rejette en INVALID_REQUEST au lieu d'un skip silencieux. +-- Colonne NULLABLE : les traces héritées (pré-000013) restent valides ; pour +-- elles, le hash est recalculé en Go depuis le payload stocké. +ALTER TABLE operations ADD COLUMN payload_hash TEXT; + +ALTER TABLE operations + ADD CONSTRAINT operations_payload_hash_hex_check + CHECK (payload_hash IS NULL OR payload_hash ~ '^[0-9a-f]{64}$'); diff --git a/backend/db/migrations_test.go b/backend/db/migrations_test.go index 4db8641..c901368 100644 --- a/backend/db/migrations_test.go +++ b/backend/db/migrations_test.go @@ -215,6 +215,33 @@ func TestMigrationsUpDown(t *testing.T) { t.Error("FK resources.user_id → users(id) manquante après 000007") } + // --- 000007 : migration douce (#10) ---------------------------------- + // user_id NULLABLE (orphelines conservées, pas de DELETE FROM resources). + var userIDNullable string + err = conn.QueryRow(` + SELECT is_nullable FROM information_schema.columns + WHERE table_schema = 'public' AND table_name = 'resources' AND column_name = 'user_id'`).Scan(&userIDNullable) + if err != nil { + t.Fatalf("resources.user_id nullabilité: %v", err) + } + if userIDNullable != "YES" { + t.Error("resources.user_id doit être NULLABLE après 000007 (migration douce, orphelines)") + } + + // --- 000011 : index snapshot delta (LOT 4) ----------------------------- + var ownerUpdatedIdx int + err = conn.QueryRow(` + SELECT COUNT(*) FROM pg_index i + JOIN pg_class t ON t.oid = i.indrelid + WHERE t.relname = 'resources' AND i.indisvalid + AND pg_get_indexdef(i.indexrelid) LIKE '%idx_resources_owner_updated_active%'`).Scan(&ownerUpdatedIdx) + if err != nil { + t.Fatalf("000011 index: %v", err) + } + if ownerUpdatedIdx == 0 { + t.Error("index idx_resources_owner_updated_active manquant après 000011") + } + // operation_id outbox = UUID 32-hex client-generated — cf. docs/api-v1.md §6.1 var opType string err = conn.QueryRow(` diff --git a/backend/handlers/auth.go b/backend/handlers/auth.go index 668747e..10b0859 100644 --- a/backend/handlers/auth.go +++ b/backend/handlers/auth.go @@ -4,12 +4,12 @@ import ( "errors" "net/http" "strings" + "sync" "time" "github.com/gin-gonic/gin" "github.com/kazier/backend/pkg/api" - "github.com/kazier/backend/pkg/auth" "github.com/kazier/backend/pkg/passwd" "github.com/kazier/backend/repository" "github.com/kazier/backend/service" @@ -33,9 +33,55 @@ type LoginResponse struct { User LoginUserDTO `json:"user"` } +// Anti-bruteforce du login (FEEDBACK #12) : limiteur basique en mémoire, +// N tentatives / minute / IP sur POST /auth/login, placé AVANT la vérification +// argon2 (coûteuse) pour protéger le CPU. Au-delà → 429 RATE_LIMITED. +// TODO(suivi) : rate-limit distribué (ex. Redis) + métriques pour les déploiements +// multi-réplicas, et budget global coordonné avec le rate-limit POST /devices +// (LOT 6) contre le remplissage de table. +var ( + loginRateLimitPerMinute = 60 + loginRateWindow = time.Minute + loginAttemptsMu sync.Mutex + loginAttempts = map[string][]time.Time{} +) + +// OnLoginRateLimited est un hook d'observabilité appelé quand le limiteur +// rejette une tentative (nil par défaut = no-op). Les tests peuvent l'utiliser +// pour asserter le déclenchement sans dépendre du timing. +var OnLoginRateLimited func(ip string) + +// ResetLoginRateLimit vide le compteur (tests uniquement). +func ResetLoginRateLimit() { + loginAttemptsMu.Lock() + defer loginAttemptsMu.Unlock() + loginAttempts = map[string][]time.Time{} +} + +// loginRateLimited enregistre une tentative et retourne true si le quota +// IP est dépassé (fenêtre glissante). +func loginRateLimited(ip string, now time.Time) bool { + loginAttemptsMu.Lock() + defer loginAttemptsMu.Unlock() + cutoff := now.Add(-loginRateWindow) + kept := make([]time.Time, 0, len(loginAttempts[ip])+1) + for _, t := range loginAttempts[ip] { + if t.After(cutoff) { + kept = append(kept, t) + } + } + if len(kept) >= loginRateLimitPerMinute { + loginAttempts[ip] = kept + return true + } + loginAttempts[ip] = append(kept, now) + return false +} + // AuthLogin est la SEULE porte d'émission de token (V1). L'erreur est -// volontairement indistinguable entre « username inconnu » et « mauvais mot de -// passe » — même code, même message, délai égalisé via passwd.VerifyTimedEqual. +// volontairement indistinguable entre « username inconnu », « mauvais mot de +// passe » et « device non enregistré » — même code 401, même message, délai +// égalisé via passwd.VerifyTimedEqual (anti-oracle, FEEDBACK #12). func AuthLogin(c *gin.Context) { if Store == nil || Store.Repository == nil || Auth == nil { api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") @@ -51,12 +97,24 @@ func AuthLogin(c *gin.Context) { api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "username, password and device_id are required") return } + if !deviceIDPattern.MatchString(req.DeviceID) { + api.Error(c, http.StatusBadRequest, "INVALID_DEVICE_ID", "device_id must be 32 lowercase hex chars") + return + } + + if loginRateLimited(c.ClientIP(), time.Now()) { + if OnLoginRateLimited != nil { + OnLoginRateLimited(c.ClientIP()) + } + api.Error(c, http.StatusTooManyRequests, "RATE_LIMITED", "too many login attempts, retry later") + return + } normalized := service.NormalizeUsername(req.Username) user, userErr := Store.Repository.Users.GetByUsernameNormalized(normalized) // Même durée de traitement que le compte existe ou non (username inconnu => - // stored vide → vérification contre dummyHash). + // stored vide → vérification contre dummyHash aléatoire par boot). stored := "" if userErr == nil && user != nil { stored = user.PasswordHash @@ -69,6 +127,12 @@ func AuthLogin(c *gin.Context) { api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not verify credentials") return } + // A1 : ne jamais déréférencer user si inconnu — même si Verify (par + // extraordinaire) réussissait, on reste en 401. + if userErr != nil || user == nil { + api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials") + return + } exists, err := Store.Repository.Devices.Exists(req.DeviceID) if err != nil { @@ -76,24 +140,31 @@ func AuthLogin(c *gin.Context) { return } if !exists { - api.Error(c, http.StatusBadRequest, "INVALID_DEVICE_ID", "device not registered") + // Volontairement indistinguable d'un mauvais password (anti-oracle). + api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials") return } if err := Store.Repository.Devices.MarkUser(req.DeviceID, user.ID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + // Course : device supprimé entre Exists et MarkUser → même 401 + // indistinguable, jamais de token pour un device fantôme. + api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials") + return + } api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update device") return } - token, err := Auth.Issue(user.ID, req.DeviceID) + token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID) if err != nil { - api.Error(c, http.StatusInternalServerError, "TOKEN_ERROR", "could not issue token") + api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token") return } api.OK(c, LoginResponse{ Token: token, - ExpiresAt: time.Now().Add(auth.TokenTTL).UnixMilli(), + ExpiresAt: expiresAt.UnixMilli(), User: LoginUserDTO{ ID: user.ID, Username: user.Username, diff --git a/backend/handlers/auth_test.go b/backend/handlers/auth_test.go index b24c1ef..9f266e4 100644 --- a/backend/handlers/auth_test.go +++ b/backend/handlers/auth_test.go @@ -42,6 +42,8 @@ func setTestStore(t *testing.T) *repository.Repository { func setTestAuth(t *testing.T) { t.Helper() Auth, _ = auth.NewManager("test-secret") + ResetLoginRateLimit() + ResetDevicesRateLimit() t.Cleanup(func() { Auth = nil }) } @@ -202,6 +204,71 @@ func TestAuthLoginWrongCredentials(t *testing.T) { } } +// TestAuthLoginUnknownUserRegisteredDevice — régression A1 : un username +// inconnu ne doit JAMAIS déréférencer user (panic → 500 via Gin recovery). +// Le device est enregistré pour isoler la branche « user inconnu » : on attend +// 401 UNAUTHORIZED, corps identique au cas « mauvais mot de passe ». +func TestAuthLoginUnknownUserRegisteredDevice(t *testing.T) { + setTestAuth(t) + repo := setTestStore(t) + createAdmin(t, repo, "admin", authTestPassword) + r := newTestRouterForAuth() + + doAuth(t, r, http.MethodPost, "/api/v1/devices", "", `{"deviceId":"`+authTestDevice+`"}`) + + badPassword := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"wrong-password","device_id":"`+authTestDevice+`"}`) + if badPassword.Code != 401 { + t.Fatalf("mauvais mot de passe: status %d body %s", badPassword.Code, badPassword.Body.String()) + } + + ghost := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"ghost","password":"wrong-password","device_id":"`+authTestDevice+`"}`) + if ghost.Code != 401 { + t.Fatalf("username inconnu: status %d body %s (attendu 401, jamais 500)", ghost.Code, ghost.Body.String()) + } + if !strings.Contains(ghost.Body.String(), "UNAUTHORIZED") { + t.Errorf("code attendu UNAUTHORIZED, got %s", ghost.Body.String()) + } + if ghost.Body.String() != badPassword.Body.String() { + t.Errorf("réponses distinguables (sécurité):\n%q\n%q", ghost.Body.String(), badPassword.Body.String()) + } +} + +func TestAuthLoginRateLimited(t *testing.T) { + setTestAuth(t) + repo := setTestStore(t) + createAdmin(t, repo, "admin", authTestPassword) + r := newTestRouterForAuth() + doAuth(t, r, http.MethodPost, "/api/v1/devices", "", `{"deviceId":"`+authTestDevice+`"}`) + + oldLimit := loginRateLimitPerMinute + loginRateLimitPerMinute = 2 + hookCalls := 0 + oldHook := OnLoginRateLimited + OnLoginRateLimited = func(ip string) { hookCalls++ } + t.Cleanup(func() { + loginRateLimitPerMinute = oldLimit + OnLoginRateLimited = oldHook + ResetLoginRateLimit() + }) + + badBody := `{"username":"admin","password":"wrong-password","device_id":"` + authTestDevice + `"}` + for i := 0; i < 2; i++ { + if rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", badBody); rec.Code != 401 { + t.Fatalf("tentative %d: status %d, attendu 401", i+1, rec.Code) + } + } + rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", badBody) + if rec.Code != 429 { + t.Fatalf("quota dépassé: status %d body %s, attendu 429", rec.Code, rec.Body.String()) + } + if !strings.Contains(rec.Body.String(), "RATE_LIMITED") { + t.Errorf("code attendu RATE_LIMITED, got %s", rec.Body.String()) + } + if hookCalls != 1 { + t.Errorf("OnLoginRateLimited appelé %d fois, attendu 1", hookCalls) + } +} + func TestAuthLoginUnregisteredDevice(t *testing.T) { setTestAuth(t) repo := setTestStore(t) @@ -209,11 +276,11 @@ func TestAuthLoginUnregisteredDevice(t *testing.T) { r := newTestRouterForAuth() rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"`+authTestPassword+`","device_id":"`+authTestDevice+`"}`) - if rec.Code != 400 { + if rec.Code != 401 { t.Fatalf("device non enregistré: status %d body %s", rec.Code, rec.Body.String()) } - if !strings.Contains(rec.Body.String(), "INVALID_DEVICE_ID") { - t.Errorf("code attendu INVALID_DEVICE_ID, got %s", rec.Body.String()) + if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") { + t.Errorf("code attendu UNAUTHORIZED (anti-oracle), got %s", rec.Body.String()) } } diff --git a/backend/handlers/devices.go b/backend/handlers/devices.go index 04d9518..2048f62 100644 --- a/backend/handlers/devices.go +++ b/backend/handlers/devices.go @@ -1,7 +1,10 @@ package handlers import ( + "net/http" "regexp" + "sync" + "time" "github.com/gin-gonic/gin" "github.com/kazier/backend/pkg/api" @@ -9,12 +12,65 @@ import ( var deviceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`) +// Anti-remplissage de POST /devices (FEEDBACK §moyenne) : l'endpoint est +// public et bon marché (un upsert), donc anonyme et floodable. Limiteur +// basique en mémoire, N enregistrements / minute / IP → 429 RATE_LIMITED. +// Budget large (300) : les usages légitimes (1 device = 1 appel) sont très +// loin du seuil ; la protection vise le flood massif, un WAF frontal fera +// le reste en prod multi-réplicas. +// TODO(suivi) : rate-limit distribué + budget global coordonné avec le +// rate-limit login (cf. handlers/auth.go). +var ( + devicesRateLimitPerMinute = 300 + devicesRateWindow = time.Minute + devicesAttemptsMu sync.Mutex + devicesAttempts = map[string][]time.Time{} +) + +// OnDevicesRateLimited est un hook d'observabilité (nil = no-op). +var OnDevicesRateLimited func(ip string) + +// ResetDevicesRateLimit vide le compteur (tests uniquement). +func ResetDevicesRateLimit() { + devicesAttemptsMu.Lock() + defer devicesAttemptsMu.Unlock() + devicesAttempts = map[string][]time.Time{} +} + +func devicesRateLimited(ip string, now time.Time) bool { + devicesAttemptsMu.Lock() + defer devicesAttemptsMu.Unlock() + cutoff := now.Add(-devicesRateWindow) + kept := make([]time.Time, 0, len(devicesAttempts[ip])+1) + for _, t := range devicesAttempts[ip] { + if t.After(cutoff) { + kept = append(kept, t) + } + } + if len(kept) >= devicesRateLimitPerMinute { + devicesAttempts[ip] = kept + return true + } + devicesAttempts[ip] = append(kept, now) + return false +} + type DeviceRegisterRequest struct { DeviceID string `json:"deviceId"` } func DevicesRegister(c *gin.Context) { - + // POST /devices est PUBLIC (sans token) : le device s'enregistre pour + // exister, puis le client appelle POST /auth/login pour obtenir son + // token user-first (cf. docs/api-v1.md §2). + // + // NOTE rate-limit : limiteur en mémoire ci-dessus (300/min/IP, 429 + // au-delà). Si le budget doit changer, ajuster + // devicesRateLimitPerMinute + documenter dans docs/api-v1.md. + // + // NOTE MarkUser : repository.Devices.MarkUser retourne ErrNotFound quand + // RowsAffected == 0 (device supprimé entre Exists et UPDATE) ; le login + // mappe ce cas en 401 indistinguable (cf. handlers/auth.go). var req DeviceRegisterRequest if err := c.ShouldBindJSON(&req); err != nil || req.DeviceID == "" { api.Error(c, 400, "INVALID_REQUEST", "missing deviceId") @@ -25,6 +81,14 @@ func DevicesRegister(c *gin.Context) { return } + if devicesRateLimited(c.ClientIP(), time.Now()) { + if OnDevicesRateLimited != nil { + OnDevicesRateLimited(c.ClientIP()) + } + api.Error(c, http.StatusTooManyRequests, "RATE_LIMITED", "too many device registrations, retry later") + return + } + if Store == nil || Store.Repository == nil { api.Error(c, 503, "SERVICE_UNAVAILABLE", "backend not initialized") return diff --git a/backend/handlers/files.go b/backend/handlers/files.go index a309a7a..32d89ef 100644 --- a/backend/handlers/files.go +++ b/backend/handlers/files.go @@ -8,6 +8,7 @@ import ( "github.com/gin-gonic/gin" "github.com/kazier/backend/pkg/api" + "github.com/kazier/backend/service" ) func intParam(value string, fallback int) int { @@ -21,18 +22,53 @@ func intParam(value string, fallback int) int { return parsed } +// parsePageParams valide page/pageSize (400 si garbage, cf. FEEDBACK A7/A16) +// au lieu du fallback silencieux. Cap pageSize 200 et offset 100000. +func parsePageParams(c *gin.Context) (page, pageSize int, ok bool) { + page = 1 + pageSize = 50 + if v := c.Query("page"); v != "" { + p, err := strconv.Atoi(v) + if err != nil || p < 1 { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `page`") + return 0, 0, false + } + page = p + } + if v := c.Query("pageSize"); v != "" { + ps, err := strconv.Atoi(v) + if err != nil || ps < 1 { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `pageSize`") + return 0, 0, false + } + pageSize = ps + } + if pageSize > 200 { + pageSize = 200 + } + if (page-1)*pageSize > 100000 { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "page offset too large") + return 0, 0, false + } + return page, pageSize, true +} + func FilesList(c *gin.Context) { if Store == nil { api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") return } userID := c.GetString(UserIDKey) - page := intParam(c.Query("page"), 1) - pageSize := intParam(c.Query("pageSize"), 50) - if pageSize > 200 { - pageSize = 200 + page, pageSize, ok := parsePageParams(c) + if !ok { + return } - files, total, err := Store.ListFiles(userID, c.Query("folderId"), page, pageSize, c.Query("sort"), c.Query("order")) + folderID := c.Query("folderId") + if folderID != "" && !deviceIDPattern.MatchString(folderID) { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `folderId`") + return + } + files, total, err := Store.ListFiles(userID, folderID, page, pageSize, c.Query("sort"), c.Query("order")) if err != nil { writeError(c, err) return @@ -108,6 +144,10 @@ func FilesUpload(c *gin.Context) { } userID := c.GetString(UserIDKey) folderID := c.PostForm("folderId") + if folderID != "" && !deviceIDPattern.MatchString(folderID) { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `folderId`") + return + } // resourceId optionnel : cible un fichier déjà connu (metadata-only de // l'outbox) pour lui attacher ses octets physiques (ex. OCR serveur). resourceID := c.PostForm("resourceId") @@ -134,6 +174,12 @@ func FilesUpload(c *gin.Context) { dto, err := Store.Upload(userID, file, folderID, resourceID) if err != nil { + // Nom/extension rejetés côté service (TrimSpace, cap 255, + // anti-slash/retour-ligne, cf. FEEDBACK A16) → 400, jamais 500. + if errors.Is(err, service.ErrInvalidUpload) { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid file name") + return + } writeError(c, err) return } @@ -165,10 +211,13 @@ func FilesSearch(c *gin.Context) { api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "missing required query param `q`") return } - page := intParam(c.Query("page"), 1) - pageSize := intParam(c.Query("pageSize"), 50) - if pageSize > 200 { - pageSize = 200 + if len(q) > 200 { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `q` too long (max 200)") + return + } + page, pageSize, ok := parsePageParams(c) + if !ok { + return } files, total, err := Store.SearchFiles(userID, q, page, pageSize) if err != nil { diff --git a/backend/handlers/files_test.go b/backend/handlers/files_test.go index 88dad0d..ff8f1ec 100644 --- a/backend/handlers/files_test.go +++ b/backend/handlers/files_test.go @@ -73,6 +73,7 @@ func setup(t *testing.T) (*gin.Engine, *service.Resources, *repository.Repositor } handlers.Auth = manager handlers.Store = store + handlers.ResetDevicesRateLimit() gin.SetMode(gin.TestMode) r := gin.New() @@ -517,12 +518,12 @@ func TestFilesPaginationDefaultsAndClamp(t *testing.T) { t.Errorf("clamp pageSize: %+v", env.Meta) } - // Paramètres invalides → défauts (page=1, pageSize=50) + // Paramètres invalides → 400 (plus de fallback silencieux, cf. A16). rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=0&pageSize=-5", token, nil, "") - env = expectOK(t, rec, "invalid-params") - if env.Meta == nil || env.Meta.Page != 1 || env.Meta.PageSize != 50 { - t.Errorf("defauts page/pageSize: %+v", env.Meta) - } + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "negative-params") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=abc&pageSize=zz", token, nil, "") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "garbage-params") // sort/order inconnus → pas d'erreur (défaut created_at desc) rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?sort=zzz&order=up&pageSize=10", token, nil, "") @@ -633,3 +634,55 @@ func TestFilesGetOcrOwnerShareAndScoping(t *testing.T) { rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/ocr", ownerToken, nil, "") expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "ocr-invalid-id") } + +func TestFilesUploadRejectsBadFilename(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "bn"), "badname-test-password", device) + + // Body multipart construit à la main : filename brut, NON neutralisé par + // le writer stdlib (qui basename/encode de son côté). Le serveur doit + // rejeter en 400, jamais 500 (cf. A16). + rawUpload := func(filename string) *httptest.ResponseRecorder { + t.Helper() + boundary := "testboundary123" + body := "--" + boundary + "\r\n" + + "Content-Disposition: form-data; name=\"file\"; filename=\"" + filename + "\"\r\n" + + "Content-Type: application/octet-stream\r\n\r\n" + + "hi\r\n" + + "--" + boundary + "--\r\n" + rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/files/upload", token, []byte(body), "multipart/form-data; boundary="+boundary) + return rec + } + + rec := rawUpload("../../evil.txt") + // La stdlib Go basename déjà côté lecture (défense en profondeur côté + // service via sanitizeFileName, testé en unitaire + backslash) : le nom + // stocké est "evil.txt" et aucun chemin ne s'échappe (destPath dérivé + // uniquement de IDs 32-hex + extension sanitizée). + env := expectOK(t, rec, "upload-traversal-name") + var uploaded fileDTO + if err := json.Unmarshal(env.Data, &uploaded); err != nil { + t.Fatalf("upload-traversal-name: unmarshal: %v", err) + } + if uploaded.Name != "evil.txt" { + t.Errorf("nom traversal neutralisé attendu \"evil.txt\", got %q", uploaded.Name) + } + + // Backslash : préservé par la stdlib → rejet service 400, jamais 500. + rec = rawUpload(`bad\name.txt`) + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "upload-backslash-name") +} + +func TestSearchQTooLong(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ql"), "search-test-password", device) + + long := make([]byte, 201) + for i := range long { + long[i] = 'a' + } + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-q-too-long") +} diff --git a/backend/handlers/lot6_contract_test.go b/backend/handlers/lot6_contract_test.go new file mode 100644 index 0000000..e0d6197 --- /dev/null +++ b/backend/handlers/lot6_contract_test.go @@ -0,0 +1,126 @@ +package handlers_test + +// Tests contrat LOT 6 : ordre statique/param (§1), validation 32-hex et +// curseur `after` stricts (A7), validation POST /devices. + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/gin-gonic/gin" + + "github.com/kazier/backend/handlers" + "github.com/kazier/backend/repository" +) + +// TestFoldersRouteServesListNotParam (§1) : GET /files/folders via le routeur +// atteint FoldersList (200), jamais FilesGet avec id="folders". +func TestFoldersRouteServesListNotParam(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "l6f"), "lot6-test-password", device) + + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/folders", token, nil, "") + expectOK(t, rec, "folders-static-wins") +} + +// TestFilesGetRejectsFoldersLiteral (§1) : si le routeur tombait un jour sur +// FilesGet avec id="folders", le garde 32-hex répond 404 (jamais 200, jamais +// 500). Appel direct du handler pour forcer le cas paramétré. +func TestFilesGetRejectsFoldersLiteral(t *testing.T) { + setup(t) + + gin.SetMode(gin.TestMode) + w := httptest.NewRecorder() + c, _ := gin.CreateTestContext(w) + c.Request = httptest.NewRequest(http.MethodGet, "/api/v1/files/folders", nil) + c.Params = gin.Params{{Key: "id", Value: "folders"}} + c.Set(handlers.UserIDKey, "00000000000000000000000000000001") + + handlers.FilesGet(c) + + expectError(t, w, http.StatusNotFound, "NOT_FOUND", "files-get-folders-literal") +} + +// TestShareLinkMalformedToken400 (A7) : token non 32-hex → 400 +// INVALID_REQUEST (pas 404). +func TestShareLinkMalformedToken400(t *testing.T) { + r, _, _ := setup(t) + for _, path := range []string{ + "/api/v1/shares/links/NOT-HEX", + "/api/v1/shares/links/xyz", + "/api/v1/shares/links/ABCDEF0123456789ABCDEF0123456789", // majuscules rejetées + } { + rec, _ := doRequest(t, r, http.MethodGet, path, "", nil, "") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "share-malformed-token") + } +} + +// TestSyncPermissionsAfterValidation (A7) : garbage/négatif → 400, epoch-ms +// 64-bit accepté. +func TestSyncPermissionsAfterValidation(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "l6a"), "lot6-test-password", device) + + for _, path := range []string{ + "/api/v1/sync/permissions?after=garbage", + "/api/v1/sync/permissions?after=-5", + "/api/v1/sync/permissions?after=12.5", + "/api/v1/sync/permissions?after=", + } { + // "?after=" vide = curseur absent → 200 (seul le dernier cas). + rec, _ := doRequest(t, r, http.MethodGet, path, token, nil, "") + if path == "/api/v1/sync/permissions?after=" { + expectOK(t, rec, "after-empty-ok") + } else { + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "after-invalid:"+path) + } + } + + // Epoch-ms au-delà de 2^31 (64-bit) → 200, pas de troncation/rejet. + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/sync/permissions?after=9999999999999", token, nil, "") + expectOK(t, rec, "after-64bit-ok") +} + +// TestDevicesRegisterValidation : 32-hex malformé/absent → 400, valide → 200. +func TestDevicesRegisterValidation(t *testing.T) { + r, _, _ := setup(t) + + rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":"NOT-HEX"}`), "application/json") + expectError(t, rec, http.StatusBadRequest, "INVALID_DEVICE_ID", "devices-malformed") + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{}`), "application/json") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "devices-missing") + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json") + expectOK(t, rec, "devices-valid") +} + +// TestDevicesRegisterRateLimited : flood → 429 RATE_LIMITED (budget 300/min/IP, +// cf. handlers/devices.go). Les requêtes invalides ne consomment pas le budget. +func TestDevicesRegisterRateLimited(t *testing.T) { + r, _, _ := setup(t) + + hookCalls := 0 + handlers.OnDevicesRateLimited = func(ip string) { hookCalls++ } + t.Cleanup(func() { handlers.OnDevicesRateLimited = nil }) + + // Les requêtes invalides (avant le compteur) ne doivent pas déclencher. + rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":"BAD"}`), "application/json") + expectError(t, rec, http.StatusBadRequest, "INVALID_DEVICE_ID", "devices-ratelimit-invalid") + + for i := 0; i < 300; i++ { + rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json") + if rec.Code != http.StatusOK { + t.Fatalf("enregistrement %d: attendu 200, got %d body=%s", i, rec.Code, rec.Body.String()) + } + } + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json") + expectError(t, rec, http.StatusTooManyRequests, "RATE_LIMITED", "devices-ratelimited") + if hookCalls != 1 { + t.Errorf("OnDevicesRateLimited appelé %d fois, attendu 1", hookCalls) + } +} diff --git a/backend/handlers/middleware.go b/backend/handlers/middleware.go index 454ca05..20cc19e 100644 --- a/backend/handlers/middleware.go +++ b/backend/handlers/middleware.go @@ -2,6 +2,7 @@ package handlers import ( "errors" + "log" "net/http" "strings" @@ -19,6 +20,15 @@ const ( // Auth issues/verifies device bearer tokens; set once at startup (cmd/server). var Auth *auth.Manager +// EnforceDeviceExists durcit RequireAuth (FEEDBACK A15) : quand true, le +// device_id porté par le token doit exister en base (POST /devices), sinon la +// requête est rejetée en 401 et le rejet est loggé côté serveur. +// Défaut false (V1) : le device reste un claim porté NON autorisant — +// l'autorisation vient du subject user_id + existence du compte. Passer à true +// coûte une lecture DB par requête authentifiée ; ne pas activer sans mesurer +// sur les routes à fort trafic (snapshot/sync). +var EnforceDeviceExists = false + // RequireAuth authenticates the bearer paseto token. Le subject (user_id) // autorise — c'est la clé de scoping de toutes les ressources ; device_id est // porté (non autorisant) pour l'idempotence outbox et les jobs OCR. Le compte @@ -26,7 +36,13 @@ var Auth *auth.Manager func RequireAuth(c *gin.Context) { header := c.GetHeader("Authorization") - token, found := strings.CutPrefix(header, "Bearer ") + token := "" + found := false + // Préfixe Bearer insensible à la casse (cf. FEEDBACK A7). + if len(header) > 7 && strings.EqualFold(header[:7], "Bearer ") { + token = strings.TrimSpace(header[7:]) + found = token != "" + } if Auth == nil || !found || token == "" { api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "missing bearer token") @@ -57,6 +73,22 @@ func RequireAuth(c *gin.Context) { } } + if EnforceDeviceExists && Store != nil && Store.Repository != nil { + // Verify garantit déjà le format 32-hex : Exists reçoit une entrée saine. + exists, err := Store.Repository.Devices.Exists(identity.DeviceID) + if err != nil { + api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not check device") + c.Abort() + return + } + if !exists { + log.Printf("auth: token d'un device inconnu rejeté (user=%s device=%s)", identity.UserID, identity.DeviceID) + api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "unknown device") + c.Abort() + return + } + } + c.Set(UserIDKey, identity.UserID) c.Set(DeviceIDKey, identity.DeviceID) c.Next() diff --git a/backend/handlers/middleware_test.go b/backend/handlers/middleware_test.go new file mode 100644 index 0000000..33adcf9 --- /dev/null +++ b/backend/handlers/middleware_test.go @@ -0,0 +1,60 @@ +package handlers + +import ( + "net/http" + "strings" + "testing" +) + +const middlewareUnknownDevice = "ffffffffffffffffffffffffffffffff" + +// Par défaut (EnforceDeviceExists=false), un token portant un device inconnu +// passe le middleware : le device est un claim non autorisant (V1). +func TestRequireAuthUnknownDevicePassesByDefault(t *testing.T) { + setTestAuth(t) + repo := setTestStore(t) + userID := createAdmin(t, repo, "admin", authTestPassword) + r := newTestRouterForAuth() + + if EnforceDeviceExists { + t.Fatal("EnforceDeviceExists devrait être false par défaut") + } + + signed, err := Auth.Issue(userID, middlewareUnknownDevice) + if err != nil { + t.Fatalf("issue: %v", err) + } + rec := doAuth(t, r, http.MethodGet, "/api/v1/files", signed, "") + if rec.Code == 401 { + t.Fatalf("device inconnu rejeté alors que EnforceDeviceExists=false: %s", rec.Body.String()) + } +} + +// Avec EnforceDeviceExists=true, le device inconnu est rejeté en 401 (et +// loggé), le device enregistré passe. +func TestRequireAuthEnforceDeviceExists(t *testing.T) { + setTestAuth(t) + repo := setTestStore(t) + userID := createAdmin(t, repo, "admin", authTestPassword) + _ = repo.Devices.Upsert(authTestDevice) + r := newTestRouterForAuth() + + old := EnforceDeviceExists + EnforceDeviceExists = true + t.Cleanup(func() { EnforceDeviceExists = old }) + + unknown, _ := Auth.Issue(userID, middlewareUnknownDevice) + rec := doAuth(t, r, http.MethodGet, "/api/v1/files", unknown, "") + if rec.Code != 401 { + t.Fatalf("device inconnu: status %d body %s, attendu 401", rec.Code, rec.Body.String()) + } + if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") { + t.Errorf("code attendu UNAUTHORIZED, got %s", rec.Body.String()) + } + + known, _ := Auth.Issue(userID, authTestDevice) + rec = doAuth(t, r, http.MethodGet, "/api/v1/files", known, "") + if rec.Code == 401 { + t.Fatalf("device enregistré rejeté avec EnforceDeviceExists=true: %s", rec.Body.String()) + } +} diff --git a/backend/handlers/ocr_test.go b/backend/handlers/ocr_test.go index 4395410..4fc6faa 100644 --- a/backend/handlers/ocr_test.go +++ b/backend/handlers/ocr_test.go @@ -40,6 +40,7 @@ func setupOcr(t *testing.T) (*gin.Engine, string, *repository.Repository) { manager, _ := auth.NewManager("test-secret") handlers.Auth = manager handlers.Store = store + handlers.ResetDevicesRateLimit() handlers.Ocr = service.NewOcr(repo, uploadDir, "fra+eng", stubEngine{text: "HELLO OCR"}) // Worker OCR borné — le handler n'enfile plus que le job, le traitement diff --git a/backend/handlers/router.go b/backend/handlers/router.go index 9e78cb6..f463089 100644 --- a/backend/handlers/router.go +++ b/backend/handlers/router.go @@ -25,11 +25,15 @@ func RegisterRoutes(r *gin.Engine) { protected.Use(RequireAuth) { protected.GET("/files", FilesList) + // Verrou LOT 6 §1 : les routes statiques restent déclarées AVANT + // /files/:id (Gin priorise déjà le statique sur le paramétré, mais + // l'ordre source verrouille l'intention : /files/folders ne doit + // jamais être avalé par FilesGet avec id="folders"). protected.GET("/files/search", FilesSearch) + protected.GET("/files/folders", FoldersList) protected.GET("/files/:id", FilesGet) protected.GET("/files/:id/ocr", FilesGetOcr) protected.DELETE("/files/:id", FilesDelete) - protected.GET("/files/folders", FoldersList) protected.POST("/files/upload", FilesUpload) protected.GET("/users/resolve", ResolveUser) diff --git a/backend/handlers/share_links.go b/backend/handlers/share_links.go index 0b61b31..1bc7acc 100644 --- a/backend/handlers/share_links.go +++ b/backend/handlers/share_links.go @@ -1,6 +1,7 @@ package handlers import ( + "errors" "net/http" "github.com/gin-gonic/gin" @@ -18,9 +19,18 @@ func ShareLinkGet(c *gin.Context) { return } token := c.Param("token") + // Contrat V1 : les tokens de lien sont du 32-hex (cf. docs/api-v1.md). + // Malformé → 400 INVALID_REQUEST (pas 404 : ce n'est pas « introuvable », + // c'est « requête invalide »). deviceIDPattern (devices.go, même package) + // exprime exactement ce format. + if !deviceIDPattern.MatchString(token) { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "malformed link token") + return + } link, err := Store.Repository.Shares.GetPublicLink(token) if err != nil { - if err == repository.ErrNotFound { + // A6 : errors.Is (pas ==) — le repo peut envelopper ErrNotFound. + if errors.Is(err, repository.ErrNotFound) { api.Error(c, http.StatusNotFound, "NOT_FOUND", "link not found or revoked") return } diff --git a/backend/handlers/store.go b/backend/handlers/store.go index d4ae4be..62225f1 100644 --- a/backend/handlers/store.go +++ b/backend/handlers/store.go @@ -2,6 +2,7 @@ package handlers import ( "errors" + "log" "github.com/gin-gonic/gin" "github.com/kazier/backend/pkg/api" @@ -28,6 +29,13 @@ func writeError(c *gin.Context, err error) { case errors.Is(err, service.ErrFileTooLarge): api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size") default: - api.Error(c, 500, "INTERNAL", err.Error()) + // Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf. + // FEEDBACK #8) : message générique, détail au log serveur. + path := "" + if c.Request != nil && c.Request.URL != nil { + path = c.Request.URL.Path + } + log.Printf("internal error: path=%s err=%v", path, err) + api.Error(c, 500, "INTERNAL", "internal error") } } diff --git a/backend/handlers/sync.go b/backend/handlers/sync.go index e4bb708..9cde188 100644 --- a/backend/handlers/sync.go +++ b/backend/handlers/sync.go @@ -2,6 +2,7 @@ package handlers import ( "net/http" + "strconv" "github.com/gin-gonic/gin" @@ -9,10 +10,37 @@ import ( "github.com/kazier/backend/service" ) +// parseAfterMs parses the `after` delta cursor of GET /sync/permissions : +// epoch-millis, 64-bit (les curseurs dépassent 2^31). Chaîne vide → 0 (sync +// complet). Garbage ou négatif → ok=false : le handler répond 400 +// INVALID_REQUEST, jamais de repli silencieux vers 0 (un curseur malformé +// pris pour « sync complet » masquerait une désynchro client). +// NOTE : intParam (files.go, LOT 2) garde son repli-défaut historique pour la +// pagination ; la validation stricte 400 des pages relève du LOT 2 +// (inter-lots). +func parseAfterMs(raw string) (int64, bool) { + if raw == "" { + return 0, true + } + ms, err := strconv.ParseInt(raw, 10, 64) + if err != nil || ms < 0 { + return 0, false + } + return ms, true +} + type syncOpsRequest struct { Operations []service.SyncOperation `json:"operations"` } +// Bornes anti-DoS de POST /sync/ops (FEEDBACK §moyenne) : le client envoie des +// batchs de 20 ; au-delà de 100 ops ou 1 MiB de body → rejet explicite, jamais +// d'OOM sur batch géant. +const ( + maxSyncOpsBodyBytes = 1 << 20 + maxSyncOpsPerBatch = 100 +) + func SyncOpsPush(c *gin.Context) { if Store == nil { api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") @@ -20,11 +48,16 @@ func SyncOpsPush(c *gin.Context) { } userID := c.GetString(UserIDKey) + c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxSyncOpsBodyBytes) var req syncOpsRequest if err := c.ShouldBindJSON(&req); err != nil { api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body") return } + if len(req.Operations) > maxSyncOpsPerBatch { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "too many operations in batch (max 100)") + return + } result, err := Store.ApplyBatch(userID, c.GetString(DeviceIDKey), req.Operations) if err != nil { @@ -40,10 +73,10 @@ func SyncPermissionsGet(c *gin.Context) { return } userID := c.GetString(UserIDKey) - after := c.Query("after") - var afterMs int64 - if after != "" { - afterMs = int64(intParam(after, 0)) + afterMs, ok := parseAfterMs(c.Query("after")) + if !ok { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `after` cursor, must be non-negative epoch-millis") + return } perms, err := Store.Snapshot(userID, afterMs) if err != nil { diff --git a/backend/handlers/sync_test.go b/backend/handlers/sync_test.go index 5d5e618..5eded3e 100644 --- a/backend/handlers/sync_test.go +++ b/backend/handlers/sync_test.go @@ -254,6 +254,20 @@ func TestSyncOpsLargeBatchAccepted(t *testing.T) { } } +func TestSyncOpsBatchTooLargeRejected(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "sx"), "sync-test-password", device) + + ops := make([]map[string]any, 0, 101) + for i := 0; i < 101; i++ { + ops = append(ops, op(repository.NewID(), repository.NewID(), "create_resource", "file", map[string]any{"name": fmt.Sprintf("g%03d.txt", i)})) + } + + rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/sync/ops", token, syncOpsBody(ops), "application/json") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "sync-batch-too-large") +} + func TestSyncOpsStopsAtFirstNonIdempotentFailure(t *testing.T) { r, _, repo := setup(t) device := repository.NewID() diff --git a/backend/ocr/tesseract.go b/backend/ocr/tesseract.go index 041e272..f3c99e1 100644 --- a/backend/ocr/tesseract.go +++ b/backend/ocr/tesseract.go @@ -4,13 +4,42 @@ import ( "bytes" "context" "errors" + "fmt" "os/exec" "path/filepath" "strings" + "time" "github.com/ledongthuc/pdf" ) +const ( + // tesseractTimeout : budget max par job (A13) — Tesseract ne doit jamais + // bloquer un worker indéfiniment (image pathologique). + tesseractTimeout = 120 * time.Second + // outputCap : plafond stdout/stderr capturés (A13, 2 Mo) — un document + // hostile ne doit pas faire exploser la RAM du worker. + outputCap = 2 << 20 + // maxPDFPages : plafond de pages lues (A13) — au-delà, erreur explicite + // (pas de troncature silencieuse). + maxPDFPages = 50 +) + +// validTesseractLang : whitelist `^[a-z+]{2,20}$` (A12, défense en profondeur +// — le point d'entrée normal est service.normalizeOcrLang). Évite toute +// injection via `tesseract -l` (espaces, `;`, options `--...`). +func validTesseractLang(lang string) bool { + if len(lang) < 2 || len(lang) > 20 { + return false + } + for _, r := range lang { + if (r < 'a' || r > 'z') && r != '+' { + return false + } + } + return true +} + // TesseractEngine runs the `tesseract` binary in a subprocess. // Images are OCR'd directly; PDFs have their text layer extracted first // (scanned PDFs → empty text, no rendering pipeline in V1). @@ -18,20 +47,55 @@ type TesseractEngine struct{} func NewTesseract() *TesseractEngine { return &TesseractEngine{} } -// ExtractText implements Engine. +// ExtractText implements Engine. Chaque job est borné par tesseractTimeout +// (contexte dérivé, annulé en fin d'appel). func (t *TesseractEngine) ExtractText(ctx context.Context, filePath, lang string) (string, error) { + ctx, cancel := context.WithTimeout(ctx, tesseractTimeout) + defer cancel() if strings.ToLower(filepath.Ext(filePath)) == ".pdf" { - return extractPDFText(filePath) + return extractPDFText(ctx, filePath) } return runTesseract(ctx, filePath, lang) } +// cappedBuffer borne un flux capturé à `limit` octets et signale la +// troncature (erreur explicite côté appelant, pas de coupe silencieuse). +type cappedBuffer struct { + buf bytes.Buffer + limit int + truncated bool +} + +func (c *cappedBuffer) Write(p []byte) (int, error) { + remaining := c.limit - c.buf.Len() + if remaining <= 0 { + c.truncated = true + return len(p), nil // déverse : le process ne bloque pas sur un pipe plein + } + if len(p) > remaining { + c.truncated = true + p = p[:remaining] + } + return c.buf.Write(p) +} + +func (c *cappedBuffer) String() string { return c.buf.String() } + func runTesseract(ctx context.Context, filePath, lang string) (string, error) { + // Défense en profondeur (A12) : même si l'appelant ne passe pas par + // service.normalizeOcrLang, `-l` ne reçoit jamais de métacaractères. + if !validTesseractLang(lang) { + return "", fmt.Errorf("tesseract: langue %q invalide", lang) + } cmd := exec.CommandContext(ctx, "tesseract", filePath, "stdout", "-l", lang) - var stdout, stderr bytes.Buffer - cmd.Stdout = &stdout - cmd.Stderr = &stderr + stdout := &cappedBuffer{limit: outputCap} + stderr := &cappedBuffer{limit: outputCap} + cmd.Stdout = stdout + cmd.Stderr = stderr if err := cmd.Run(); err != nil { + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + return "", fmt.Errorf("tesseract: délai dépassé (%s): %w", tesseractTimeout, ctx.Err()) + } if errors.Is(ctx.Err(), context.Canceled) { return "", ctx.Err() } @@ -41,24 +105,37 @@ func runTesseract(ctx context.Context, filePath, lang string) (string, error) { } return "", errors.New("tesseract: " + msg) } + if stdout.truncated { + return "", fmt.Errorf("tesseract: sortie tronquée (> %d octets)", outputCap) + } + // stderr tronqué avec un run OK : le texte est complet, mais le diagnostic + // est perdu — on l'accepte sans échouer le job. return strings.TrimSpace(stdout.String()), nil } -func extractPDFText(filePath string) (string, error) { +func extractPDFText(ctx context.Context, filePath string) (string, error) { f, r, err := pdf.Open(filePath) if err != nil { return "", errors.New("pdf: " + err.Error()) } defer f.Close() + if n := r.NumPage(); n > maxPDFPages { + return "", fmt.Errorf("pdf: %d pages > plafond %d (tronquer = perdre du texte)", n, maxPDFPages) + } var builder strings.Builder for i := 1; i <= r.NumPage(); i++ { + select { + case <-ctx.Done(): + return "", fmt.Errorf("pdf: annulé page %d: %w", i, ctx.Err()) + default: + } p := r.Page(i) if p.V.IsNull() { - continue + return "", fmt.Errorf("pdf: page %d nulle", i) } plain, err := p.GetPlainText(nil) if err != nil { - continue + return "", fmt.Errorf("pdf: page %d illisible: %w", i, err) } builder.WriteString(plain) builder.WriteString("\n") diff --git a/backend/ocr/tesseract_test.go b/backend/ocr/tesseract_test.go new file mode 100644 index 0000000..5d456c6 --- /dev/null +++ b/backend/ocr/tesseract_test.go @@ -0,0 +1,52 @@ +package ocr + +import ( + "strings" + "testing" +) + +func TestValidTesseractLang(t *testing.T) { + valid := []string{"fra", "eng", "fra+eng", "de", "abcdefghijklmnopqrst"} // 20 chars + for _, lang := range valid { + if !validTesseractLang(lang) { + t.Errorf("langue %q : attendue valide", lang) + } + } + invalid := []string{ + "", "e", "fra;rm -rf", "fra eng", "fra+eng --psm", + "FRA", "fra-eng", "fra/eng", "abcdefghijklmnopqrstu", // 21 chars + "fra\neng", "-l fra", + } + for _, lang := range invalid { + if validTesseractLang(lang) { + t.Errorf("langue %q : attendue invalide (injection -l)", lang) + } + } +} + +func TestCappedBufferTruncation(t *testing.T) { + c := &cappedBuffer{limit: 8} + if _, err := c.Write([]byte("12345678")); err != nil { + t.Fatalf("write: %v", err) + } + if c.truncated { + t.Error("8 octets pour limite 8 : ne doit pas être tronqué") + } + if _, err := c.Write([]byte("9")); err != nil { + t.Fatalf("write: %v", err) + } + if !c.truncated { + t.Error("9 octets pour limite 8 : doit être marqué tronqué") + } + if c.String() != "12345678" { + t.Errorf("contenu = %q, attendu %q", c.String(), "12345678") + } + // Écriture massive d'un coup : bornée, jamais plus que `limit`. + big := &cappedBuffer{limit: 4} + if _, err := big.Write([]byte(strings.Repeat("x", 1<<20))); err != nil { + t.Fatalf("write: %v", err) + } + if !big.truncated || len(big.String()) != 4 { + t.Errorf("écriture 1 Mo limite 4 : tronqué=%v len=%d", big.truncated, len(big.String())) + } +} diff --git a/backend/pkg/api/response.go b/backend/pkg/api/response.go index 7083b3f..a3df467 100644 --- a/backend/pkg/api/response.go +++ b/backend/pkg/api/response.go @@ -1,6 +1,10 @@ package api -import "github.com/gin-gonic/gin" +import ( + "log" + + "github.com/gin-gonic/gin" +) const NotImplementedCode = "NOT_IMPLEMENTED" @@ -22,6 +26,14 @@ func OKList(c *gin.Context, data any, page, pageSize, total int) { } func Error(c *gin.Context, status int, code, message string) { + // LOT 6 §5 : le client ne reçoit que l'enveloppe générique (code + + // message sans détail interne — jamais de err.Error() brut). Le détail + // va au log serveur pour le diagnostic. + path := "" + if c.Request != nil && c.Request.URL != nil { + path = c.Request.URL.Path + } + log.Printf("api error: status=%d code=%s message=%s path=%s", status, code, message, path) c.JSON(status, gin.H{ "error": gin.H{"code": code, "message": message}, }) diff --git a/backend/pkg/auth/auth.go b/backend/pkg/auth/auth.go index 528d6a3..b8e784d 100644 --- a/backend/pkg/auth/auth.go +++ b/backend/pkg/auth/auth.go @@ -3,6 +3,7 @@ package auth import ( "crypto/sha256" "errors" + "regexp" "time" "aidanwoods.dev/go-paseto" @@ -14,6 +15,8 @@ const TokenTTL = 7 * 24 * time.Hour var ErrInvalidToken = errors.New("invalid token") +var hex32Pattern = regexp.MustCompile(`^[0-9a-f]{32}$`) + // Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant) // et le device (claim secondaire, porté mais NON autorisant seul). type Identity struct { @@ -39,29 +42,40 @@ func NewManager(secret string) (*Manager, error) { // Issue émet un token lié à un utilisateur ET à un device. func (m *Manager) Issue(userID, deviceID string) (string, error) { + token, _, err := m.IssueWithExpiry(userID, deviceID) + return token, err +} + +// IssueWithExpiry émet un token et retourne son expiration réelle (le `exp` +// embarqué). Les appelants doivent exposer expiresAt, jamais le recalculer +// via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7). +func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, error) { now := time.Now() + expiresAt := now.Add(TokenTTL) token := paseto.NewToken() token.SetIssuedAt(now) token.SetNotBefore(now) - token.SetExpiration(now.Add(TokenTTL)) + token.SetExpiration(expiresAt) token.SetSubject(userID) // v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable). token.SetString("device_id", deviceID) - return token.V4Encrypt(m.key, nil), nil + return token.V4Encrypt(m.key, nil), expiresAt, nil } // Verify décode et contrôle le token, retourne l'identité (user + device). +// Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) — rejet +// sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK. func (m *Manager) Verify(signed string) (Identity, error) { parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) if err != nil { return Identity{}, ErrInvalidToken } userID, err := parsed.GetSubject() - if err != nil || userID == "" { + if err != nil || !hex32Pattern.MatchString(userID) { return Identity{}, ErrInvalidToken } deviceID, err := parsed.GetString("device_id") - if err != nil || deviceID == "" { + if err != nil || !hex32Pattern.MatchString(deviceID) { return Identity{}, ErrInvalidToken } return Identity{UserID: userID, DeviceID: deviceID}, nil diff --git a/backend/pkg/auth/auth_test.go b/backend/pkg/auth/auth_test.go index d5e81eb..0f6edc2 100644 --- a/backend/pkg/auth/auth_test.go +++ b/backend/pkg/auth/auth_test.go @@ -96,6 +96,44 @@ func TestVerifyRequiresDeviceClaim(t *testing.T) { } } +func TestVerifyRejectsNonHex32IDs(t *testing.T) { + m, _ := NewManager("test-secret") + + issueWith := func(userID, deviceID string) string { + token := paseto.NewToken() + now := time.Now() + token.SetIssuedAt(now) + token.SetNotBefore(now) + token.SetExpiration(now.Add(TokenTTL)) + token.SetSubject(userID) + token.SetString("device_id", deviceID) + return token.V4Encrypt(m.key, nil) + } + + cases := map[string][2]string{ + "subject vide": {"", testDeviceID}, + "subject non-hex": {"not-hex-at-all-!!!!!!!!!!!!!!!!", testDeviceID}, + "subject majuscules": {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", testDeviceID}, + "subject trop court": {"abc123", testDeviceID}, + "device vide": {testUserID, ""}, + "device non-hex": {testUserID, "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"}, + "device majuscules": {testUserID, "0123456789ABCDEF0123456789ABCDEF"}, + "device trop long": {testUserID, testDeviceID + "00"}, + "device avec tirets": {testUserID, "01234567-89ab-cdef-0123-456789abcdef"}, + } + for name, ids := range cases { + signed := issueWith(ids[0], ids[1]) + if _, err := m.Verify(signed); err == nil { + t.Errorf("%s: token accepté (user=%q device=%q), attendu rejet", name, ids[0], ids[1]) + } + } + + // Sanity : les IDs 32-hex valides passent toujours. + if _, err := m.Verify(issueWith(testUserID, testDeviceID)); err != nil { + t.Errorf("IDs valides rejetés: %v", err) + } +} + func TestIssueSetsExpiration(t *testing.T) { m, _ := NewManager("test-secret") before := time.Now() @@ -118,3 +156,25 @@ func TestIssueSetsExpiration(t *testing.T) { t.Errorf("expiration = %v, attendu ≈ now+%v (fenêtre [%v, %v])", exp, TokenTTL, lower, upper) } } + +func TestIssueWithExpiryMatchesTokenExp(t *testing.T) { + m, _ := NewManager("test-secret") + signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID) + if err != nil { + t.Fatalf("IssueWithExpiry: %v", err) + } + parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) + if err != nil { + t.Fatalf("parse: %v", err) + } + exp, err := parsed.GetExpiration() + if err != nil { + t.Fatalf("GetExpiration: %v", err) + } + // L'expiresAt retourné doit être le exp embarqué (pas un Now()+TTL + // recalculé — cf. FEEDBACK A7). Comparaison à la seconde : le token + // sérialise sans lecture monotonique ni sous-seconde. + if exp.Unix() != expiresAt.Unix() { + t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp) + } +} diff --git a/backend/pkg/passwd/passwd.go b/backend/pkg/passwd/passwd.go index 94979b9..65ef683 100644 --- a/backend/pkg/passwd/passwd.go +++ b/backend/pkg/passwd/passwd.go @@ -30,12 +30,17 @@ var ( ErrMalformed = errors.New("malformed password hash") ) -// dummyHash est un hash argon2id valide d'un mot de passe aléatoire fixe. -// Il sert d'égalisation de timing : quand le username est inconnu, on vérifie -// quand même contre ce hash pour que le délai de réponse soit identique à un -// « mauvais mot de passe ». +// dummyHash est un hash argon2id valide d'un mot de passe aléatoire généré +// au boot. Il sert d'égalisation de timing : quand le username est inconnu, +// on vérifie quand même contre ce hash pour que le délai de réponse soit +// identique à un « mauvais mot de passe ». Aléatoire par boot pour éviter +// toute préimage hardcodée (cf. FEEDBACK A1). var dummyHash = func() string { - h, err := Hash("kazier-constantime-dummy") + raw := make([]byte, 32) + if _, err := rand.Read(raw); err != nil { + panic(fmt.Sprintf("passwd: entropie dummy indisponible: %v", err)) + } + h, err := Hash(string(raw)) if err != nil { panic(fmt.Sprintf("passwd: impossible de pré-hacher le dummy: %v", err)) } @@ -75,6 +80,18 @@ func Verify(password, stored string) error { if _, err := fmt.Sscanf(fields[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil { return ErrMalformed } + // Caps anti-DoS : un hash stocké compromis ne doit pas provoquer un + // OOM/CPU arbitraire au prochain login (cf. FEEDBACK §moyenne). + const ( + maxMemory = 256 * 1024 // 256 MiB + maxTime = 10 + maxThreads = 8 + maxKeyLen = 128 + maxSaltLen = 128 + ) + if memory <= 0 || memory > maxMemory || timeCost <= 0 || timeCost > maxTime || threads <= 0 || threads > maxThreads { + return ErrMalformed + } salt, err := base64.RawStdEncoding.DecodeString(fields[4]) if err != nil { @@ -84,6 +101,9 @@ func Verify(password, stored string) error { if err != nil { return ErrMalformed } + if len(salt) == 0 || len(salt) > maxSaltLen || len(want) == 0 || len(want) > maxKeyLen { + return ErrMalformed + } got := argon2.IDKey([]byte(password), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want))) if subtle.ConstantTimeCompare(got, want) != 1 { diff --git a/backend/repository/devices.go b/backend/repository/devices.go index 332f5ad..c2409ed 100644 --- a/backend/repository/devices.go +++ b/backend/repository/devices.go @@ -33,10 +33,22 @@ func (d *Devices) Exists(deviceID string) (bool, error) { // MarkUser mémorise le dernier utilisateur connecté sur ce device (INFORMATIF, // jamais autorisant) et rafraîchit last_seen_at. Appelé au login. +// Device absent → ErrNotFound (le handler distingue la course +// Exists→MarkUser au lieu d'émettre un token pour un device fantôme). func (d *Devices) MarkUser(deviceID, userID string) error { - _, err := d.DB.Exec( + result, err := d.DB.Exec( `UPDATE devices SET user_id = $2, last_seen_at = NOW() WHERE device_id = $1`, deviceID, userID, ) - return err + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + return nil } diff --git a/backend/repository/devices_test.go b/backend/repository/devices_test.go index 106ce8c..5c9a632 100644 --- a/backend/repository/devices_test.go +++ b/backend/repository/devices_test.go @@ -1,6 +1,7 @@ package repository import ( + "errors" "testing" "github.com/kazier/backend/dbtest" @@ -71,3 +72,12 @@ func TestDevicesMarkUser(t *testing.T) { t.Errorf("user_id mémorisé = %q, attendu %q", storedUser, userID) } } + +func TestDevicesMarkUserUnknownDevice(t *testing.T) { + d := newTestDevices(t) + // Device jamais enregistré → ErrNotFound (pas de UPDATE silencieux à + // 0 ligne) : le login mappe ce cas en 401 au lieu d'émettre un token. + if err := d.MarkUser(NewID(), NewID()); !errors.Is(err, ErrNotFound) { + t.Errorf("MarkUser device inconnu: attendu ErrNotFound, got %v", err) + } +} diff --git a/backend/repository/ocr_jobs.go b/backend/repository/ocr_jobs.go index 9e990dd..a0ca38d 100644 --- a/backend/repository/ocr_jobs.go +++ b/backend/repository/ocr_jobs.go @@ -22,6 +22,12 @@ var ErrJobNotFound = errors.New("ocr job not found") // ErrNoQueuedJobs marks an OCR queue drained (no job to claim). var ErrNoQueuedJobs = errors.New("no queued ocr jobs") +// ErrJobStateConflict marks a guarded transition attempted from an +// unexpected state (double Complete, Fail of a non-processing job, +// TouchProcessing of a non-queued job). Terminal states are sticky: +// a second transition never overwrites the first. +var ErrJobStateConflict = errors.New("ocr job state conflict") + type OcrJobs struct{ DB *sql.DB } func (o *OcrJobs) Create(jobID, deviceID, fileID string) error { @@ -58,12 +64,22 @@ func (o *OcrJobs) Get(deviceID, jobID string) (OcrJobRow, error) { } func (o *OcrJobs) TouchProcessing(deviceID, jobID string) error { - _, err := o.DB.Exec( + res, err := o.DB.Exec( `UPDATE ocr_jobs SET status = 'processing', started_at = NOW() WHERE job_id = $1 AND device_id = $2 AND status = 'queued'`, jobID, deviceID, ) - return err + if err != nil { + return err + } + affected, err := res.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrJobStateConflict + } + return nil } // ClaimNext atomically picks the oldest queued job (FIFO) and moves it to @@ -96,12 +112,15 @@ func (o *OcrJobs) ClaimNext() (OcrJobRow, error) { // ResetStaleProcessing requeues jobs stuck in `processing` (worker crash / // processus redémarré) et plus vieux que `olderThan`. Retourne le nb de jobs -// requeued. +// requeued. La comparaison utilise l'horloge DB (NOW(), pas time.Now() du +// process) pour rester correcte même si les horloges divergent. Les jobs sans +// `started_at` (claim sans timestamp, anomalie) sont aussi requeued. func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) { res, err := o.DB.Exec( `UPDATE ocr_jobs SET status = 'queued', started_at = NULL - WHERE status = 'processing' AND started_at < $1`, - time.Now().Add(-olderThan), + WHERE status = 'processing' + AND (started_at IS NULL OR started_at < NOW() - ($1::bigint * INTERVAL '1 millisecond'))`, + olderThan.Milliseconds(), ) if err != nil { return 0, err @@ -110,19 +129,39 @@ func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) { } func (o *OcrJobs) Complete(deviceID, jobID, text string) error { - _, err := o.DB.Exec( + res, err := o.DB.Exec( `UPDATE ocr_jobs SET status = 'done', text = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW() - WHERE job_id = $1 AND device_id = $2`, + WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`, jobID, deviceID, text, ) - return err + if err != nil { + return err + } + affected, err := res.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrJobStateConflict + } + return nil } func (o *OcrJobs) Fail(deviceID, jobID, message string) error { - _, err := o.DB.Exec( + res, err := o.DB.Exec( `UPDATE ocr_jobs SET status = 'failed', error = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW() - WHERE job_id = $1 AND device_id = $2`, + WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`, jobID, deviceID, message, ) - return err + if err != nil { + return err + } + affected, err := res.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrJobStateConflict + } + return nil } diff --git a/backend/repository/ocr_jobs_test.go b/backend/repository/ocr_jobs_test.go index 5ad9134..5d31ba0 100644 --- a/backend/repository/ocr_jobs_test.go +++ b/backend/repository/ocr_jobs_test.go @@ -67,6 +67,10 @@ func TestOcrJobsFail(t *testing.T) { if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil { t.Fatalf("create: %v", err) } + // Fail n'est valide que depuis `processing` (transition gardée). + if err := repo.OcrJobs.TouchProcessing(deviceID, jobID); err != nil { + t.Fatalf("touch processing: %v", err) + } if err := repo.OcrJobs.Fail(deviceID, jobID, "tesseract exploded"); err != nil { t.Fatalf("fail: %v", err) } @@ -76,6 +80,71 @@ func TestOcrJobsFail(t *testing.T) { } } +func TestOcrJobsGuardedTransitions(t *testing.T) { + repo, _, deviceID, fileID := seedOcrJobFixture(t) + newJob := func(t *testing.T) string { + t.Helper() + jobID := NewID() + if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil { + t.Fatalf("create: %v", err) + } + return jobID + } + + // Fail depuis `queued` → conflit, le job reste queued. + queued := newJob(t) + if err := repo.OcrJobs.Fail(deviceID, queued, "boom"); !errors.Is(err, ErrJobStateConflict) { + t.Errorf("fail depuis queued : attendu ErrJobStateConflict, got %v", err) + } + if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Status != "queued" { + t.Errorf("fail depuis queued : status = %q, attendu queued", row.Status) + } + + // Complete depuis `queued` → conflit. + if err := repo.OcrJobs.Complete(deviceID, queued, "x"); !errors.Is(err, ErrJobStateConflict) { + t.Errorf("complete depuis queued : attendu ErrJobStateConflict, got %v", err) + } + + // Double TouchProcessing → conflit. + if err := repo.OcrJobs.TouchProcessing(deviceID, queued); err != nil { + t.Fatalf("touch processing: %v", err) + } + if err := repo.OcrJobs.TouchProcessing(deviceID, queued); !errors.Is(err, ErrJobStateConflict) { + t.Errorf("double touch : attendu ErrJobStateConflict, got %v", err) + } + + // Double Complete → le premier gagne, le second est un conflit. + if err := repo.OcrJobs.Complete(deviceID, queued, "FIRST"); err != nil { + t.Fatalf("complete: %v", err) + } + if err := repo.OcrJobs.Complete(deviceID, queued, "SECOND"); !errors.Is(err, ErrJobStateConflict) { + t.Errorf("double complete : attendu ErrJobStateConflict, got %v", err) + } + if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Text == nil || *row.Text != "FIRST" { + t.Errorf("double complete : texte = %+v, attendu FIRST", row.Text) + } + + // Fail après Complete → conflit, le statut `done` est collant. + if err := repo.OcrJobs.Fail(deviceID, queued, "late"); !errors.Is(err, ErrJobStateConflict) { + t.Errorf("fail après done : attendu ErrJobStateConflict, got %v", err) + } + if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Status != "done" { + t.Errorf("fail après done : status = %q, attendu done", row.Status) + } + + // Complete après Fail → conflit. + failed := newJob(t) + if err := repo.OcrJobs.TouchProcessing(deviceID, failed); err != nil { + t.Fatalf("touch processing: %v", err) + } + if err := repo.OcrJobs.Fail(deviceID, failed, "boom"); err != nil { + t.Fatalf("fail: %v", err) + } + if err := repo.OcrJobs.Complete(deviceID, failed, "late"); !errors.Is(err, ErrJobStateConflict) { + t.Errorf("complete après failed : attendu ErrJobStateConflict, got %v", err) + } +} + func TestOcrJobsGetScopedByDevice(t *testing.T) { repo, _, deviceID, fileID := seedOcrJobFixture(t) jobID := NewID() @@ -179,3 +248,24 @@ func TestOcrJobsResetStaleProcessing(t *testing.T) { t.Errorf("status après reset = %q, attendu queued", row.Status) } } + +func TestOcrJobsResetStaleProcessingNullStartedAt(t *testing.T) { + repo, _, deviceID, fileID := seedOcrJobFixture(t) + jobID := NewID() + if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil { + t.Fatalf("create: %v", err) + } + // Job passé en `processing` sans `started_at` (anomalie de claim) → stale. + if _, err := repo.OcrJobs.DB.Exec( + `UPDATE ocr_jobs SET status = 'processing', started_at = NULL WHERE job_id = $1`, jobID); err != nil { + t.Fatalf("forcer processing sans started_at: %v", err) + } + if n, err := repo.OcrJobs.ResetStaleProcessing(time.Minute); err != nil { + t.Fatalf("reset: %v", err) + } else if n != 1 { + t.Errorf("reset started_at NULL : attendu 1, got %d", n) + } + if row, _ := repo.OcrJobs.Get(deviceID, jobID); row.Status != "queued" { + t.Errorf("status après reset = %q, attendu queued", row.Status) + } +} diff --git a/backend/repository/operations.go b/backend/repository/operations.go index cfe9a36..8c27b07 100644 --- a/backend/repository/operations.go +++ b/backend/repository/operations.go @@ -1,7 +1,9 @@ package repository import ( + "crypto/sha256" "database/sql" + "encoding/hex" "encoding/json" "errors" "regexp" @@ -16,9 +18,26 @@ type Operations struct { DB *sql.DB } +// Statuts de la trace outbox (CHECK status IN ('applied','failed'), 000004). +// 'failed' = brouillon claimé pas encore confirmé (ou apply en échec) ; +// 'applied' = effet durable confirmé. +const ( + OpStatusApplied = "applied" + OpStatusFailed = "failed" +) + // ErrInvalidOperationID is returned when operation_id is not 32 lowercase hex. var ErrInvalidOperationID = errors.New("operation_id must be 32 lowercase hex chars") +// ErrInvalidPayload is returned when the trace payload is not valid JSON. +// Le service le mappe en INVALID_REQUEST (faute client, message statique sûr). +var ErrInvalidPayload = errors.New("invalid payload JSON") + +// ErrPayloadMismatch is returned when an operation is replayed under the same +// (device_id, operation_id) with a different payload (cf. A9). The replay +// must halt in INVALID_REQUEST, never skip silently. +var ErrPayloadMismatch = errors.New("operation replayed with different payload") + // Applied reports whether the operation was already processed for this device. func (o *Operations) Applied(deviceID, operationID string) (bool, error) { var exists int @@ -32,20 +51,157 @@ func (o *Operations) Applied(deviceID, operationID string) (bool, error) { return err == nil, err } +// StoredOp is the persisted trace of an applied operation (replay compare). +type StoredOp struct { + OpType string + ResourceID string + Payload []byte + Status string + PayloadHash string // "" = trace héritée pré-000013 (hash recalculé depuis Payload) +} + +// Get returns the stored trace for (device, operation), or sql.ErrNoRows. +func (o *Operations) Get(deviceID, operationID string) (StoredOp, error) { + var op StoredOp + var resourceID sql.NullString + var payloadHash sql.NullString + var payload []byte + err := o.DB.QueryRow( + `SELECT op_type, resource_id, COALESCE(payload::text, '{}'), status, payload_hash + FROM operations WHERE device_id = $1 AND operation_id = $2`, + deviceID, operationID, + ).Scan(&op.OpType, &resourceID, &payload, &op.Status, &payloadHash) + if err != nil { + return StoredOp{}, err + } + if resourceID.Valid { + op.ResourceID = resourceID.String + } + if payloadHash.Valid { + op.PayloadHash = payloadHash.String + } + op.Payload = payload + return op, nil +} + +// Claim atomically takes ownership of an operation slot for this device +// (#7 : sérialisation des batches concurrents sur la contrainte +// UNIQUE(device_id, operation_id)). Premier appelant → claimed=true, la ligne +// est insérée en status='failed' (brouillon) avec le hash du payload ; le +// perdant du conflit (claimed=false) suit le chemin rejeu (comparer via Get). +// Après apply réussi, l'appelant promeut la ligne via MarkApplied ; en cas +// d'échec d'apply, la ligne reste 'failed' (rejouable à payload identique). +func (o *Operations) Claim(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) (bool, error) { + if !operationIDPattern.MatchString(operationID) { + return false, ErrInvalidOperationID + } + if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) { + return false, ErrInvalidPayload + } + var refTypeValue any + if refType != "" { + refTypeValue = refType + } + res, err := o.DB.Exec( + `INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'failed') + ON CONFLICT (device_id, operation_id) DO NOTHING`, + deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload), + ) + if err != nil { + return false, err + } + affected, err := res.RowsAffected() + if err != nil { + return false, err + } + return affected == 1, nil +} + +// MarkApplied promotes a claimed ('failed') trace row to 'applied' once the +// operation effect is durable. Best-effort : l'échec est remonté pour que le +// batch retourne applied:i explicite (rejouable, pas 500 nu). +func (o *Operations) MarkApplied(deviceID, operationID string) error { + res, err := o.DB.Exec( + `UPDATE operations SET status = 'applied' + WHERE device_id = $1 AND operation_id = $2 AND status = 'failed'`, + deviceID, operationID, + ) + if err != nil { + return err + } + affected, err := res.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + // Déjà promue (rejeu concurrent) ou ligne absente : pas d'erreur, + // l'idempotence est portée par la contrainte d'unicité. + return nil + } + return nil +} + +// MatchesReplay reports whether an incoming operation matches the stored +// trace: same op type, same resource, same canonical payload hash. Legacy +// rows (payload_hash NULL, pré-000013) comparent le hash recalculé depuis le +// payload stocké. Mismatch → ErrPayloadMismatch (wrappable via errors.Is). +func (op StoredOp) MatchesReplay(opType, resourceID string, payload []byte) error { + if op.OpType != opType || op.ResourceID != resourceID { + return ErrPayloadMismatch + } + want := CanonicalPayloadHash(payload) + got := op.PayloadHash + if got == "" { + got = CanonicalPayloadHash(op.Payload) + } + if got != want { + return ErrPayloadMismatch + } + return nil +} + +// CanonicalPayloadHash is sha256-hex of the canonical payload form: empty / +// "null" → {}, sinon round-trip JSON (clés triées, espaces neutralisés) pour +// que deux sérialisations du même objet donnent le même hash. +func CanonicalPayloadHash(payload []byte) string { + sum := sha256.Sum256(canonicalPayloadBytes(payload)) + return hex.EncodeToString(sum[:]) +} + +func canonicalPayloadBytes(payload []byte) []byte { + if len(payload) == 0 || string(payload) == "null" { + return []byte(`{}`) + } + var v any + if err := json.Unmarshal(payload, &v); err != nil { + return []byte(`{}`) + } + out, err := json.Marshal(v) + if err != nil { + return []byte(`{}`) + } + return out +} + // Record stores an applied operation trace (idempotent on replay). +// Le hash canonique du payload est persisté (000013, cf. A9) ; status='applied'. func (o *Operations) Record(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) error { if !operationIDPattern.MatchString(operationID) { return ErrInvalidOperationID } + if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) { + return ErrInvalidPayload + } var refTypeValue any if refType != "" { refTypeValue = refType } _, err := o.DB.Exec( - `INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload) - VALUES ($1, $2, $3, $4, $5, $6, $7) + `INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'applied') ON CONFLICT (device_id, operation_id) DO NOTHING`, - deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), + deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload), ) return err } @@ -62,7 +218,9 @@ func jsonBytes(payload []byte) any { return []byte(`{}`) } if !json.Valid(payload) { - return []byte(`{}`) + // Trace infidèle refusée (cf. A15) : l'appelant doit rejeter en amont ; + // ici on ne normalise plus silencieusement vers {}. + return nil } return payload } diff --git a/backend/repository/operations_test.go b/backend/repository/operations_test.go index c7c786d..739cd4f 100644 --- a/backend/repository/operations_test.go +++ b/backend/repository/operations_test.go @@ -1,7 +1,6 @@ package repository import ( - "encoding/json" "errors" "testing" @@ -66,7 +65,7 @@ func TestOperationsRecordRejectsInvalidOperationID(t *testing.T) { } } -func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) { +func TestOperationsRecordRejectsInvalidPayload(t *testing.T) { o, devices := newTestOperations(t) deviceID := NewID() if err := devices.Upsert(deviceID); err != nil { @@ -74,20 +73,128 @@ func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) { } opID := NewID() - // Un payload non-JSON ne doit pas faire échouer la trace (jsonBytes → {}). - if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err != nil { - t.Fatalf("record: %v", err) + // Un payload non-JSON est refusé (pas de normalisation silencieuse vers {}) : + // l'appelant (service) doit rejeter en amont en INVALID_REQUEST. + if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err == nil { + t.Error("payload non-JSON : erreur attendue, got nil") } + if applied, _ := o.Applied(deviceID, opID); applied { + t.Error("record refusé : l'op ne doit pas être tracée") + } +} + +func TestOperationsRecordStoresPayloadHash(t *testing.T) { + o, devices := newTestOperations(t) + deviceID := NewID() + if err := devices.Upsert(deviceID); err != nil { + t.Fatalf("register device: %v", err) + } + + opID := NewID() + payload := []byte(`{"name":"x"}`) + if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), payload); err != nil { + t.Fatalf("record: %v", err) + } + stored, err := o.Get(deviceID, opID) + if err != nil { + t.Fatalf("get: %v", err) + } + if stored.Status != OpStatusApplied { + t.Errorf("status = %q, attendu %q", stored.Status, OpStatusApplied) + } + want := CanonicalPayloadHash(payload) + if stored.PayloadHash != want { + t.Errorf("payload_hash = %q, attendu %q", stored.PayloadHash, want) + } + if len(stored.PayloadHash) != 64 { + t.Errorf("payload_hash attendu 64-hex, got %q", stored.PayloadHash) + } +} + +func TestOperationsClaimAndMarkApplied(t *testing.T) { + o, devices := newTestOperations(t) + deviceID := NewID() + if err := devices.Upsert(deviceID); err != nil { + t.Fatalf("register device: %v", err) + } - var stored string - if err := o.DB.QueryRow(`SELECT payload::text FROM operations WHERE device_id = $1 AND operation_id = $2`, deviceID, opID).Scan(&stored); err != nil { - t.Fatalf("read payload: %v", err) + opID := NewID() + payload := []byte(`{"name":"x"}`) + // Premier claim → pris. + claimed, err := o.Claim(deviceID, opID, "create_resource", "resource", nil, NewID(), payload) + if err != nil || !claimed { + t.Fatalf("claim 1: claimed=%v err=%v", claimed, err) + } + // La trace brouillon est en status failed (pas encore confirmée). + stored, err := o.Get(deviceID, opID) + if err != nil { + t.Fatalf("get: %v", err) + } + if stored.Status != OpStatusFailed { + t.Errorf("status après claim = %q, attendu %q", stored.Status, OpStatusFailed) + } + // Second claim (batch concurrent) → perdu, chemin rejeu. + claimed, err = o.Claim(deviceID, opID, "create_resource", "resource", nil, NewID(), payload) + if err != nil || claimed { + t.Fatalf("claim 2: claimed=%v err=%v", claimed, err) + } + // Promotion après apply réussi. + if err := o.MarkApplied(deviceID, opID); err != nil { + t.Fatalf("mark applied: %v", err) + } + stored, err = o.Get(deviceID, opID) + if err != nil { + t.Fatalf("get 2: %v", err) + } + if stored.Status != OpStatusApplied { + t.Errorf("status après promote = %q, attendu %q", stored.Status, OpStatusApplied) + } + // MarkApplied idempotent (re-promote sans effet). + if err := o.MarkApplied(deviceID, opID); err != nil { + t.Errorf("re-promote: %v", err) + } +} + +func TestStoredOpMatchesReplay(t *testing.T) { + o, devices := newTestOperations(t) + deviceID := NewID() + if err := devices.Upsert(deviceID); err != nil { + t.Fatalf("register device: %v", err) + } + + opID := NewID() + resID := NewID() + payload := []byte(`{"name":"x"}`) + if err := o.Record(deviceID, opID, "create_resource", "resource", nil, resID, payload); err != nil { + t.Fatalf("record: %v", err) + } + stored, err := o.Get(deviceID, opID) + if err != nil { + t.Fatalf("get: %v", err) + } + // Identique (espaces neutres via hash canonique) → match. + if err := stored.MatchesReplay("create_resource", resID, []byte("{ \"name\" : \"x\" }")); err != nil { + t.Errorf("rejeu identique: %v", err) + } + // Payload muté → ErrPayloadMismatch. + if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"y"}`)); !errors.Is(err, ErrPayloadMismatch) { + t.Errorf("payload muté : attendu ErrPayloadMismatch, got %v", err) + } + // Type muté → ErrPayloadMismatch. + if err := stored.MatchesReplay("delete_resource", resID, payload); !errors.Is(err, ErrPayloadMismatch) { + t.Errorf("type muté : attendu ErrPayloadMismatch, got %v", err) + } + // Ressource mutée → ErrPayloadMismatch. + if err := stored.MatchesReplay("create_resource", NewID(), payload); !errors.Is(err, ErrPayloadMismatch) { + t.Errorf("ressource mutée : attendu ErrPayloadMismatch, got %v", err) } - var parsed any - if err := json.Unmarshal([]byte(stored), &parsed); err != nil { - t.Fatalf("payload stocké invalide: %q", stored) + // Ligne héritée sans payload_hash (pré-000013) : hash recalculé depuis + // le payload stocké → match quand identique. + stored.PayloadHash = "" + if err := stored.MatchesReplay("create_resource", resID, payload); err != nil { + t.Errorf("ligne héritée identique: %v", err) } - if stored != "{}" { - t.Errorf("payload normalisé attendu {}, got %q", stored) + if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"z"}`)); !errors.Is(err, ErrPayloadMismatch) { + t.Errorf("ligne héritée mutée : attendu ErrPayloadMismatch, got %v", err) } } diff --git a/backend/repository/resources.go b/backend/repository/resources.go index 2791715..ed87a5d 100644 --- a/backend/repository/resources.go +++ b/backend/repository/resources.go @@ -20,12 +20,22 @@ var ErrNameConflict = errors.New("name conflict") // NewID returns an opaque lowercase 32-hex identifier (charset ^[0-9a-f]{32}$), // mirroring the mobile's lower(hex(randomblob(16))). Never a UUID. +// Panics on entropy failure (legacy) — prefer NewIDErr for new code. func NewID() string { - buf := make([]byte, 16) - if _, err := rand.Read(buf); err != nil { + id, err := NewIDErr() + if err != nil { panic(fmt.Sprintf("crypto/rand failed: %v", err)) } - return hex.EncodeToString(buf) + return id +} + +// NewIDErr is the non-panicking variant (cf. FEEDBACK A5). +func NewIDErr() (string, error) { + buf := make([]byte, 16) + if _, err := rand.Read(buf); err != nil { + return "", fmt.Errorf("crypto/rand failed: %w", err) + } + return hex.EncodeToString(buf), nil } func isUniqueViolation(err error) bool { @@ -33,6 +43,14 @@ func isUniqueViolation(err error) bool { return errors.As(err, &pqErr) && pqErr.Code == "23505" } +// isForeignKeyViolation reports a Postgres FK violation (23503). Une +// violation de FK parent (dossier cible disparu en course) est mappée vers +// ErrNotFound — cible inexistante — plutôt que de fuir en 500. +func isForeignKeyViolation(err error) bool { + var pqErr *pq.Error + return errors.As(err, &pqErr) && pqErr.Code == "23503" +} + type FileRow struct { ID string Name string @@ -108,42 +126,39 @@ const grantedCTE = ` AND r.deleted_at IS NULL AND g.depth < 100 )` -func (r *Resources) folderExists(ownerID, folderID string) (bool, error) { - var exists int - err := r.DB.QueryRow( - `SELECT 1 FROM resources - WHERE resource_id = $1 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL`, - folderID, ownerID, - ).Scan(&exists) - if err == sql.ErrNoRows { - return false, nil - } - return err == nil, err -} - +// insert persiste une ligne file/folder avec parent-check ATOMIQUE +// (single-statement INSERT...SELECT) : le dossier parent (quand non vide) +// doit exister, appartenir au même owner, être un folder non supprimé — +// sinon ErrNotFound. L'ancien SELECT-then-INSERT (TOCTOU : parent supprimé +// entre check et insert → FK 500) est remplacé ; une violation FK résiduelle +// (course) est mappée vers ErrNotFound, jamais 500. func (r *Resources) insert(ownerID, id, name, parentResourceID, resourceType string, size int64, mimeType, extension *string) error { - if parentResourceID != "" { - ok, err := r.folderExists(ownerID, parentResourceID) - if err != nil { - return err - } - if !ok { - return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound) - } - } - var parentID any - if parentResourceID != "" { - parentID = parentResourceID - } - _, err := r.DB.Exec( + result, err := r.DB.Exec( `INSERT INTO resources (resource_id, type, name, parent_id, user_id, size_bytes, mime_type, extension) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, - id, resourceType, name, parentID, ownerID, size, mimeType, extension, + SELECT $1, $2, $3, NULLIF($4, ''), $5, $6, $7, $8 + WHERE $4 = '' OR EXISTS ( + SELECT 1 FROM resources + WHERE resource_id = $4 AND user_id = $5 AND type = 'folder' AND deleted_at IS NULL + )`, + id, resourceType, name, parentResourceID, ownerID, size, mimeType, extension, ) if isUniqueViolation(err) { return ErrNameConflict } - return err + if isForeignKeyViolation(err) { + return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound) + } + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound) + } + return nil } // InsertFile persists a file metadata row for the owner device. The parent @@ -270,6 +285,26 @@ func (r *Resources) GetResourceOwner(resourceID string) (string, error) { return ownerID, err } +// GetParentID returns the parent_id ('""' si racine) d'une ressource non +// supprimée. No-rows → ErrNotFound. Sert au check de cycle des moves. +func (r *Resources) GetParentID(resourceID string) (string, error) { + var parent sql.NullString + err := r.DB.QueryRow( + `SELECT parent_id FROM resources WHERE resource_id = $1 AND deleted_at IS NULL`, + resourceID, + ).Scan(&parent) + if errors.Is(err, sql.ErrNoRows) { + return "", ErrNotFound + } + if err != nil { + return "", err + } + if !parent.Valid { + return "", nil + } + return parent.String, nil +} + // DeleteFile soft-deletes the file (deleted_at), returning its id. func (r *Resources) DeleteFile(ownerID, resourceID string) (string, error) { result, err := r.DB.Exec( @@ -369,26 +404,28 @@ func (r *Resources) GetFolder(ownerID, resourceID string) (FolderRow, error) { return row, err } -// MoveResource sets parent_id (root when parentResourceID empty). The target -// folder must exist and belong to the owner. Absent source is a no-op. +// MoveResource sets parent_id (root when parentResourceID empty) avec +// parent-check ATOMIQUE (single-statement) : la cible doit exister, +// appartenir au même owner, être un folder non supprimé. Source absente / +// non-owned OU cible absente → ErrNotFound (même code : le choix A8 +// move-non-owned → NOT_FOUND est appliqué ici, cf. LOT 3 pour la doc +// sync). Violation FK résiduelle (course) → ErrNotFound, jamais 500. func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) error { - if parentResourceID != "" { - if _, err := r.GetFolder(ownerID, parentResourceID); err != nil { - return err - } - } - var parentID any - if parentResourceID != "" { - parentID = parentResourceID - } result, err := r.DB.Exec( - `UPDATE resources SET parent_id = $3, updated_at = NOW() - WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`, - resourceID, ownerID, parentID, + `UPDATE resources SET parent_id = NULLIF($3, ''), updated_at = NOW() + WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL + AND ($3 = '' OR EXISTS ( + SELECT 1 FROM resources + WHERE resource_id = $3 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL + ))`, + resourceID, ownerID, parentResourceID, ) if err != nil && isUniqueViolation(err) { return ErrNameConflict } + if err != nil && isForeignKeyViolation(err) { + return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound) + } if err != nil { return err } @@ -402,7 +439,7 @@ func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) e return nil } -// UpdateName renames a resource. Absent source is a no-op. +// UpdateName renames a resource. Absent / not owned → ErrNotFound. func (r *Resources) UpdateName(ownerID, resourceID, name string) error { result, err := r.DB.Exec( `UPDATE resources SET name = $3, updated_at = NOW() @@ -425,8 +462,18 @@ func (r *Resources) UpdateName(ownerID, resourceID, name string) error { return nil } +// UpdateNameOwned renames a resource OWNED by ownerID. Absent / not owned → +// ErrNotFound, sibling homonyme → ErrNameConflict. Variante scopée +// canonique (sémantique identique à UpdateName, nom aligné sur TouchOwned +// pour LOT 3). +func (r *Resources) UpdateNameOwned(ownerID, resourceID, name string) error { + return r.UpdateName(ownerID, resourceID, name) +} + // UpdateNameByID renames a resource without owner scoping — the caller // (service) has already verified the user's effective access (editor+). +// Conservée volontairement pour update_metadata : un editor non-owner peut +// renommer, UpdateNameOwned rejetterait à tort. func (r *Resources) UpdateNameByID(resourceID, name string) error { result, err := r.DB.Exec( `UPDATE resources SET name = $2, updated_at = NOW() @@ -519,8 +566,35 @@ func (r *Resources) ExistsOwner(ownerID, resourceID string) (bool, error) { return err == nil, err } +// TouchOwned bumps updated_at on a non-deleted resource OWNED by ownerID so +// that the grantee's delta snapshot picks it up after a share is created. +// Absent / not owned → ErrNotFound. C'est la variante scopée à utiliser +// (LOT 3 : migrer les appelants sync vers TouchOwned). +func (r *Resources) TouchOwned(ownerID, resourceID string) error { + result, err := r.DB.Exec( + `UPDATE resources SET updated_at = NOW() + WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`, + resourceID, ownerID, + ) + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + return nil +} + // TouchResource bumps updated_at on a non-deleted resource so that the // grantee's delta snapshot picks it up after a share is created. +// +// Deprecated: non scopée (touche n'importe quel owner) — préférer TouchOwned. +// Plus aucun appelant sync (migrés vers TouchOwned) ; conservée pour +// compatibilité des appelants externes éventuels. func (r *Resources) TouchResource(resourceID string) error { _, err := r.DB.Exec( `UPDATE resources SET updated_at = NOW() WHERE resource_id = $1 AND deleted_at IS NULL`, diff --git a/backend/repository/resources_test.go b/backend/repository/resources_test.go index de35a86..e8c21dc 100644 --- a/backend/repository/resources_test.go +++ b/backend/repository/resources_test.go @@ -233,6 +233,156 @@ func TestListOwnedDelta(t *testing.T) { } } +func TestInsertParentCrossOwnerNotFound(t *testing.T) { + repo := newTestResources(t) + owner := NewID() + other := NewID() + mustInsertUser(t, repo, owner) + mustInsertUser(t, repo, other) + + ownerFolder := NewID() + if err := repo.InsertFolder(owner, ownerFolder, "Docs", ""); err != nil { + t.Fatalf("insert folder: %v", err) + } + + // Dossier d'un autre owner comme parent → NOT_FOUND (pas de fuite 500). + if err := repo.InsertFile(other, NewID(), "x.txt", ownerFolder, 1, nil, nil); !errors.Is(err, ErrNotFound) { + t.Errorf("parent autre owner : attendu ErrNotFound, got %v", err) + } + if err := repo.InsertFolder(other, NewID(), "Sub", ownerFolder); !errors.Is(err, ErrNotFound) { + t.Errorf("parent dossier autre owner : attendu ErrNotFound, got %v", err) + } + + // Un fichier comme parent → NOT_FOUND (pas un folder). + fileID := NewID() + if err := repo.InsertFile(owner, fileID, "note.txt", "", 1, nil, nil); err != nil { + t.Fatalf("insert file: %v", err) + } + if err := repo.InsertFile(owner, NewID(), "y.txt", fileID, 1, nil, nil); !errors.Is(err, ErrNotFound) { + t.Errorf("parent fichier : attendu ErrNotFound, got %v", err) + } +} + +func TestMoveResourceAtomic(t *testing.T) { + repo := newTestResources(t) + owner := NewID() + other := NewID() + mustInsertUser(t, repo, owner) + mustInsertUser(t, repo, other) + + folderA := NewID() + folderB := NewID() + if err := repo.InsertFolder(owner, folderA, "A", ""); err != nil { + t.Fatalf("insert A: %v", err) + } + if err := repo.InsertFolder(owner, folderB, "B", ""); err != nil { + t.Fatalf("insert B: %v", err) + } + otherFolder := NewID() + if err := repo.InsertFolder(other, otherFolder, "Other", ""); err != nil { + t.Fatalf("insert other: %v", err) + } + fileID := NewID() + if err := repo.InsertFile(owner, fileID, "note.txt", folderA, 1, nil, nil); err != nil { + t.Fatalf("insert file: %v", err) + } + + // Move OK vers dossier owned. + if err := repo.MoveResource(owner, fileID, folderB); err != nil { + t.Fatalf("move: %v", err) + } + got, err := repo.GetFile(owner, fileID) + if err != nil || got.FolderID != folderB { + t.Errorf("après move : folder=%q err=%v", got.FolderID, err) + } + + // Cible d'un autre owner → NOT_FOUND, la source ne bouge pas. + if err := repo.MoveResource(owner, fileID, otherFolder); !errors.Is(err, ErrNotFound) { + t.Errorf("cible autre owner : attendu ErrNotFound, got %v", err) + } + got, _ = repo.GetFile(owner, fileID) + if got.FolderID != folderB { + t.Errorf("move refusé ne doit rien changer, folder=%q", got.FolderID) + } + + // Cible inexistante → NOT_FOUND. + if err := repo.MoveResource(owner, fileID, NewID()); !errors.Is(err, ErrNotFound) { + t.Errorf("cible inconnue : attendu ErrNotFound, got %v", err) + } + + // Source inconnue → NOT_FOUND. + if err := repo.MoveResource(owner, NewID(), folderB); !errors.Is(err, ErrNotFound) { + t.Errorf("source inconnue : attendu ErrNotFound, got %v", err) + } + + // Retour à la racine. + if err := repo.MoveResource(owner, fileID, ""); err != nil { + t.Fatalf("move racine: %v", err) + } + got, _ = repo.GetFile(owner, fileID) + if got.FolderID != "" { + t.Errorf("racine attendue, folder=%q", got.FolderID) + } +} + +func TestTouchOwnedAndUpdateNameOwned(t *testing.T) { + repo := newTestResources(t) + owner := NewID() + other := NewID() + mustInsertUser(t, repo, owner) + mustInsertUser(t, repo, other) + + fileID := NewID() + if err := repo.InsertFile(owner, fileID, "note.txt", "", 1, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + before, err := repo.GetFile(owner, fileID) + if err != nil { + t.Fatalf("get: %v", err) + } + if err := repo.TouchOwned(owner, fileID); err != nil { + t.Fatalf("touch owned: %v", err) + } + after, err := repo.GetFile(owner, fileID) + if err != nil { + t.Fatalf("get après touch: %v", err) + } + if !after.UpdatedAt.After(before.UpdatedAt) && !after.UpdatedAt.Equal(before.UpdatedAt) { + t.Errorf("touch doit bumperc updated_at : %v → %v", before.UpdatedAt, after.UpdatedAt) + } + + // Non-owned / inconnu → ErrNotFound. + if err := repo.TouchOwned(other, fileID); !errors.Is(err, ErrNotFound) { + t.Errorf("touch autre owner : attendu ErrNotFound, got %v", err) + } + if err := repo.TouchOwned(owner, NewID()); !errors.Is(err, ErrNotFound) { + t.Errorf("touch inconnu : attendu ErrNotFound, got %v", err) + } + + if err := repo.UpdateNameOwned(owner, fileID, "renamed.txt"); err != nil { + t.Fatalf("rename owned: %v", err) + } + renamed, err := repo.GetFile(owner, fileID) + if err != nil || renamed.Name != "renamed.txt" { + t.Errorf("rename : %+v err=%v", renamed, err) + } + if err := repo.UpdateNameOwned(other, fileID, "volé.txt"); !errors.Is(err, ErrNotFound) { + t.Errorf("rename autre owner : attendu ErrNotFound, got %v", err) + } + if err := repo.UpdateNameOwned(owner, NewID(), "x.txt"); !errors.Is(err, ErrNotFound) { + t.Errorf("rename inconnu : attendu ErrNotFound, got %v", err) + } + + // Anciennes variantes (deprecated, compat LOT 3) : toujours fonctionnelles. + if err := repo.TouchResource(fileID); err != nil { + t.Errorf("touch legacy: %v", err) + } + if err := repo.UpdateNameByID(fileID, "legacy.txt"); err != nil { + t.Errorf("rename legacy: %v", err) + } +} + func TestUpdateOcrTextAndReadBack(t *testing.T) { repo := newTestResources(t) owner := NewID() diff --git a/backend/repository/shares.go b/backend/repository/shares.go index 7fe56d3..f605231 100644 --- a/backend/repository/shares.go +++ b/backend/repository/shares.go @@ -327,17 +327,44 @@ func (s *Shares) ResourceExists(resourceID string) (bool, error) { } // CreateLink stores a share link (token = id, client-generated 32-hex). +// Idempotent sur rejeu même (token) : ON CONFLICT DO NOTHING puis vérifie +// que le lien existant vise la même ressource ET le même owner (created_by) — +// sinon ErrNameConflict (réutilisation de token, cf. FEEDBACK #3). Un lien +// révoqué identique reste révoqué (pas de résurrection par rejeu : revoke gagne). func (s *Shares) CreateLink(token, resourceID, access string, expiresAt *time.Time, createdBy string) error { var expires any if expiresAt != nil { expires = *expiresAt } - _, err := s.DB.Exec( + res, err := s.DB.Exec( `INSERT INTO share_links (id, resource_id, access, created_by, expires_at) - VALUES ($1, $2, $3, $4, $5)`, + VALUES ($1, $2, $3, $4, $5) + ON CONFLICT (id) DO NOTHING`, token, resourceID, access, createdBy, expires, ) - return err + if err != nil { + return err + } + affected, err := res.RowsAffected() + if err != nil { + return err + } + if affected == 1 { + return nil + } + // Conflit : le token existe déjà — idempotent si même (ressource, owner), + // sinon conflit (le token est une clé d'idempotence client). + var existing struct { + resourceID string + createdBy string + } + if err := s.DB.QueryRow(`SELECT resource_id, created_by FROM share_links WHERE id = $1`, token).Scan(&existing.resourceID, &existing.createdBy); err != nil { + return err + } + if existing.resourceID != resourceID || existing.createdBy != createdBy { + return ErrNameConflict + } + return nil } // RevokeLink soft-revokes a link by token. Returns ErrNotFound if the link diff --git a/backend/repository/users.go b/backend/repository/users.go index 6c8a6ba..6356a35 100644 --- a/backend/repository/users.go +++ b/backend/repository/users.go @@ -20,11 +20,12 @@ type Users struct { DB *sql.DB } -// Count retourne le nombre d'utilisateurs (y compris supprimés) — sert au -// bootstrap admin au démarrage. +// Count retourne le nombre d'utilisateurs ACTIFS (deleted_at IS NULL) — sert +// au bootstrap admin au démarrage. Une base dont tous les comptes sont +// soft-deleted est vue comme vide : EnsureAdmin recréera un admin (#9+A10). func (u *Users) Count() (int, error) { var n int - err := u.DB.QueryRow(`SELECT COUNT(*) FROM users`).Scan(&n) + err := u.DB.QueryRow(`SELECT COUNT(*) FROM users WHERE deleted_at IS NULL`).Scan(&n) return n, err } @@ -67,8 +68,11 @@ func (u *Users) ResolveExact(normalized string) (*UserRow, error) { // Create insère un compte avec un id 32-hex généré. Retourne l'id. func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmin bool) (string, error) { - id := NewID() - _, err := u.DB.Exec( + id, err := NewIDErr() + if err != nil { + return "", err + } + _, err = u.DB.Exec( `INSERT INTO users (id, username, username_normalized, password_hash, is_admin, created_at) VALUES ($1, $2, $3, $4, $5, NOW())`, id, username, usernameNormalized, passwordHash, isAdmin, @@ -82,24 +86,47 @@ func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmi return id, nil } -// UpdatePassword remplace le hash du compte. Les tokens déjà émis restent -// valides 7 jours : limite assumée V1 (pas de liste de révocation). +// UpdatePassword remplace le hash du compte actif. Compte absent ou +// soft-deleted → ErrNotFound. Les tokens déjà émis restent valides 7 jours : +// limite assumée V1 (pas de liste de révocation). func (u *Users) UpdatePassword(id, newHash string) error { - _, err := u.DB.Exec( - `UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1`, + result, err := u.DB.Exec( + `UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`, id, newHash, ) - return err + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + return nil } -// MarkDeleted soft-delete un compte : les tokens issus sont rejetés par le -// middleware (GetByID filtre deleted_at). +// MarkDeleted soft-delete un compte actif : les tokens issus sont rejetés par +// le middleware (GetByID filtre deleted_at). Compte absent ou déjà supprimé → +// ErrNotFound (pas d'idempotence silencieuse : le second delete signale que +// la cible n'est plus active). func (u *Users) MarkDeleted(id string) error { - _, err := u.DB.Exec( - `UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1`, + result, err := u.DB.Exec( + `UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`, id, ) - return err + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + return nil } func scanUser(scan func(...any) error) (*UserRow, error) { diff --git a/backend/repository/users_test.go b/backend/repository/users_test.go index 0bd2db4..3832c82 100644 --- a/backend/repository/users_test.go +++ b/backend/repository/users_test.go @@ -64,6 +64,11 @@ func TestUsersUpdatePassword(t *testing.T) { if err != nil || row.PasswordHash != "hash-2" { t.Errorf("hash après update = %q (err=%v)", row.PasswordHash, err) } + + // Compte inconnu → ErrNotFound (#9+A10). + if err := u.UpdatePassword(NewID(), "hash-x"); !errors.Is(err, ErrNotFound) { + t.Errorf("update password inconnu : attendu ErrNotFound, got %v", err) + } } func TestUsersMarkDeletedHidesAccount(t *testing.T) { @@ -82,7 +87,22 @@ func TestUsersMarkDeletedHidesAccount(t *testing.T) { if _, err := u.GetByUsernameNormalized("carol"); !errors.Is(err, ErrNotFound) { t.Errorf("get par username après suppression : attendu ErrNotFound, got %v", err) } - if n, _ := u.Count(); n != 1 { - t.Errorf("count doit compter aussi les supprimés (bootstrap), got %d", n) + // Count ne compte que les ACTIFS : carol soft-deleted → 0 (#9+A10). Une + // base 100% soft-deleted est vue comme vide par le bootstrap. + if n, _ := u.Count(); n != 0 { + t.Errorf("count doit exclure les supprimés, got %d", n) + } + + // UpdatePassword sur compte supprimé → ErrNotFound. + if err := u.UpdatePassword(id, "hash-2"); !errors.Is(err, ErrNotFound) { + t.Errorf("update password après suppression : attendu ErrNotFound, got %v", err) + } + // Second MarkDeleted → ErrNotFound (plus de cible active). + if err := u.MarkDeleted(id); !errors.Is(err, ErrNotFound) { + t.Errorf("second mark deleted : attendu ErrNotFound, got %v", err) + } + // MarkDeleted sur inconnu → ErrNotFound. + if err := u.MarkDeleted(NewID()); !errors.Is(err, ErrNotFound) { + t.Errorf("mark deleted inconnu : attendu ErrNotFound, got %v", err) } } diff --git a/backend/service/bootstrap.go b/backend/service/bootstrap.go index eee51c4..03536a8 100644 --- a/backend/service/bootstrap.go +++ b/backend/service/bootstrap.go @@ -21,7 +21,9 @@ func NormalizeUsername(username string) string { } // EnsureAdmin crée le compte admin au premier démarrage si la table users est -// vide. Idempotent : l'env n'écrase jamais un compte existant. +// vide. Idempotent : l'env n'écrase jamais un compte existant. Seuls les +// comptes ACTIFS comptent (Users.Count filtre deleted_at, #9+A10) : une base +// 100% soft-deleted est vue comme vide et reçoit un nouvel admin. func EnsureAdmin(repo *repository.Repository, username, password string) error { count, err := repo.Users.Count() if err != nil { diff --git a/backend/service/bootstrap_test.go b/backend/service/bootstrap_test.go index 14d888b..cad8eff 100644 --- a/backend/service/bootstrap_test.go +++ b/backend/service/bootstrap_test.go @@ -60,6 +60,32 @@ func TestEnsureAdminRefusesOnEmptyDBWithoutEnv(t *testing.T) { } } +func TestEnsureAdminRecreatesWhenAllSoftDeleted(t *testing.T) { + s := newServiceStore(t) + repo := s.Repository + + // Un seul compte, soft-deleted : Count (actifs seuls, #9+A10) voit une + // base vide → EnsureAdmin recrée un admin au lieu de refuser. + id, err := repo.Users.Create("alice", "alice", "existing-hash", false) + if err != nil { + t.Fatalf("seed user: %v", err) + } + if err := repo.Users.MarkDeleted(id); err != nil { + t.Fatalf("mark deleted: %v", err) + } + + if err := EnsureAdmin(repo, "admin", "admin-secret-123"); err != nil { + t.Fatalf("EnsureAdmin sur base 100%% soft-deleted : %v", err) + } + admin, err := repo.Users.GetByUsernameNormalized("admin") + if err != nil { + t.Fatalf("admin recréé introuvable: %v", err) + } + if !admin.IsAdmin { + t.Error("le compte recréé doit être admin") + } +} + func TestEnsureAdminNeverOverwritesExistingAccounts(t *testing.T) { s := newServiceStore(t) repo := s.Repository diff --git a/backend/service/folders.go b/backend/service/folders.go deleted file mode 100644 index 84d2d95..0000000 --- a/backend/service/folders.go +++ /dev/null @@ -1,14 +0,0 @@ -package service - -import "github.com/kazier/backend/models" - -func (s *Services) CreateFolder(folderName string, destination *models.Document) (*models.Document, error) { - - directory, err := models.NewDocument(folderName, models.DIRECTORY, 1) - if err != nil { - return nil, err - } - - return directory, nil - -} diff --git a/backend/service/move.go b/backend/service/move.go deleted file mode 100644 index dec4c93..0000000 --- a/backend/service/move.go +++ /dev/null @@ -1,34 +0,0 @@ -package service - -import ( - "errors" - "fmt" - - "github.com/kazier/backend/models" -) - -func (s *Services) MoveDocumentIntoDocument(from *models.Document, to *models.Document) error { - - if from.UUID == nil { - return errors.New(models.ERROR_DOCUMENT_NOT_PERCISTED) - } - - if to.Type != models.DIRECTORY { - return errors.New("the destination document must be a directory") - } - - if canEdit, _ := UserCanEditDocument(s.ConnectedUser, from); !canEdit { - return errors.New("you cannot edit this folder") - } - - if canEdit, _ := UserCanEditDocument(s.ConnectedUser, to); !canEdit { - return errors.New("you cannot edit this folder") - } - - // Check if document exist and move the document into document if is directory - - fmt.Println("To implement move to ", to.UUID) - - return nil - -} diff --git a/backend/service/move_test.go b/backend/service/move_test.go deleted file mode 100644 index 67c1234..0000000 --- a/backend/service/move_test.go +++ /dev/null @@ -1,62 +0,0 @@ -package service - -import ( - "testing" - - "github.com/kazier/backend/models" -) - -func TestMoveDocument(t *testing.T) { - - userAntoine, err := models.NewUser("antoine") - if err != nil { - t.Fatalf("creating antoine user: %v", err) - } - - fakeUUID := "dsqdsq" - document, err := models.NewDocument("test.pdf", models.FILE, 1) - if err != nil { - t.Fatalf("creating document: %v", err) - } - document.UUID = &fakeUUID - - folder, err := models.NewDocument("orga", models.DIRECTORY, 1) - if err != nil { - t.Fatalf("creating folder: %v", err) - } - folder.UUID = &fakeUUID - - service := New(userAntoine) - - if err := service.MoveDocumentIntoDocument(document, folder); err != nil { - t.Error(err) - } - -} - -func TestMoveDocumentToAFile(t *testing.T) { - - userAntoine, err := models.NewUser("antoine") - if err != nil { - t.Fatalf("creating antoine user: %v", err) - } - - document, err := models.NewDocument("test.pdf", models.FILE, 1) - if err != nil { - t.Fatalf("creating document: %v", err) - } - - notAFolder, err := models.NewDocument("orga", models.FILE, 1) - if err != nil { - t.Fatalf("creating file: %v", err) - } - - service := New(userAntoine) - - err = service.MoveDocumentIntoDocument(document, notAFolder) - - if err == nil { - t.Error(err) - } - -} \ No newline at end of file diff --git a/backend/service/ocr.go b/backend/service/ocr.go index 37ab9d9..6390ea5 100644 --- a/backend/service/ocr.go +++ b/backend/service/ocr.go @@ -3,8 +3,11 @@ package service import ( "context" "errors" + "fmt" "log" + "os" "path/filepath" + "regexp" "strings" "sync" "time" @@ -41,7 +44,29 @@ type Ocr struct { } func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr { - return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: lang, Engine: engine, StaleAfter: StaleClaimTimeout} + return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: normalizeOcrLang(lang), Engine: engine, StaleAfter: StaleClaimTimeout} +} + +var ( + // ocrLangPattern : whitelist OCR_LANG (A12) — lettres Tesseract + `+` + // uniquement (ex. `fra`, `eng`, `fra+eng`). Tout le reste (espaces, + // `;`, `-`, options `--...`) est une tentative d'injection `-l`. + ocrLangPattern = regexp.MustCompile(`^[a-z+]{2,20}$`) + // hexIDPattern : identifiants 32-hex (anti `..` dans physicalPath). + hexIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`) +) + +// DefaultOcrLang est la langue Tesseract de repli (OCR_LANG, défaut fra+eng). +const DefaultOcrLang = "fra+eng" + +// normalizeOcrLang applique la whitelist OCR_LANG : valeur invalide → repli +// sur le défaut avec log (jamais d'injection vers `tesseract -l`). +func normalizeOcrLang(lang string) string { + if ocrLangPattern.MatchString(lang) { + return lang + } + log.Printf("ocr: OCR_LANG %q invalide (whitelist ^[a-z+]{2,20}$), repli sur %q", lang, DefaultOcrLang) + return DefaultOcrLang } // Create valide la ressource (ownership par user) et l'enfile uniquement @@ -110,44 +135,87 @@ func (o *Ocr) workerLoop(ctx context.Context) { } // process exécute l'extraction pour un job déjà réclamé (`processing`). +// Ordre A13 : l'écriture `UpdateOcrText` est vérifiée AVANT le `Complete` — +// hôte supprimé entre-temps (0 ligne, ErrNotFound) → le job `Fail` au lieu +// de rester `done` avec un texte fantôme. Les erreurs `Fail`/`Complete` +// (conflit d'état : job requeue et repris par un autre worker) sont loggées, +// jamais silencieuses. func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) { + fail := func(message string) { + if err := o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, message); err != nil { + log.Printf("ocr: fail job %s: %v", row.ID, err) + } + } + complete := func(text string) { + if err := o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text); err != nil { + log.Printf("ocr: complete job %s: %v", row.ID, err) + } + } userID, err := o.Repository.Resources.GetResourceOwner(row.FileID) if err != nil { - _ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable") + fail("file not readable") return } path, err := o.physicalPath(userID, row.FileID) if err != nil { - _ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable") + fail("file not readable") return } text, err := o.Engine.ExtractText(ctx, path, o.Lang) if err != nil { - _ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, err.Error()) + fail(err.Error()) return } - _ = o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text) // Le texte atterrit sur la ressource (updated_at bumpé) : consultable par - // tous les devices du user et les grantees via GET /files/:id/ocr. SILENCIEUX - // (hôte déjà supprimé ou lock d'écriture) : le job reste source d'historique. + // tous les devices du user et les grantees via GET /files/:id/ocr. if trimmed := strings.TrimSpace(text); trimmed != "" { if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil { - log.Printf("ocr: persiste ocr_text de %s: %v", row.FileID, err) + if errors.Is(err, repository.ErrNotFound) { + fail("file not readable") + } else { + fail(err.Error()) + } + return } } + complete(text) } // physicalPath résout UPLOAD_DIR//. — l'ext est -// choisi à l'upload, le fichier réel est retrouvé par préfixe. +// choisi à l'upload, le fichier réel est retrouvé par préfixe. Durci (A12) : +// identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier +// (ni dossier, ni symlink brut), `EvalSymlinks` contenu dans UPLOAD_DIR +// (anti évasion par lien symbolique). Candidat rejeté → candidat suivant ; +// aucun candidat → ErrNotFound. func (o *Ocr) physicalPath(userID, fileID string) (string, error) { + if !hexIDPattern.MatchString(userID) || !hexIDPattern.MatchString(fileID) { + return "", fmt.Errorf("physicalPath: identifiant non 32-hex") + } + base, err := filepath.EvalSymlinks(o.UploadDir) + if err != nil { + return "", fmt.Errorf("physicalPath: upload dir illisible: %w", err) + } matches, err := filepath.Glob(filepath.Join(o.UploadDir, userID, fileID+".*")) if err != nil { return "", err } for _, m := range matches { - if strings.HasPrefix(filepath.Base(m), fileID+".") { - return m, nil + if !strings.HasPrefix(filepath.Base(m), fileID+".") { + continue } + fi, err := os.Lstat(m) + if err != nil || !fi.Mode().IsRegular() { + continue + } + resolved, err := filepath.EvalSymlinks(m) + if err != nil { + continue + } + rel, err := filepath.Rel(base, resolved) + if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) { + continue + } + return resolved, nil } return "", repository.ErrNotFound } @@ -161,4 +229,4 @@ func toOcrJobDTO(row repository.OcrJobRow) OcrJobDTO { dto.Error = *row.Error } return dto -} \ No newline at end of file +} diff --git a/backend/service/ocr_test.go b/backend/service/ocr_test.go index d8d46bc..a32bf93 100644 --- a/backend/service/ocr_test.go +++ b/backend/service/ocr_test.go @@ -94,6 +94,76 @@ func TestOcrPhysicalPath(t *testing.T) { } } +func TestOcrPhysicalPathRejectsNonHexIDs(t *testing.T) { + o := NewOcr(nil, t.TempDir(), "fra+eng", nil) + for _, tc := range [][2]string{ + {"../evil", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}, + {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "../../etc/passwd.png"}, + {"", ""}, + } { + if _, err := o.physicalPath(tc[0], tc[1]); err == nil { + t.Errorf("ids %q/%q : attendu rejet non 32-hex", tc[0], tc[1]) + } + } +} + +func TestOcrPhysicalPathRejectsSymlinkEscape(t *testing.T) { + uploadDir := t.TempDir() + userID := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + fileID := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + outside := t.TempDir() + + secret := filepath.Join(outside, "secret.png") + if err := os.WriteFile(secret, []byte("secret"), 0o644); err != nil { + t.Fatalf("write secret: %v", err) + } + userDir := filepath.Join(uploadDir, userID) + if err := os.MkdirAll(userDir, 0o755); err != nil { + t.Fatalf("mkdir: %v", err) + } + // Lien symbolique .png → hors UPLOAD_DIR : doit être ignoré. + if err := os.Symlink(secret, filepath.Join(userDir, fileID+".png")); err != nil { + t.Fatalf("symlink: %v", err) + } + + o := NewOcr(nil, uploadDir, "fra+eng", nil) + if _, err := o.physicalPath(userID, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Errorf("symlink hors UPLOAD_DIR : attendu ErrNotFound, got %v", err) + } +} + +func TestOcrPhysicalPathRejectsDirectory(t *testing.T) { + uploadDir := t.TempDir() + userID := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + fileID := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + userDir := filepath.Join(uploadDir, userID) + if err := os.MkdirAll(filepath.Join(userDir, fileID+".png"), 0o755); err != nil { + t.Fatalf("mkdir: %v", err) + } + + o := NewOcr(nil, uploadDir, "fra+eng", nil) + if _, err := o.physicalPath(userID, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Errorf("dossier à la place du fichier : attendu ErrNotFound, got %v", err) + } +} + +func TestNormalizeOcrLang(t *testing.T) { + for _, lang := range []string{"fra", "eng", "fra+eng"} { + if got := normalizeOcrLang(lang); got != lang { + t.Errorf("langue %q : attendue conservée, got %q", lang, got) + } + } + for _, lang := range []string{"", "e", "fra;id", "fra eng", "FRA", "--psm 6 fra"} { + if got := normalizeOcrLang(lang); got != DefaultOcrLang { + t.Errorf("langue %q : attendu repli %q, got %q", lang, DefaultOcrLang, got) + } + } + o := NewOcr(nil, t.TempDir(), "fra;evil", nil) + if o.Lang != DefaultOcrLang { + t.Errorf("NewOcr langue hostile : attendu %q, got %q", DefaultOcrLang, o.Lang) + } +} + func TestOcrJobFailsWhenPhysicalFileMissing(t *testing.T) { o, userID, deviceID, _ := newTestOcr(t, t.TempDir(), stubEngine{text: "x"}) diff --git a/backend/service/resources.go b/backend/service/resources.go index 012cfc2..0f0d4c3 100644 --- a/backend/service/resources.go +++ b/backend/service/resources.go @@ -4,9 +4,11 @@ import ( "errors" "fmt" "io" + "log" "mime/multipart" "os" "path/filepath" + "regexp" "strings" "time" @@ -16,6 +18,10 @@ import ( // ErrFileTooLarge signals an upload above MaxFileSize. var ErrFileTooLarge = errors.New("file too large") +// ErrInvalidUpload signals a rejected upload (display name or path component). +// Handlers map it to 400 INVALID_REQUEST (never 500). +var ErrInvalidUpload = errors.New("invalid upload name") + // FileDTO serializes exactly as mobile/api/types.ts FileDto. type FileDTO struct { ID string `json:"id"` @@ -53,6 +59,66 @@ func NewResources(repo *repository.Repository, uploadDir string, maxFileSize int } } +var ( + extensionPattern = regexp.MustCompile(`^[a-z0-9]{1,10}$`) + idPattern = regexp.MustCompile(`^[0-9a-f]{32}$`) +) + +// allowedMimeTypes whitelists client-declared Content-Types (parameters +// stripped, lowercased) ; anything absent falls back to +// application/octet-stream (cf. FEEDBACK A16). +var allowedMimeTypes = map[string]struct{}{ + "application/octet-stream": {}, + "application/pdf": {}, + "application/json": {}, + "application/zip": {}, + "text/plain": {}, + "text/csv": {}, + "text/markdown": {}, + "image/png": {}, + "image/jpeg": {}, + "image/gif": {}, + "image/webp": {}, + "audio/mpeg": {}, + "video/mp4": {}, +} + +// sanitizeExtension normalise l'extension issue du filename client (cf. +// FEEDBACK #5) : lowercase, [a-z0-9]{1,10}, sinon "" (pas de suffixe). +func sanitizeExtension(filename string) string { + ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), ".")) + if !extensionPattern.MatchString(ext) { + return "" + } + return ext +} + +// sanitizeFileName nettoie le nom stocké (cf. FEEDBACK A16) : TrimSpace, +// cap 255, rejet vide / slash / backslash / retour ligne. Le nom n'est +// qu'une métadonnée (jamais un composant de chemin), mais on le verrouille +// quand même pour casser toute confusion downstream. +func sanitizeFileName(name string) (string, error) { + n := strings.TrimSpace(name) + if n == "" || len(n) > 255 || strings.ContainsAny(n, "/\\\x00\n\r") { + return "", ErrInvalidUpload + } + return n, nil +} + +func sanitizeMimeType(mime string) string { + m := strings.ToLower(strings.TrimSpace(mime)) + if i := strings.IndexByte(m, ';'); i >= 0 { + m = strings.TrimSpace(m[:i]) + } + if m == "" || len(m) > 128 { + return "application/octet-stream" + } + if _, ok := allowedMimeTypes[m]; !ok { + return "application/octet-stream" + } + return m +} + func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) { rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order) if err != nil { @@ -132,66 +198,166 @@ func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDT // rename, never a move, never a duplicate row. Unknown / foreign resource → // repo.ErrNotFound. func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) { - if file.Size > s.MaxFileSize { - return FileDTO{}, ErrFileTooLarge + // Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des + // composants de chemin. ownerID vient de l'auth mais on ne lui fait pas + // confiance aveuglément ; resourceID fourni par le client est déjà + // pré-validé côté handler (404), ici on rejete en NotFound/400 pareil. + if strings.ContainsAny(ownerID, "/\\\x00\n\r") || strings.Contains(ownerID, "..") { + return FileDTO{}, ErrInvalidUpload } - targetExisting := resourceID != "" if targetExisting { + if !idPattern.MatchString(resourceID) { + return FileDTO{}, repository.ErrNotFound + } if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil { return FileDTO{}, err } } else { - resourceID = repository.NewID() + var err error + resourceID, err = repository.NewIDErr() + if err != nil { + return FileDTO{}, err + } } - extension := strings.TrimPrefix(filepath.Ext(file.Filename), ".") + name, err := sanitizeFileName(file.Filename) + if err != nil { + return FileDTO{}, err + } + extension := sanitizeExtension(file.Filename) destDir := filepath.Join(s.UploadDir, ownerID) - if err := os.MkdirAll(destDir, 0o755); err != nil { + if err := os.MkdirAll(destDir, 0o700); err != nil { return FileDTO{}, fmt.Errorf("create upload dir: %w", err) } + // MkdirAll respecte umask et ne touche pas aux dirs préexistants : on + // enforce 0700 explicitement (cf. FEEDBACK A4). + if err := os.Chmod(destDir, 0o700); err != nil { + return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err) + } - destPath := filepath.Join(destDir, resourceID+"."+extension) - if err := copyMultipart(file, destPath); err != nil { + destName := resourceID + if extension != "" { + destName = resourceID + "." + extension + } + destPath := filepath.Join(destDir, destName) + + // Mémorise les anciens physiques pour cleanup post-succès (changement d'ext). + // Note : Glob(id.*) ne matche pas le fichier sans extension, on traite le + // chemin nu séparément (cf. FEEDBACK #6). + oldMatches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*")) + barePath := filepath.Join(destDir, resourceID) + if barePath != destPath { + if _, err := os.Stat(barePath); err == nil { + oldMatches = append(oldMatches, barePath) + } + } + + written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize) + if err != nil { return FileDTO{}, err } - mimeType := file.Header.Get("Content-Type") - var err error + mimeType := sanitizeMimeType(file.Header.Get("Content-Type")) + var extPtr *string + if extension != "" { + extPtr = &extension + } if targetExisting { - err = s.Repo.UpdatePhysical(ownerID, resourceID, file.Size, &mimeType, &extension) + err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr) } else { - err = s.Repo.InsertFile(ownerID, resourceID, file.Filename, folderID, file.Size, &mimeType, &extension) + err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr) } if err != nil { - _ = os.Remove(destPath) + // Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique. + stillOld := false + for _, m := range oldMatches { + if m == destPath { + stillOld = true + break + } + } + if !stillOld { + _ = os.Remove(destPath) + } return FileDTO{}, err } + // Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6). + for _, m := range oldMatches { + if m != destPath && strings.HasPrefix(filepath.Base(m), resourceID+".") { + _ = os.Remove(m) + } + } row, err := s.Repo.GetFile(ownerID, resourceID) if err != nil { + // Lecture post-insert en échec : au moins logguer (cf. FEEDBACK #6). + // Sur création on tente en plus de retirer le fichier pour ne pas + // laisser d'orphelin (le client retry → NAME_CONFLICT → re-upload + // ciblé). Sur re-upload ciblé on ne touche à rien (données existantes). + log.Printf("upload: GetFile(%s) failed after persist: %v", resourceID, err) + if !targetExisting { + _ = os.Remove(destPath) + } return FileDTO{}, err } return toFileDTO(row), nil } -func copyMultipart(file *multipart.FileHeader, destPath string) error { +// copyMultipartAtomic écrit vers un temp dans destDir (0600) avec limite +// stricte maxSize+1 (header file.Size non fiable, cf. A2), fsync + rename +// atomique (cf. A3). Retourne les octets réellement écrits. +func copyMultipartAtomic(file *multipart.FileHeader, destDir, destPath string, maxSize int64) (int64, error) { src, err := file.Open() if err != nil { - return fmt.Errorf("open multipart file: %w", err) + return 0, fmt.Errorf("open multipart file: %w", err) } defer src.Close() - dst, err := os.Create(destPath) + // Temp dans le même répertoire (même filesystem → rename atomique), + // pattern .tmp--* (cf. FEEDBACK A3). Jamais d'overwrite direct. + tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*") if err != nil { - return fmt.Errorf("create file: %w", err) + return 0, fmt.Errorf("create tmp file: %w", err) + } + tmpName := tmp.Name() + // En cas d'échec avant rename, nettoyer le temp. + success := false + defer func() { + if !success { + _ = os.Remove(tmpName) + } + }() + if err := tmp.Chmod(0o600); err != nil { + tmp.Close() + return 0, fmt.Errorf("chmod tmp file: %w", err) } - defer dst.Close() - if _, err := io.Copy(dst, src); err != nil { - return fmt.Errorf("copy upload: %w", err) + limited := io.LimitReader(src, maxSize+1) + written, err := io.Copy(tmp, limited) + if err != nil { + tmp.Close() + return 0, fmt.Errorf("copy upload: %w", err) } - return nil + if written > maxSize { + tmp.Close() + return 0, ErrFileTooLarge + } + if err := tmp.Sync(); err != nil { + tmp.Close() + return 0, fmt.Errorf("fsync upload: %w", err) + } + if err := tmp.Close(); err != nil { + return 0, fmt.Errorf("close upload: %w", err) + } + if err := os.Rename(tmpName, destPath); err != nil { + return 0, fmt.Errorf("commit upload: %w", err) + } + if err := os.Chmod(destPath, 0o600); err != nil { + return 0, fmt.Errorf("chmod upload: %w", err) + } + success = true + return written, nil } func toFileDTO(row repository.FileRow) FileDTO { diff --git a/backend/service/resources_test.go b/backend/service/resources_test.go index e0d5c4c..b413a3c 100644 --- a/backend/service/resources_test.go +++ b/backend/service/resources_test.go @@ -6,6 +6,7 @@ import ( "mime/multipart" "os" "path/filepath" + "strings" "testing" "github.com/kazier/backend/repository" @@ -162,3 +163,204 @@ func TestUploadTargetUnknownIsNotFound(t *testing.T) { t.Fatalf("upload inconnu : attendu ErrNotFound, got %v", err) } } + +// A2 : le header multipart Size est déclaratif — seul le comptage réel des +// octets (LimitReader MaxFileSize+1) fait foi. +func TestUploadEnforcesActualSizeDespiteLyingHeader(t *testing.T) { + s := newServiceStore(t) // MaxFileSize = 100 + userID := mustCreateUser(t, s.Repository, "upload-lying") + + fh := multipartFileHeader(t, "big.txt", bytes.Repeat([]byte("x"), 150)) + fh.Size = 10 // header menteur : annonce 10 alors que 150 arrivent + if _, err := s.Upload(userID, fh, "", ""); !errors.Is(err, ErrFileTooLarge) { + t.Fatalf("header menteur : attendu ErrFileTooLarge, got %v", err) + } + // Aucun résidu physique (ni fichier final, ni .tmp-* orphelin). + if entries, err := os.ReadDir(filepath.Join(s.UploadDir, userID)); err == nil && len(entries) != 0 { + names := make([]string, 0, len(entries)) + for _, e := range entries { + names = append(names, e.Name()) + } + t.Errorf("résidu physique après refus : %v", names) + } +} + +// #5 : extension sanitizée (lowercase [a-z0-9]{1,10}), pas de "id." si vide. +func TestUploadSanitizesExtension(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "upload-ext") + + // Uppercase → lowercase. + dto, err := s.Upload(userID, multipartFileHeader(t, "PHOTO.JPG", []byte("data")), "", "") + if err != nil { + t.Fatalf("upload uppercase ext: %v", err) + } + if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto.ID+".jpg")); err != nil { + t.Errorf("fichier .jpg (lowercase) attendu: %v", err) + } + + // Pas d'extension → fichier nu, sans trailing dot. + dto2, err := s.Upload(userID, multipartFileHeader(t, "README", []byte("data")), "", "") + if err != nil { + t.Fatalf("upload sans ext: %v", err) + } + if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto2.ID)); err != nil { + t.Errorf("fichier sans extension attendu: %v", err) + } + if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto2.ID+".")); !os.IsNotExist(err) { + t.Errorf("trailing dot interdit (id.) : err=%v", err) + } + + // Extension trop longue / non alnum → "" (fichier nu). + dto3, err := s.Upload(userID, multipartFileHeader(t, "run.verylongextensiontoolong", []byte("data")), "", "") + if err != nil { + t.Fatalf("upload ext invalide: %v", err) + } + if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto3.ID)); err != nil { + t.Errorf("ext invalide → fichier nu attendu: %v", err) + } + + // Backslash survit au round-trip multipart stdlib → rejet prouvé de bout + // en bout (les autres cas slash/NUL/retour-ligne sont couverts en + // unitaire sur sanitizeFileName, la stdlib Go les neutralisant déjà). + if _, err := s.Upload(userID, multipartFileHeader(t, `a\b.txt`, []byte("data")), "", ""); !errors.Is(err, ErrInvalidUpload) { + t.Errorf(`nom %q : attendu ErrInvalidUpload, got %v`, `a\b.txt`, err) + } +} + +// #5/A16 : sanitizeurs unitaires — un client non-Go peut envoyer un filename +// brut (slash, .., NUL, retour-ligne) que la stdlib Go ne neutraliserait pas +// côté lecture serveur. +func TestSanitizeFileName(t *testing.T) { + for _, bad := range []string{"", " ", "../evil.txt", "a/b.txt", "a\x00b.txt", "bad\nname.txt", "bad\rname.txt", strings.Repeat("a", 256)} { + if _, err := sanitizeFileName(bad); !errors.Is(err, ErrInvalidUpload) { + t.Errorf("sanitizeFileName(%q) : attendu ErrInvalidUpload, got %v", bad, err) + } + } + for _, good := range []string{"docs.txt", " pad.txt ", "vacances-août.jpg", "a b c.pdf"} { + got, err := sanitizeFileName(good) + if err != nil { + t.Errorf("sanitizeFileName(%q) : rejet inattendu: %v", good, err) + } else if got != strings.TrimSpace(good) { + t.Errorf("sanitizeFileName(%q) = %q, attendu trim", good, got) + } + } +} + +func TestSanitizeExtension(t *testing.T) { + cases := map[string]string{ + "photo.JPG": "jpg", + "archive.tar.gz": "gz", + "README": "", + "run.verylongextensiontoolong": "", + "evil.php/../../x": "", + "a.b/c": "", + "weird.HTM\nL": "", + "dot.": "", + } + for in, want := range cases { + if got := sanitizeExtension(in); got != want { + t.Errorf("sanitizeExtension(%q) = %q, attendu %q", in, got, want) + } + } +} + +// #6 : un re-upload ciblé avec une nouvelle extension ne laisse qu'un seul +// fichier physique (l'ancien suffixe est supprimé). +func TestUploadReuploadNewExtensionRemovesStaleFile(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "upload-reext") + + resourceID := repository.NewID() + png := "png" + if err := s.Repository.Resources.InsertFile(userID, resourceID, "scan.png", "", 0, nil, &png); err != nil { + t.Fatalf("insert metadata-only: %v", err) + } + if _, err := s.Upload(userID, multipartFileHeader(t, "scan.png", []byte("PNGDATA")), "", resourceID); err != nil { + t.Fatalf("premier upload ciblé: %v", err) + } + + dto, err := s.Upload(userID, multipartFileHeader(t, "scan.jpg", []byte("JPGDATA!")), "", resourceID) + if err != nil { + t.Fatalf("re-upload nouvelle ext: %v", err) + } + if dto.ID != resourceID { + t.Fatalf("id attendu %s, got %s", resourceID, dto.ID) + } + entries, err := os.ReadDir(filepath.Join(s.UploadDir, userID)) + if err != nil { + t.Fatalf("readdir: %v", err) + } + if len(entries) != 1 || entries[0].Name() != resourceID+".jpg" { + names := make([]string, 0, len(entries)) + for _, e := range entries { + names = append(names, e.Name()) + } + t.Errorf("un seul physique attendu (%s.jpg), got %v", resourceID, names) + } + content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg")) + if err != nil || string(content) != "JPGDATA!" { + t.Errorf("contenu = %q, err=%v (attendu JPGDATA!)", content, err) + } +} + +// A4 : répertoire 0700, fichier 0600 (enforcés malgré umask). +func TestUploadFileAndDirPermissions(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "upload-perms") + + dto, err := s.Upload(userID, multipartFileHeader(t, "secret.txt", []byte("data")), "", "") + if err != nil { + t.Fatalf("upload: %v", err) + } + dirInfo, err := os.Stat(filepath.Join(s.UploadDir, userID)) + if err != nil { + t.Fatalf("stat dir: %v", err) + } + if perm := dirInfo.Mode().Perm(); perm != 0o700 { + t.Errorf("perms dossier = %04o, attendu 0700", perm) + } + fileInfo, err := os.Stat(filepath.Join(s.UploadDir, userID, dto.ID+".txt")) + if err != nil { + t.Fatalf("stat file: %v", err) + } + if perm := fileInfo.Mode().Perm(); perm != 0o600 { + t.Errorf("perms fichier = %04o, attendu 0600", perm) + } +} + +// A16 : Content-Type hors whitelist → fallback application/octet-stream. +func TestUploadMimeTypeWhitelistFallback(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "upload-mime") + + evil := multipartFileHeader(t, "evil.bin", []byte("data")) + evil.Header.Set("Content-Type", "application/x-evil-tool") + dto, err := s.Upload(userID, evil, "", "") + if err != nil { + t.Fatalf("upload evil mime: %v", err) + } + if dto.MimeType != "application/octet-stream" { + t.Errorf("mime inattendu = %q, attendu fallback application/octet-stream", dto.MimeType) + } + + withParams := multipartFileHeader(t, "page.bin", []byte("data")) + withParams.Header.Set("Content-Type", "text/html; charset=utf-8") + dto, err = s.Upload(userID, withParams, "", "") + if err != nil { + t.Fatalf("upload html mime: %v", err) + } + if dto.MimeType != "application/octet-stream" { + t.Errorf("text/html non whitelisté, fallback attendu, got %q", dto.MimeType) + } + + allowed := multipartFileHeader(t, "img.bin", []byte("data")) + allowed.Header.Set("Content-Type", "image/png") + dto, err = s.Upload(userID, allowed, "", "") + if err != nil { + t.Fatalf("upload png mime: %v", err) + } + if dto.MimeType != "image/png" { + t.Errorf("mime whitelisté perdu, got %q", dto.MimeType) + } +} diff --git a/backend/service/services.go b/backend/service/services.go index a9ca25c..ccb1e0b 100644 --- a/backend/service/services.go +++ b/backend/service/services.go @@ -1,31 +1,6 @@ package service -import "github.com/kazier/backend/models" - -type Services struct { - ConnectedUser *models.User -} - -func New(connectedUser *models.User) *Services { - - return &Services{ - ConnectedUser: connectedUser, - } - -} - -func UserCanReadDocument(connectedUser *models.User, document *models.Document) (bool, string) { - return true, "" -} - -func UserCanEditDocument(connectedUser *models.User, document *models.Document) (bool, string) { - return true, "" -} - -func UserCanDeleteDocument(connectedUser *models.User, document *models.Document) (bool, string) { - return true, "" -} - -func UserCanCreateDocument(connectedUser *models.User, document *models.Document) (bool, string) { - return true, "" -} +// Stubs historiques UserCan* (toujours-true) supprimés — LOT 5 #11. +// L'autorisation V1 est portée par le scoping owner (`user_id`) dans +// repository.Resources + les grants `shares` (cf. docs/api-v1.md) : +// aucune fonction toujours-true ne doit subsister ici. diff --git a/backend/service/sync.go b/backend/service/sync.go index 009c891..c4bbe7b 100644 --- a/backend/service/sync.go +++ b/backend/service/sync.go @@ -3,6 +3,7 @@ package service import ( "encoding/json" "errors" + "log" "regexp" "time" @@ -92,33 +93,86 @@ func classifySyncError(err error) (string, string) { return "NOT_FOUND", "target resource or folder not found" case errors.Is(err, repository.ErrGranteeNotFound): return "GRANTEE_NOT_FOUND", "the specified user does not exist" + case errors.Is(err, repository.ErrPayloadMismatch): + return "INVALID_REQUEST", "operation replayed with different payload" + case errors.Is(err, errCycle): + return "INVALID_REQUEST", "cannot move a resource into its own subtree" default: - return "INVALID_REQUEST", err.Error() + // Volontairement générique : ne pas fuir SQL/FS internes (cf. #8). + // Le détail reste côté serveur (logs), le client reçoit un code stable. + log.Printf("sync: internal apply error: %v", err) + return "INVALID_REQUEST", "invalid operation" } } +var errCycle = errors.New("cannot move a resource into its own subtree") + // ApplyBatch applique les ops de l'outbox : les mutations de ressources sont // scopées par l'UTILISATEUR (userID), l'idempotence reste par DEVICE // (deviceID) — cf. docs/api-v1.md §6.1. +// +// Atomicité par op (#7) : chaque op est sérialisée par un claim atomique sur +// la trace outbox (INSERT ... ON CONFLICT DO NOTHING portant la contrainte +// UNIQUE(device_id, operation_id), cf. Operations.Claim) — deux batches +// concurrents ne peuvent pas appliquer deux fois la même op : le perdant +// suit le chemin rejeu (comparaison de hash, cf. A9). Le claim est posé en +// status='failed' AVANT l'apply puis promu en 'applied' (MarkApplied) une +// fois l'effet durable : un crash entre les deux laisse une trace rejouable +// (ré-apply à payload identique), jamais un skip silencieux. +// +// Limite documentée : claim→apply→promote ne sont pas une transaction SQL +// unique — apply touche resources/shares via des statements atomiques +// (INSERT ... SELECT parent, TouchOwned). Le TOCTOU résiduel (deux owners +// créant le même resource_id) dégénère en NAME_CONFLICT explicite, jamais +// en double écriture silencieuse. Une atomicité totale exigerait un +// transaction manager transverse aux repos (vrai Tx ApplyBatch, reportée — +// cf. FEEDBACK risques résiduels). +// +// Erreurs de persistance (claim/promote) : retournées comme applied:i +// explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client +// sait exactement où reprendre. func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) { for i := range ops { op := &ops[i] if err := validateSyncOp(op); err != nil { return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil } - already, err := s.Repository.Operations.Applied(deviceID, op.OperationID) + claimed, err := s.Repository.Operations.Claim(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload) if err != nil { - return SyncResult{}, err + // Faute client (clé ou payload malformé) → INVALID_REQUEST halt, + // message statique sûr ; panne persistance → INTERNAL explicite. + if errors.Is(err, repository.ErrInvalidOperationID) { + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation_id must be 32 lowercase hex chars"}}, nil + } + if errors.Is(err, repository.ErrInvalidPayload) { + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil + } + log.Printf("sync: claim device=%s op=%s: %v", deviceID, op.OperationID, err) + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to persist operation state"}}, nil } - if already { - continue + if !claimed { + // Rejeu : même (device, op) déjà tracé — comparer (A9). + stored, err := s.Repository.Operations.Get(deviceID, op.OperationID) + if err != nil { + log.Printf("sync: replay read device=%s op=%s: %v", deviceID, op.OperationID, err) + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to read operation state"}}, nil + } + if err := stored.MatchesReplay(op.Operation, derefString(op.ResourceID), op.Payload); err != nil { + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation replayed with different payload"}}, nil + } + if stored.Status == repository.OpStatusApplied { + continue // déjà appliquée à l'identique → skip idempotent + } + // Trace 'failed' à payload identique : la première tentative est + // morte avant MarkApplied (crash) → on ré-applique (recovery). } if err := s.applySyncOp(userID, op); err != nil { code, message := classifySyncError(err) return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil } - if err := s.recordApplied(deviceID, op); err != nil { - return SyncResult{}, err + if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil { + log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err) + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "operation applied but trace update failed; safe to retry"}}, nil } } return SyncResult{Applied: len(ops)}, nil @@ -167,29 +221,47 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error { // Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon, // cohérent avec move_resource). Ordre du SAF walk : parent avant enfant. if p.ParentResourceID != "" { + if !resourceIDPattern.MatchString(p.ParentResourceID) { + return errors.New("payload.parentResourceId must be 32 lowercase hex chars") + } if _, err := s.Repo.GetFolder(ownerID, p.ParentResourceID); err != nil { return err } } + var insertErr error if derefString(op.ResourceType) == "folder" { - return s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID) + insertErr = s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID) + } else { + mime := p.MimeType + insertErr = s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension)) } - mime := p.MimeType - return s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension)) + if insertErr != nil { + // Course ExistsOwner→Insert (concurrent ou rejeu croisé) : si la + // ressource est désormais owned, l'effet est atteint → idempotent. + // Sinon NAME_CONFLICT explicite (sibling ou resource_id d'autrui). + // Atomicité totale (INSERT ... SELECT) : inter-lots, LOT 4. + if errors.Is(insertErr, repository.ErrNameConflict) { + if owned, err := s.Repo.ExistsOwner(ownerID, resourceID); err == nil && owned { + return nil + } + } + return insertErr + } + return nil case OpUpdateMetadata: - // Owner can always rename. A shared resource can be renamed by an - // editor+ (docs §6.2 effective_access ranking). Below editor, or on - // a resource the caller cannot reach at all, we keep the documented - // terminal-state semantics: absent → no-op. + // Sémantique uniforme (A8) : toute ressource que l'appelant ne peut + // pas renommer — absente, d'autrui, ou partagée sous editor — halte + // en NOT_FOUND. Pas de no-op silencieux : un rename qui n'a rien + // renommé est un bug client ou une désync, le halt l'expose au lieu + // de valider un état qui n'existe pas. Le même code NOT_FOUND dans + // tous les cas évite tout oracle d'existence. Owner → rank owner, + // editor+ partagé → autorisé (docs §6.2). access, err := s.Repository.Shares.EffectiveAccess(ownerID, resourceID) if err != nil { return err } if access.EffectiveRank < repository.AccessEditor { - if !access.Accessible { - return nil - } return repository.ErrNotFound } var p renamePayload @@ -199,16 +271,17 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error { if p.Name == "" { return errors.New("payload.name required") } - return s.Repo.UpdateNameByID(resourceID, p.Name) + // NOTE : UpdateNameByID (non-scopé) est volontaire ici — un editor + // non-owner peut renommer (EffectiveAccess vérifié plus haut), donc + // UpdateNameOwned(ownerID, ...) rejetterait à tort. La garde + // d'autorisation précède immédiatement l'écriture. + return s.Repo.UpdateNameByID(resourceID, p.Name) case OpMoveResource: - exists, err := s.Repo.ExistsOwner(ownerID, resourceID) - if err != nil { - return err - } - if !exists { - return nil - } + // A8 : move owner-only. Source non-owned (absente OU d'autrui) → + // NOT_FOUND halt (MoveResource ne touche que les lignes owned). + // Pas de applied silencieux : un move qui n'a rien déplacé + // désynchroniserait le client. var p movePayload if err := json.Unmarshal(op.Payload, &p); err != nil { return errors.New("invalid payload: " + err.Error()) @@ -216,9 +289,36 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error { if p.ToFolderResourceID == resourceID { return errors.New("cannot move a resource into itself") } + if p.ToFolderResourceID != "" { + if !resourceIDPattern.MatchString(p.ToFolderResourceID) { + return errors.New("payload.toFolderResourceId must be 32 lowercase hex chars") + } + // Check de cycle : le dossier cible ne doit pas être la ressource + // elle-même ni l'un de ses descendants (cf. FEEDBACK #2). + if err := s.checkNoCycle(p.ToFolderResourceID, resourceID); err != nil { + return err + } + } return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID) case OpDeleteResource: + // A8 : delete owner-only. Ligne vivante d'autrui → NOT_FOUND halt + // (pas de applied silencieux). Aucune ligne vivante (jamais existé, + // ou déjà supprimée par son owner) → no-op idempotent : l'état + // terminal (absente) est déjà atteint, le rejeu reste sûr. + exists, err := s.Repo.ExistsOwner(ownerID, resourceID) + if err != nil { + return err + } + if !exists { + if _, err := s.Repo.GetResourceOwner(resourceID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil + } + return err + } + return repository.ErrNotFound + } return s.Repo.SyncDelete(ownerID, resourceID) case OpShare, OpUpdateShare: @@ -275,13 +375,18 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) var expiresAt *time.Time if p.ExpiresAt != nil { t := time.UnixMilli(*p.ExpiresAt) + if !t.After(time.Now()) { + return errors.New("payload.expiresAt must be in the future") + } expiresAt = &t } if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil { return err } // Bump resource updated_at so the grantee's delta snapshot picks it up. - return s.Repo.TouchResource(resourceID) + // Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le + // TouchResource non-scopé. + return s.Repo.TouchOwned(ownerID, resourceID) } // applyRevokeShareOp handles OpRevokeShare: soft-revoke a user-to-user grant. @@ -303,10 +408,13 @@ func (s *Resources) applyRevokeShareOp(ownerID, resourceID string, op *SyncOpera if !resourceIDPattern.MatchString(p.GranteeUserID) { return errors.New("payload.granteeUserId must be 32 lowercase hex chars") } - // Revoke is idempotent: no-op if already revoked/missing. - _ = s.Repository.Shares.Revoke(resourceID, p.GranteeUserID) + // Revoke is idempotent: no-op if already revoked/missing — mais les vraies + // pannes DB remontent (cf. FEEDBACK §moyenne). + if err := s.Repository.Shares.Revoke(resourceID, p.GranteeUserID); err != nil && !errors.Is(err, repository.ErrNotFound) { + return err + } // Bump resource updated_at so the grantee's delta snapshot reflects the change. - return s.Repo.TouchResource(resourceID) + return s.Repo.TouchOwned(ownerID, resourceID) } // applyCreateLinkOp handles OpCreateLink: create a public share link. @@ -332,12 +440,15 @@ func (s *Resources) applyCreateLinkOp(ownerID, resourceID string, op *SyncOperat var expiresAt *time.Time if p.ExpiresAt != nil { t := time.UnixMilli(*p.ExpiresAt) + if !t.After(time.Now()) { + return errors.New("payload.expiresAt must be in the future") + } expiresAt = &t } if err := s.Repository.Shares.CreateLink(p.Token, resourceID, p.Access, expiresAt, ownerID); err != nil { return err } - return s.Repo.TouchResource(resourceID) + return s.Repo.TouchOwned(ownerID, resourceID) } // applyRevokeLinkOp handles OpRevokeLink: soft-revoke a public share link. @@ -356,13 +467,35 @@ func (s *Resources) applyRevokeLinkOp(ownerID, resourceID string, op *SyncOperat if !resourceIDPattern.MatchString(p.Token) { return errors.New("payload.token must be 32 lowercase hex chars") } - // Revoke is idempotent: no-op if already revoked/missing. - _ = s.Repository.Shares.RevokeLink(p.Token) - return s.Repo.TouchResource(resourceID) + // Revoke is idempotent: no-op if already revoked/missing — mais les vraies + // pannes DB remontent. + if err := s.Repository.Shares.RevokeLink(p.Token); err != nil && !errors.Is(err, repository.ErrNotFound) { + return err + } + return s.Repo.TouchOwned(ownerID, resourceID) } -func (s *Resources) recordApplied(deviceID string, op *SyncOperation) error { - return s.Repository.Operations.Record(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload) +// checkNoCycle remonte la chaîne parentale depuis toFolder : si on rencontre +// resourceID, le move créerait un cycle (cf. FEEDBACK #2). +func (s *Resources) checkNoCycle(toFolderID, resourceID string) error { + cur := toFolderID + for i := 0; i < 128; i++ { + if cur == "" { + return nil + } + if cur == resourceID { + return errCycle + } + parent, err := s.Repo.GetParentID(cur) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return err + } + return err + } + cur = parent + } + return errCycle } func derefString(v *string) string { diff --git a/backend/service/sync_test.go b/backend/service/sync_test.go index 8b4dcbc..dc6fc49 100644 --- a/backend/service/sync_test.go +++ b/backend/service/sync_test.go @@ -208,6 +208,41 @@ func TestApplyBatchMoveToMissingFolder(t *testing.T) { } } +func TestApplyBatchMoveIntoDescendantRejected(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "sync-move-cycle") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + parentID := repository.NewID() + childID := repository.NewID() + if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), parentID, OpCreateResource, "folder", map[string]any{"name": "parent"}), + syncOp(repository.NewID(), childID, OpCreateResource, "folder", map[string]any{"name": "child", "parentResourceId": parentID}), + }); err != nil { + t.Fatalf("apply create parent+child: %v", err) + } + + // Déplacer le parent dans son propre enfant créerait un cycle : halt. + result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), parentID, OpMoveResource, "folder", map[string]any{"toFolderResourceId": childID}), + }) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" { + t.Fatalf("move parent→enfant: attendu applied=0 INVALID_REQUEST, got %+v", result) + } + + // Le parent est toujours à la racine : aucun cycle créé. + got, err := s.Repository.Resources.GetParentID(parentID) + if err != nil { + t.Fatalf("GetParentID: %v", err) + } + if got != "" { + t.Errorf("parent déplacé malgré le rejet: parent=%q", got) + } +} + func TestApplyBatchRejectsInvalidPayloadJSON(t *testing.T) { s := newServiceStore(t) userID := mustCreateUser(t, s.Repository, "sync-badpayload") @@ -1146,15 +1181,16 @@ func TestUpdateMetadataRequiresEditor(t *testing.T) { t.Errorf("viewer update: attendu applied=0 NOT_FOUND, got %+v", result) } - // Stranger (no access) → no-op terminal (absent semantics), no failure. + // Stranger (no access) → NOT_FOUND halt (A8 : pas de no-op silencieux ; + // un rename qui n'a rien renommé est une désync, le halt l'expose). result, err = s.ApplyBatch(strangerID, shareTestDeviceID, []SyncOperation{ syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "sneak.txt"}), }) if err != nil { t.Fatalf("stranger update: %v", err) } - if result.Applied != 1 || result.Failed != nil { - t.Errorf("stranger update: attendu applied=1 aucun échec, got %+v", result) + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" { + t.Errorf("stranger update: attendu applied=0 NOT_FOUND, got %+v", result) } row, err = s.Repo.GetFile(ownerID, fileID) if err != nil || row.Name != "renamed.txt" { @@ -1179,15 +1215,16 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) { t.Fatalf("create + share: %v", err) } - // Editor tries to move the shared file → no-op (owner-only), nothing moves. + // Editor tries to move the shared file → NOT_FOUND halt (A8 : move + // owner-only, pas de applied silencieux). result, err := s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{ syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}), }) if err != nil { t.Fatalf("grantee move: %v", err) } - if result.Applied != 1 || result.Failed != nil { - t.Fatalf("grantee move: applied=%d failed=%+v", result.Applied, result.Failed) + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" { + t.Fatalf("grantee move: attendu applied=0 NOT_FOUND, got %+v", result) } row, err := s.Repo.GetFile(ownerID, fileID) if err != nil { @@ -1197,17 +1234,254 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) { t.Errorf("fichier déplacé par un non-owner: folderId=%q, attendu racine", row.FolderID) } - // Editor tries to delete the shared file → no-op, still present for owner. + // Editor tries to delete the shared file → NOT_FOUND halt (A8), still + // present for owner. result, err = s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{ syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}), }) if err != nil { t.Fatalf("grantee delete: %v", err) } - if result.Applied != 1 || result.Failed != nil { - t.Fatalf("grantee delete: applied=%d failed=%+v", result.Applied, result.Failed) + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" { + t.Fatalf("grantee delete: attendu applied=0 NOT_FOUND, got %+v", result) } if _, err := s.Repo.GetFile(ownerID, fileID); err != nil { t.Errorf("fichier supprimé par un non-owner: %v", err) } } + +// --- LOT 3 : rejeu, payload_hash, liens idempotents, sémantiques A8 --- + +func TestApplyBatchReplaySameOpIsIdempotent(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "replay-owner") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileID := repository.NewID() + opID := repository.NewID() + op := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}) + + result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{op}) + if err != nil || result.Applied != 1 || result.Failed != nil { + t.Fatalf("apply 1: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err) + } + // Rejeu à l'identique (même operation_id, même payload) → skip succès. + result, err = s.ApplyBatch(userID, deviceID, []SyncOperation{op}) + if err != nil || result.Applied != 1 || result.Failed != nil { + t.Errorf("rejeu identique: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err) + } +} + +func TestApplyBatchReplayMutatedPayloadRejected(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "replay-mut") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileID := repository.NewID() + opID := repository.NewID() + first := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}) + if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{first}); err != nil { + t.Fatalf("apply 1: %v", err) + } + // Même (device, operation_id), payload muté → INVALID_REQUEST halt (A9), + // pas de skip silencieux. + mutated := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "y.txt"}) + result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{mutated}) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" { + t.Errorf("payload muté: attendu applied=0 INVALID_REQUEST, got %+v", result) + } + // Même opération rejouée sous un autre type → rejet aussi. + retyped := syncOp(opID, fileID, OpDeleteResource, "file", map[string]any{}) + result, err = s.ApplyBatch(userID, deviceID, []SyncOperation{retyped}) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" { + t.Errorf("type muté: attendu applied=0 INVALID_REQUEST, got %+v", result) + } +} + +func TestApplyBatchReplayWhitespaceEquivalentPayload(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "replay-ws") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileID := repository.NewID() + opID := repository.NewID() + first := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}) + if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{first}); err != nil { + t.Fatalf("apply 1: %v", err) + } + // Même objet, sérialisation différente (espaces) → hash canonique égal → skip. + second := SyncOperation{ + OperationID: opID, + ResourceID: strp(fileID), + ResourceType: strp("file"), + Operation: OpCreateResource, + Payload: json.RawMessage(`{ "name" : "x.txt" }`), + } + result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{second}) + if err != nil || result.Applied != 1 || result.Failed != nil { + t.Errorf("rejeu équivalent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err) + } +} + +func TestCreateLinkReplayIdempotent(t *testing.T) { + s := newServiceStore(t) + ownerID := mustCreateUser(t, s.Repository, "linkreplay-owner") + mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileID := repository.NewID() + if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}), + }); err != nil { + t.Fatalf("create: %v", err) + } + + token := repository.NewID() + link := func(opID string) SyncOperation { + return syncOp(opID, fileID, OpCreateLink, "file", map[string]any{ + "token": token, + "access": "viewer", + }) + } + // Premier create_link. + if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{link(repository.NewID())}); err != nil { + t.Fatalf("create link 1: %v", err) + } + // Rejeu même token, même ressource, même owner (nouvel operation_id) → succès. + result, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{link(repository.NewID())}) + if err != nil || result.Applied != 1 || result.Failed != nil { + t.Errorf("rejeu lien identique: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err) + } +} + +func TestCreateLinkTokenReuseConflict(t *testing.T) { + s := newServiceStore(t) + ownerID := mustCreateUser(t, s.Repository, "linkconf-owner") + mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileA := repository.NewID() + fileB := repository.NewID() + if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileA, OpCreateResource, "file", map[string]any{"name": "a.txt"}), + syncOp(repository.NewID(), fileB, OpCreateResource, "file", map[string]any{"name": "b.txt"}), + }); err != nil { + t.Fatalf("create: %v", err) + } + + token := repository.NewID() + if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileA, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}), + }); err != nil { + t.Fatalf("create link: %v", err) + } + // Même token vers une AUTRE ressource du même owner → NAME_CONFLICT (#3). + result, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileB, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}), + }) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NAME_CONFLICT" { + t.Errorf("token réutilisé: attendu applied=0 NAME_CONFLICT, got %+v", result) + } +} + +func TestCreateLinkTokenOwnerMismatch(t *testing.T) { + s := newServiceStore(t) + owner1 := mustCreateUser(t, s.Repository, "linkown-1") + owner2 := mustCreateUser(t, s.Repository, "linkown-2") + mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileA := repository.NewID() + fileB := repository.NewID() + if _, err := s.ApplyBatch(owner1, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileA, OpCreateResource, "file", map[string]any{"name": "a.txt"}), + }); err != nil { + t.Fatalf("create A: %v", err) + } + if _, err := s.ApplyBatch(owner2, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileB, OpCreateResource, "file", map[string]any{"name": "b.txt"}), + }); err != nil { + t.Fatalf("create B: %v", err) + } + + token := repository.NewID() + if _, err := s.ApplyBatch(owner1, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileA, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}), + }); err != nil { + t.Fatalf("create link: %v", err) + } + // Même token, autre owner → NAME_CONFLICT (#3). + result, err := s.ApplyBatch(owner2, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileB, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}), + }) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NAME_CONFLICT" { + t.Errorf("token d'autrui: attendu applied=0 NAME_CONFLICT, got %+v", result) + } +} + +func TestUpdateMetadataAbsentHalts(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "ren-absent") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + // update_metadata sur ressource inexistante → NOT_FOUND halt (A8). + result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), repository.NewID(), OpUpdateMetadata, "file", map[string]any{"name": "ghost.txt"}), + }) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" { + t.Errorf("rename absent: attendu applied=0 NOT_FOUND, got %+v", result) + } +} + +func TestMoveForeignHalts(t *testing.T) { + s := newServiceStore(t) + ownerID := mustCreateUser(t, s.Repository, "movef-owner") + outsiderID := mustCreateUser(t, s.Repository, "movef-outsider") + mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileID := repository.NewID() + targetID := repository.NewID() + if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}), + syncOp(repository.NewID(), targetID, OpCreateResource, "folder", map[string]any{"name": "t"}), + }); err != nil { + t.Fatalf("create: %v", err) + } + // Move d'une ressource d'autrui (jamais partagée) → NOT_FOUND halt. + result, err := s.ApplyBatch(outsiderID, shareTestDeviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}), + }) + if err != nil { + t.Fatalf("ApplyBatch: %v", err) + } + if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" { + t.Errorf("move étranger: attendu applied=0 NOT_FOUND, got %+v", result) + } +} + +func TestDeleteAbsentIsIdempotentNoop(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "delabsent-owner") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + // Delete d'une ressource sans ligne vivante → no-op idempotent (état + // terminal déjà atteint), pas de halt. + result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), repository.NewID(), OpDeleteResource, "file", map[string]any{}), + }) + if err != nil || result.Applied != 1 || result.Failed != nil { + t.Errorf("delete absent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err) + } +} diff --git a/backend/service/upload.go b/backend/service/upload.go deleted file mode 100644 index 839ee46..0000000 --- a/backend/service/upload.go +++ /dev/null @@ -1,19 +0,0 @@ -package service - -import ( - "fmt" - - "github.com/kazier/backend/models" -) - -func (s *Services) UploadDocument(file *string, destination *models.Document) error { - - if canEdit, _ := UserCanEditDocument(s.ConnectedUser, destination); !canEdit { - return fmt.Errorf("cannot edit document") - } - - models.NewDocument("test", models.FILE, 1) - - return nil - -}