Up And Down : première version
This commit is contained in:
commit
89c5430308
76 files changed
+20730
No files matched your search
@@ -0,0 +1,256 @@
|
||||
package auth
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Auth réunit l'authentification locale (comptes, inscription) et OIDC derrière
|
||||
// une même session : cookie signé, vérifié à chaque requête contre l'état du
|
||||
// compte (désactivé, supprimé, rôle modifié : effet immédiat).
|
||||
//
|
||||
// POST /auth/local/login {"username","password"}
|
||||
// POST /auth/local/register {"username","name","email","password"}
|
||||
// GET /auth/login connexion OIDC (si activée)
|
||||
// GET /auth/logout déconnexion (propagée au fournisseur OIDC)
|
||||
type Auth struct {
|
||||
Accounts *Accounts
|
||||
Sessions *Sessions
|
||||
OIDC *OIDC // nil : OIDC désactivé
|
||||
Local bool // comptes locaux activés
|
||||
// Registration renvoie le mode d'inscription courant : closed, approval ou open.
|
||||
Registration func() string
|
||||
// OIDCName : libellé du bouton de connexion OIDC.
|
||||
OIDCName string
|
||||
|
||||
logins *Limiter
|
||||
regs *Limiter
|
||||
}
|
||||
|
||||
// New prépare l'authentification ; Accounts et Sessions sont obligatoires.
|
||||
func New(a *Auth) *Auth {
|
||||
a.logins = NewLimiter(10, 15*time.Minute)
|
||||
a.regs = NewLimiter(5, time.Hour)
|
||||
if a.Registration == nil {
|
||||
a.Registration = func() string { return "closed" }
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// OnlyOIDC indique que la connexion passe uniquement par le fournisseur OIDC.
|
||||
func (a *Auth) OnlyOIDC() bool { return a.OIDC != nil && !a.Local }
|
||||
|
||||
// Register ajoute les routes /auth/*.
|
||||
func (a *Auth) Register(mux *http.ServeMux) {
|
||||
if a.OIDC != nil {
|
||||
a.OIDC.RegisterLogin(mux)
|
||||
}
|
||||
if a.Local {
|
||||
mux.HandleFunc("POST /auth/local/login", a.localLogin)
|
||||
mux.HandleFunc("POST /auth/local/register", a.localRegister)
|
||||
}
|
||||
mux.HandleFunc("GET /auth/logout", a.logout)
|
||||
mux.HandleFunc("POST /auth/logout", a.logout)
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
|
||||
func writeErr(w http.ResponseWriter, status int, msg string) {
|
||||
writeJSON(w, status, map[string]string{"error": msg})
|
||||
}
|
||||
|
||||
// clientIP : adresse du client. Derrière un reverse proxy, l'entrée la plus à
|
||||
// droite de X-Forwarded-For est celle qu'il a ajoutée.
|
||||
func clientIP(r *http.Request) string {
|
||||
if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
|
||||
parts := strings.Split(xff, ",")
|
||||
if ip := strings.TrimSpace(parts[len(parts)-1]); ip != "" {
|
||||
return ip
|
||||
}
|
||||
}
|
||||
host, _, err := net.SplitHostPort(r.RemoteAddr)
|
||||
if err != nil {
|
||||
return r.RemoteAddr
|
||||
}
|
||||
return host
|
||||
}
|
||||
|
||||
type credentials struct {
|
||||
Username string `json:"username"`
|
||||
Name string `json:"name"`
|
||||
Email string `json:"email"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
func decodeJSON(w http.ResponseWriter, r *http.Request, v any) bool {
|
||||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(v); err != nil {
|
||||
writeErr(w, http.StatusBadRequest, "requête JSON invalide")
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (a *Auth) localLogin(w http.ResponseWriter, r *http.Request) {
|
||||
var c credentials
|
||||
if !decodeJSON(w, r, &c) {
|
||||
return
|
||||
}
|
||||
userKey, ipKey := "u:"+strings.ToLower(strings.TrimSpace(c.Username)), "ip:"+clientIP(r)
|
||||
if !a.logins.Allowed(userKey) || !a.logins.Allowed(ipKey) {
|
||||
w.Header().Set("Retry-After", "900")
|
||||
writeErr(w, http.StatusTooManyRequests, "trop de tentatives : réessayer dans quelques minutes")
|
||||
return
|
||||
}
|
||||
acc, err := a.Accounts.Authenticate(c.Username, c.Password)
|
||||
switch err {
|
||||
case nil:
|
||||
case ErrBadCredentials:
|
||||
a.logins.Fail(userKey)
|
||||
a.logins.Fail(ipKey)
|
||||
writeErr(w, http.StatusUnauthorized, err.Error())
|
||||
return
|
||||
case ErrPending, ErrDisabled:
|
||||
writeJSON(w, http.StatusForbidden, map[string]string{"error": err.Error(), "code": codeOf(err)})
|
||||
return
|
||||
default:
|
||||
slog.Error("connexion locale", "err", err)
|
||||
writeErr(w, http.StatusInternalServerError, "erreur interne")
|
||||
return
|
||||
}
|
||||
a.logins.Reset(userKey)
|
||||
if err := a.Sessions.Start(w, r, acc.User()); err != nil {
|
||||
writeErr(w, http.StatusInternalServerError, "erreur interne")
|
||||
return
|
||||
}
|
||||
slog.Info("connexion locale", "user", acc.ID)
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func codeOf(err error) string {
|
||||
if err == ErrPending {
|
||||
return "pending"
|
||||
}
|
||||
return "disabled"
|
||||
}
|
||||
|
||||
func (a *Auth) localRegister(w http.ResponseWriter, r *http.Request) {
|
||||
var c credentials
|
||||
if !decodeJSON(w, r, &c) {
|
||||
return
|
||||
}
|
||||
setup := a.Accounts.NeedsSetup() // premier compte : administrateur, même si les inscriptions sont fermées
|
||||
mode := a.Registration()
|
||||
if mode == "closed" && !setup {
|
||||
writeErr(w, http.StatusForbidden, "les inscriptions sont fermées")
|
||||
return
|
||||
}
|
||||
ipKey := "reg:" + clientIP(r)
|
||||
if !setup && !a.regs.Allowed(ipKey) {
|
||||
w.Header().Set("Retry-After", "3600")
|
||||
writeErr(w, http.StatusTooManyRequests, "trop d'inscriptions depuis cette adresse")
|
||||
return
|
||||
}
|
||||
status := StatusActive
|
||||
if mode == "approval" {
|
||||
status = StatusPending
|
||||
}
|
||||
acc, err := a.Accounts.CreateLocal(NewAccount{Username: c.Username, Name: c.Name, Email: c.Email,
|
||||
Password: c.Password, Status: status})
|
||||
if err != nil {
|
||||
code := http.StatusBadRequest
|
||||
if err == ErrAccountExists {
|
||||
code = http.StatusConflict
|
||||
}
|
||||
writeErr(w, code, err.Error())
|
||||
return
|
||||
}
|
||||
if !setup {
|
||||
a.regs.Fail(ipKey)
|
||||
}
|
||||
slog.Info("inscription", "user", acc.ID, "status", acc.Status, "role", acc.Role)
|
||||
if acc.Status == StatusPending {
|
||||
writeJSON(w, http.StatusAccepted, map[string]string{"status": StatusPending})
|
||||
return
|
||||
}
|
||||
if err := a.Sessions.Start(w, r, acc.User()); err != nil {
|
||||
writeErr(w, http.StatusInternalServerError, "erreur interne")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, map[string]string{"status": StatusActive})
|
||||
}
|
||||
|
||||
func (a *Auth) logout(w http.ResponseWriter, r *http.Request) {
|
||||
if s, ok := a.Sessions.Get(r); ok && s.Provider == ProviderOIDC && a.OIDC != nil {
|
||||
a.OIDC.logout(w, r)
|
||||
return
|
||||
}
|
||||
a.Sessions.Clear(w, r)
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
http.Redirect(w, r, "/", http.StatusSeeOther)
|
||||
}
|
||||
|
||||
// current renvoie l'utilisateur de la session : le compte doit exister et être
|
||||
// actif ; son rôle est celui du compte. La session est prolongée passée la
|
||||
// moitié de sa durée.
|
||||
func (a *Auth) current(w http.ResponseWriter, r *http.Request) (*User, bool) {
|
||||
s, ok := a.Sessions.Get(r)
|
||||
if !ok {
|
||||
return nil, false
|
||||
}
|
||||
acc, ok := a.Accounts.Get(s.ID)
|
||||
if !ok || acc.Status != StatusActive {
|
||||
a.Sessions.Clear(w, r)
|
||||
return nil, false
|
||||
}
|
||||
u := acc.User()
|
||||
if time.Until(time.Unix(s.Exp, 0)) < a.Sessions.TTL/2 {
|
||||
_ = a.Sessions.Start(w, r, u)
|
||||
}
|
||||
return &u, true
|
||||
}
|
||||
|
||||
// Middleware exige une session sauf pour /auth/* et les chemins publics. Sans
|
||||
// session : l'API répond 401 ; une navigation reçoit l'application, qui affiche
|
||||
// la page de connexion (ou, avec OIDC seul, est renvoyée vers le fournisseur).
|
||||
func (a *Auth) Middleware(next http.Handler, public func(string) bool) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
p := r.URL.Path
|
||||
if strings.HasPrefix(p, "/auth/") || public(p) {
|
||||
if u, ok := a.current(w, r); ok { // identité disponible sur les routes publiques (ex. /api/me)
|
||||
r = r.WithContext(WithUser(r.Context(), u))
|
||||
}
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
u, ok := a.current(w, r)
|
||||
if ok {
|
||||
next.ServeHTTP(w, r.WithContext(WithUser(r.Context(), u)))
|
||||
return
|
||||
}
|
||||
if strings.HasPrefix(p, "/api/") || r.Method != http.MethodGet {
|
||||
if a.OnlyOIDC() {
|
||||
w.Header().Set(LoginHeader, "/auth/login")
|
||||
}
|
||||
writeErr(w, http.StatusUnauthorized, "connexion nécessaire")
|
||||
return
|
||||
}
|
||||
if a.OnlyOIDC() {
|
||||
loginRedirect(w)
|
||||
return
|
||||
}
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
// UserContext renvoie ctx portant l'utilisateur u (jetons d'API).
|
||||
func UserContext(ctx context.Context, u *User) context.Context { return WithUser(ctx, u) }
|
||||
Reference in new issue
Block a user