Backend : token_version (000022, claim tv, 401 si révoqué, bump au password — fin limite V1), quota (000023 idempotente, colonne héritée de 000001, 413 QUOTA_EXCEEDED, GET /users/me/usage), devices (GET + DELETE révocation, EnforceDeviceExists en prod), renames concurrents transparents (baseUpdatedAt + conflicts[] non-fataux, tolérance 2 s). Tests service + handlers + migrations + auth. Mobile : pipeline conflits (DTO + SyncConflictStore + worker + dialogue), baseUpdatedAt prêt, liens 7j par défaut, écran Appareils (+ quota), import classeur unifié (scan/note/dossier), onboarding cercle Famille. Contrat docs/api-v1.md, V3.md (S6 livré).
257 lines
8.4 KiB
Go
257 lines
8.4 KiB
Go
package handlers
|
|
|
|
import (
|
|
"errors"
|
|
"log"
|
|
"net/http"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"github.com/kazier/backend/pkg/api"
|
|
"github.com/kazier/backend/pkg/passwd"
|
|
"github.com/kazier/backend/repository"
|
|
"github.com/kazier/backend/service"
|
|
)
|
|
|
|
type LoginRequest struct {
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
DeviceID string `json:"device_id"`
|
|
}
|
|
|
|
type LoginUserDTO struct {
|
|
ID string `json:"id"`
|
|
Username string `json:"username"`
|
|
IsAdmin bool `json:"is_admin"`
|
|
}
|
|
|
|
type LoginResponse struct {
|
|
Token string `json:"token"`
|
|
ExpiresAt int64 `json:"expires_at"`
|
|
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 », « 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")
|
|
return
|
|
}
|
|
|
|
var req LoginRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
|
|
return
|
|
}
|
|
if strings.TrimSpace(req.Username) == "" || req.Password == "" || req.DeviceID == "" {
|
|
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 aléatoire par boot).
|
|
stored := ""
|
|
if userErr == nil && user != nil {
|
|
stored = user.PasswordHash
|
|
}
|
|
if err := passwd.VerifyTimedEqual(req.Password, stored); err != nil {
|
|
if errors.Is(err, passwd.ErrMismatch) {
|
|
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
|
|
return
|
|
}
|
|
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 {
|
|
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not check device")
|
|
return
|
|
}
|
|
if !exists {
|
|
// 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, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID, user.TokenVersion)
|
|
if err != nil {
|
|
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token")
|
|
return
|
|
}
|
|
|
|
api.OK(c, LoginResponse{
|
|
Token: token,
|
|
ExpiresAt: expiresAt.UnixMilli(),
|
|
User: LoginUserDTO{
|
|
ID: user.ID,
|
|
Username: user.Username,
|
|
IsAdmin: user.IsAdmin,
|
|
},
|
|
})
|
|
}
|
|
|
|
type changePasswordRequest struct {
|
|
CurrentPassword string `json:"current_password"`
|
|
NewPassword string `json:"new_password"`
|
|
}
|
|
|
|
// ChangePassword met à jour le hash du compte connecté. Le mot de passe
|
|
// courant est requis. V3 S6 : le changement bumpe `token_version` — tous les
|
|
// autres tokens (autres devices, sessions volées) sont révoqués aussitôt
|
|
// (le token courant aussi : le client doit se reconnecter).
|
|
func ChangePassword(c *gin.Context) {
|
|
if Store == nil || Store.Repository == nil {
|
|
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
|
|
return
|
|
}
|
|
userID := c.GetString(UserIDKey)
|
|
|
|
var req changePasswordRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
|
|
return
|
|
}
|
|
if len(req.NewPassword) < 8 {
|
|
api.Error(c, http.StatusBadRequest, "INVALID_PASSWORD", "new password must be at least 8 characters")
|
|
return
|
|
}
|
|
|
|
user, err := Store.Repository.Users.GetByID(userID)
|
|
if err != nil {
|
|
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "account not found")
|
|
return
|
|
}
|
|
if err := passwd.Verify(req.CurrentPassword, user.PasswordHash); err != nil {
|
|
api.Error(c, http.StatusForbidden, "INVALID_PASSWORD", "current password is incorrect")
|
|
return
|
|
}
|
|
|
|
newHash, err := passwd.Hash(req.NewPassword)
|
|
if err != nil {
|
|
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not hash new password")
|
|
return
|
|
}
|
|
if err := Store.Repository.Users.UpdatePassword(userID, newHash); err != nil {
|
|
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update password")
|
|
return
|
|
}
|
|
// Révocation (V3 S6) : bump best-effort — un échec ici ne doit pas faire
|
|
// croire que le password n'a pas changé (il l'est, ligne ci-dessus).
|
|
if err := Store.Repository.Users.BumpTokenVersion(userID); err != nil {
|
|
log.Printf("auth: bump token_version(%s): %v", userID, err)
|
|
}
|
|
|
|
api.OK(c, gin.H{"id": userID})
|
|
}
|
|
|
|
// ResolveUser résout UN destinataire par username EXACT (normalisé lowercase).
|
|
// Jamais de listing ni de préfixe (pas d'énumération de comptes). Ne renvoie
|
|
// que {id, username} — jamais email/is_admin/created_at.
|
|
func ResolveUser(c *gin.Context) {
|
|
if Store == nil || Store.Repository == nil {
|
|
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
|
|
return
|
|
}
|
|
username := service.NormalizeUsername(c.Query("username"))
|
|
if username == "" {
|
|
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "username is required")
|
|
return
|
|
}
|
|
|
|
user, err := Store.Repository.Users.ResolveExact(username)
|
|
if errors.Is(err, repository.ErrNotFound) {
|
|
api.Error(c, http.StatusNotFound, "NOT_FOUND", "user not found")
|
|
return
|
|
}
|
|
if err != nil {
|
|
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not resolve user")
|
|
return
|
|
}
|
|
|
|
api.OK(c, gin.H{"id": user.ID, "username": user.Username})
|
|
}
|