Repository Public
1/**2 * =============================================================================3 * SP BOUCHER | INFRASTRUCTURE & AUTOMATION4 * ARTIFICIAL INTELLIGENCE • FINANCE • ENGINEERING5 * =============================================================================6 *7 * Project : MacLustr Command Center (MCC)8 * File : services/internal/identity/sessions.go9 * Module : services10 * Repository : https://git.spboucher.ai/maclustr-command-center11 * Project Website : https://clustr.spboucher.ai12 * Created : 2026-11-1813 * Last Modified : 2026-11-1814 *15 * Author : Simon-Pierre Boucher16 * Position : Professor of Finance17 * Institution : Université du Québec en Outaouais (UQO)18 * Organization : SP Boucher19 * Website : https://spboucher.ai20 * Git : https://git.spboucher.ai21 *22 * Preferred Contact: admin@spboucher.ai23 * Technical Contact: dev@spboucher.ai24 * Security/Admin : admin@spboucher.ai25 *26 * Copyright (c) 202627 * Simon-Pierre Boucher28 * All rights reserved where applicable. This file is governed by the29 * applicable project license, copyright notices and relevant law.30 * Existing third-party rights and notices remain unaffected.31 *32 * License : None specified (no license file in this repository)33 *34 * Do not embed credentials, private keys, access tokens,35 * certificates or confidential personal information.36 *37 * =============================================================================38 * END OF SP BOUCHER SOURCE HEADER39 * =============================================================================40 */4142package identity4344import (45 "context"46 "errors"47 "time"4849 "github.com/google/uuid"50 "github.com/jackc/pgx/v5"5152 "clustr.spboucher.ai/mcc/internal/audit"53 "clustr.spboucher.ai/mcc/internal/authz"54 "clustr.spboucher.ai/mcc/internal/httpx"55 "clustr.spboucher.ai/mcc/internal/ids"56 "clustr.spboucher.ai/mcc/internal/secret"57)5859// issueSession creates the device (or reuses the caller's own, non-revoked60// one) and a session, inside tx.61func (s *Service) issueSession(ctx context.Context, tx pgx.Tx, user User, passkeyID *uuid.UUID, client ClientInfo, meta ReqMeta) (*AuthResult, error) {62 if !client.valid() {63 return nil, httpx.Validation("client.kind must be web, macos or ios.")64 }65 now := s.now()66 res := &AuthResult{User: user}6768 // Device: reuse only a device that belongs to this user, has this kind and is not revoked.69 var dev Device70 found := false71 if client.DeviceID != nil {72 err := tx.QueryRow(ctx, `update devices set last_seen_at=$3, label=case when $4<>'' then $4 else label end,73 model=case when $5<>'' then $5 else model end, os_version=case when $6<>'' then $6 else os_version end,74 app_version=case when $7<>'' then $7 else app_version end75 where id=$1 and user_id=$2 and kind=$8::device_kind and revoked_at is null76 returning id, user_id, kind::text, label, model, os_version, app_version, created_at, last_seen_at`,77 *client.DeviceID, user.ID, now, trunc(client.Label, 80), trunc(client.Model, 80), trunc(client.OSVersion, 40), trunc(client.AppVersion, 40), client.Kind).78 Scan(&dev.ID, &dev.UserID, &dev.Kind, &dev.Label, &dev.Model, &dev.OSVersion, &dev.AppVersion, &dev.CreatedAt, &dev.LastSeenAt)79 if err == nil {80 found = true81 } else if !errors.Is(err, pgx.ErrNoRows) {82 return nil, err83 }84 }85 if !found {86 dev = Device{ID: ids.New(), UserID: user.ID, Kind: client.Kind, Label: trunc(client.Label, 80), Model: trunc(client.Model, 80),87 OSVersion: trunc(client.OSVersion, 40), AppVersion: trunc(client.AppVersion, 40), CreatedAt: now, LastSeenAt: &now}88 if _, err := tx.Exec(ctx, `insert into devices(id,user_id,kind,label,model,os_version,app_version,created_at,last_seen_at)89 values ($1,$2,$3::device_kind,$4,$5,$6,$7,$8,$8)`, dev.ID, user.ID, dev.Kind, dev.Label, dev.Model, dev.OSVersion, dev.AppVersion, now); err != nil {90 return nil, err91 }92 }93 res.Device = dev9495 sess := Session{ID: ids.New(), User: user, DeviceID: dev.ID, PasskeyID: passkeyID, CreatedAt: now, LastSeenAt: now, AuthenticatedAt: now, UserAgent: trunc(meta.UserAgent, 300)}96 var ip *string97 if meta.IP != nil {98 v := meta.IP.String()99 ip, sess.IP = &v, v100 }101 var tokenHash []byte102 var accessExp *time.Time103 if client.Kind == "web" {104 sess.Kind = "cookie"105 res.SessionToken, tokenHash = secret.NewToken()106 sess.IdleExpiresAt, sess.AbsoluteExpiresAt = now.Add(s.cfg.SessionIdle), now.Add(s.cfg.SessionAbsolute)107 } else {108 sess.Kind = "bearer"109 res.AccessToken, tokenHash = secret.NewToken()110 res.AccessExpiresAt = now.Add(s.cfg.AccessTTL)111 accessExp = &res.AccessExpiresAt112 sess.IdleExpiresAt, sess.AbsoluteExpiresAt = now.Add(s.cfg.RefreshTTL), now.Add(bearerAbsolute)113 }114 if _, err := tx.Exec(ctx, `insert into sessions(id,user_id,device_id,kind,token_hash,access_expires_at,passkey_id,created_at,last_seen_at,115 authenticated_at,idle_expires_at,absolute_expires_at,ip,user_agent)116 values ($1,$2,$3,$4::session_kind,$5,$6,$7,$8,$8,$8,$9,$10,$11::inet,$12)`,117 sess.ID, user.ID, dev.ID, sess.Kind, tokenHash, accessExp, passkeyID, now, sess.IdleExpiresAt, sess.AbsoluteExpiresAt, ip, sess.UserAgent); err != nil {118 return nil, err119 }120 if sess.Kind == "bearer" {121 var rh []byte122 res.RefreshToken, rh = secret.NewToken()123 if _, err := tx.Exec(ctx, `insert into refresh_tokens(id,session_id,token_hash,issued_at,expires_at) values ($1,$2,$3,$4,$5)`,124 ids.New(), sess.ID, rh, now, now.Add(s.cfg.RefreshTTL)); err != nil {125 return nil, err126 }127 }128 res.Session = sess129 return res, nil130}131132func trunc(s string, n int) string {133 r := []rune(s)134 if len(r) > n {135 return string(r[:n])136 }137 return s138}139140const sessionSelect = `select s.id, s.kind::text, s.device_id, s.passkey_id, s.created_at, s.last_seen_at, s.authenticated_at,141 s.idle_expires_at, s.absolute_expires_at, coalesce(host(s.ip),''), coalesce(s.user_agent,''), s.revoked_at, s.access_expires_at,142 d.revoked_at, ` + userCols + ` from sessions s join users u on u.id=s.user_id join devices d on d.id=s.device_id `143144func scanSession(row pgx.Row) (Session, *time.Time, *time.Time, error) {145 var s Session146 var accessExp, devRevoked *time.Time147 u, err := scanUserPrefixed(row, &s.ID, &s.Kind, &s.DeviceID, &s.PasskeyID, &s.CreatedAt, &s.LastSeenAt, &s.AuthenticatedAt,148 &s.IdleExpiresAt, &s.AbsoluteExpiresAt, &s.IP, &s.UserAgent, &s.RevokedAt, &accessExp, &devRevoked)149 s.User = u150 return s, accessExp, devRevoked, err151}152153func scanUserPrefixed(row pgx.Row, prefix ...any) (User, error) {154 var u User155 var role string156 dst := append(prefix, &u.ID, &u.Handle, &u.DisplayName, &role, &u.Locale, &u.WebAuthnHandle, &u.CreatedAt, &u.DisabledAt)157 err := row.Scan(dst...)158 u.Role = authz.Role(role)159 return u, err160}161162// Authenticate resolves a presented session token (cookie value or bearer163// access token). Every failure is the same opaque error.164func (s *Service) Authenticate(ctx context.Context, token, kind string) (*Session, error) {165 hash, err := secret.Parse(token)166 if err != nil {167 return nil, httpx.ErrUnauthenticated168 }169 sess, accessExp, devRevoked, err := scanSession(s.pool.QueryRow(ctx, sessionSelect+`where s.token_hash=$1 and s.kind=$2::session_kind`, hash, kind))170 if errors.Is(err, pgx.ErrNoRows) {171 return nil, httpx.ErrUnauthenticated172 } else if err != nil {173 return nil, err174 }175 now := s.now()176 switch {177 case sess.RevokedAt != nil, devRevoked != nil, sess.User.DisabledAt != nil,178 !now.Before(sess.IdleExpiresAt), !now.Before(sess.AbsoluteExpiresAt),179 kind == "bearer" && (accessExp == nil || !now.Before(*accessExp)):180 return nil, httpx.ErrUnauthenticated181 }182 // Sliding idle window for cookie sessions; bearer sessions slide on refresh only.183 if now.Sub(sess.LastSeenAt) >= touchEvery {184 idle := sess.IdleExpiresAt185 if kind == "cookie" {186 idle = now.Add(s.cfg.SessionIdle)187 if idle.After(sess.AbsoluteExpiresAt) {188 idle = sess.AbsoluteExpiresAt189 }190 }191 if _, err := s.pool.Exec(ctx, `update sessions set last_seen_at=$2, idle_expires_at=$3 where id=$1 and revoked_at is null`, sess.ID, now, idle); err != nil {192 return nil, err193 }194 s.pool.Exec(ctx, `update devices set last_seen_at=$2 where id=$1`, sess.DeviceID, now)195 sess.LastSeenAt, sess.IdleExpiresAt = now, idle196 }197 return &sess, nil198}199200// Refresh rotates a native session's tokens. Presenting a refresh token that201// was already rotated means it leaked or was replayed: the whole session is202// revoked and the event audited.203func (s *Service) Refresh(ctx context.Context, refreshToken string, meta ReqMeta) (*AuthResult, error) {204 hash, err := secret.Parse(refreshToken)205 if err != nil {206 return nil, ErrRefresh207 }208 tx, err := s.pool.Begin(ctx)209 if err != nil {210 return nil, err211 }212 defer tx.Rollback(ctx)213 var (214 rtID, sessID uuid.UUID215 usedAt *time.Time216 expiresAt time.Time217 )218 err = tx.QueryRow(ctx, `select id, session_id, used_at, expires_at from refresh_tokens where token_hash=$1 for update`, hash).219 Scan(&rtID, &sessID, &usedAt, &expiresAt)220 if errors.Is(err, pgx.ErrNoRows) {221 return nil, ErrRefresh222 } else if err != nil {223 return nil, err224 }225 sess, _, devRevoked, err := scanSession(tx.QueryRow(ctx, sessionSelect+`where s.id=$1 for update of s`, sessID))226 if err != nil {227 return nil, err228 }229 now := s.now()230 if usedAt != nil {231 if sess.RevokedAt == nil {232 if _, err := tx.Exec(ctx, `update sessions set revoked_at=$2, revoked_reason='refresh_reuse' where id=$1`, sessID, now); err != nil {233 return nil, err234 }235 if err := s.audit(ctx, tx, &sess, meta, "session.refresh_reuse_detected", "session", sessID.String(), audit.Denied,236 "a rotated refresh token was presented again; session revoked", nil); err != nil {237 return nil, err238 }239 if err := tx.Commit(ctx); err != nil {240 return nil, err241 }242 }243 return nil, ErrRefresh244 }245 if sess.RevokedAt != nil || devRevoked != nil || sess.User.DisabledAt != nil || sess.Kind != "bearer" ||246 !now.Before(expiresAt) || !now.Before(sess.AbsoluteExpiresAt) {247 return nil, ErrRefresh248 }249 res := &AuthResult{User: sess.User}250 var accessHash, refreshHash []byte251 res.AccessToken, accessHash = secret.NewToken()252 res.RefreshToken, refreshHash = secret.NewToken()253 res.AccessExpiresAt = now.Add(s.cfg.AccessTTL)254 newID := ids.New()255 refreshExp := now.Add(s.cfg.RefreshTTL)256 if refreshExp.After(sess.AbsoluteExpiresAt) {257 refreshExp = sess.AbsoluteExpiresAt258 }259 if _, err := tx.Exec(ctx, `insert into refresh_tokens(id,session_id,token_hash,issued_at,expires_at) values ($1,$2,$3,$4,$5)`,260 newID, sessID, refreshHash, now, refreshExp); err != nil {261 return nil, err262 }263 if _, err := tx.Exec(ctx, `update refresh_tokens set used_at=$2, replaced_by=$3 where id=$1`, rtID, now, newID); err != nil {264 return nil, err265 }266 if _, err := tx.Exec(ctx, `update sessions set token_hash=$2, access_expires_at=$3, last_seen_at=$4, idle_expires_at=$5 where id=$1`,267 sessID, accessHash, res.AccessExpiresAt, now, refreshExp); err != nil {268 return nil, err269 }270 if err := tx.Commit(ctx); err != nil {271 return nil, err272 }273 sess.LastSeenAt, sess.IdleExpiresAt = now, refreshExp274 res.Session = sess275 return res, nil276}277278// RevokeSession ends one session. A user may always end their own; ending279// someone else's is authorized by the caller (users.manage) before calling.280func (s *Service) RevokeSession(ctx context.Context, actor *Session, sessionID uuid.UUID, reason string, meta ReqMeta) error {281 tx, err := s.pool.Begin(ctx)282 if err != nil {283 return err284 }285 defer tx.Rollback(ctx)286 var owner uuid.UUID287 err = tx.QueryRow(ctx, `update sessions set revoked_at=$2, revoked_reason=$3 where id=$1 and revoked_at is null returning user_id`,288 sessionID, s.now(), reason).Scan(&owner)289 if errors.Is(err, pgx.ErrNoRows) {290 return httpx.ErrNotFound291 } else if err != nil {292 return err293 }294 if err := s.audit(ctx, tx, actor, meta, "session.revoke", "session", sessionID.String(), audit.Success, reason,295 map[string]any{"user_id": owner.String()}); err != nil {296 return err297 }298 return tx.Commit(ctx)299}300301// SessionOwner returns the user a session belongs to.302func (s *Service) SessionOwner(ctx context.Context, sessionID uuid.UUID) (uuid.UUID, error) {303 var id uuid.UUID304 err := s.pool.QueryRow(ctx, `select user_id from sessions where id=$1`, sessionID).Scan(&id)305 if errors.Is(err, pgx.ErrNoRows) {306 return id, httpx.ErrNotFound307 }308 return id, err309}310311func (s *Service) ListSessions(ctx context.Context, userID uuid.UUID) ([]Session, error) {312 rows, err := s.pool.Query(ctx, sessionSelect+`where s.user_id=$1 and s.revoked_at is null and s.idle_expires_at > $2 and s.absolute_expires_at > $2313 order by s.last_seen_at desc`, userID, s.now())314 if err != nil {315 return nil, err316 }317 return pgx.CollectRows(rows, func(r pgx.CollectableRow) (Session, error) {318 sess, _, _, err := scanSession(r)319 return sess, err320 })321}322323const deviceCols = `id, user_id, kind::text, label, model, os_version, app_version, created_at, last_seen_at, revoked_at, push_token is not null`324325func scanDevice(r pgx.Row) (Device, error) {326 var d Device327 err := r.Scan(&d.ID, &d.UserID, &d.Kind, &d.Label, &d.Model, &d.OSVersion, &d.AppVersion, &d.CreatedAt, &d.LastSeenAt, &d.RevokedAt, &d.HasPush)328 return d, err329}330331func (s *Service) ListDevices(ctx context.Context, userID uuid.UUID) ([]Device, error) {332 rows, err := s.pool.Query(ctx, `select `+deviceCols+` from devices where user_id=$1 order by coalesce(last_seen_at, created_at) desc`, userID)333 if err != nil {334 return nil, err335 }336 return pgx.CollectRows(rows, func(r pgx.CollectableRow) (Device, error) { return scanDevice(r) })337}338339func (s *Service) DeviceOwner(ctx context.Context, deviceID uuid.UUID) (uuid.UUID, error) {340 var id uuid.UUID341 err := s.pool.QueryRow(ctx, `select user_id from devices where id=$1`, deviceID).Scan(&id)342 if errors.Is(err, pgx.ErrNoRows) {343 return id, httpx.ErrNotFound344 }345 return id, err346}347348// RevokeDevice revokes a device, all its sessions and its push token, atomically.349func (s *Service) RevokeDevice(ctx context.Context, actor *Session, deviceID uuid.UUID, meta ReqMeta) error {350 tx, err := s.pool.Begin(ctx)351 if err != nil {352 return err353 }354 defer tx.Rollback(ctx)355 now := s.now()356 var owner uuid.UUID357 err = tx.QueryRow(ctx, `update devices set revoked_at=$2, push_token=null where id=$1 and revoked_at is null returning user_id`, deviceID, now).Scan(&owner)358 if errors.Is(err, pgx.ErrNoRows) {359 return httpx.ErrNotFound360 } else if err != nil {361 return err362 }363 tag, err := tx.Exec(ctx, `update sessions set revoked_at=$2, revoked_reason='device_revoked' where device_id=$1 and revoked_at is null`, deviceID, now)364 if err != nil {365 return err366 }367 if err := s.audit(ctx, tx, actor, meta, "device.revoke", "device", deviceID.String(), audit.Success, "",368 map[string]any{"user_id": owner.String(), "sessions_revoked": tag.RowsAffected()}); err != nil {369 return err370 }371 return tx.Commit(ctx)372}373374// SetPushToken stores the APNs token of the session's device.375func (s *Service) SetPushToken(ctx context.Context, sess *Session, token, env string) error {376 if env != "development" && env != "production" {377 return httpx.Validation("environment must be development or production.")378 }379 if n := len(token); n < 32 || n > 200 {380 return httpx.Validation("Invalid push token.")381 }382 for _, c := range token {383 if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F') {384 return httpx.Validation("Invalid push token.")385 }386 }387 _, err := s.pool.Exec(ctx, `update devices set push_token=$2, push_env=$3 where id=$1 and revoked_at is null`, sess.DeviceID, token, env)388 return err389}390391// MarkStepUp records a fresh passkey verification on the session.392func (s *Service) markStepUp(ctx context.Context, tx pgx.Tx, sessionID uuid.UUID) error {393 _, err := tx.Exec(ctx, `update sessions set authenticated_at=$2 where id=$1`, sessionID, s.now())394 return err395}396397// CleanupExpired removes dead rows. Safe to run from any service instance.398func (s *Service) CleanupExpired(ctx context.Context) error {399 now := s.now()400 for _, q := range []string{401 `delete from webauthn_challenges where expires_at < $1::timestamptz - interval '1 hour'`,402 `delete from refresh_tokens where expires_at < $1::timestamptz - interval '7 days'`,403 `delete from invitation_transactions where expires_at < $1::timestamptz - interval '30 days'`,404 } {405 if _, err := s.pool.Exec(ctx, q, now); err != nil {406 return err407 }408 }409 return nil410}411