Repository Public
1package api23import (4 "context"5 "encoding/hex"6 "errors"7 "slices"8 "strings"910 "github.com/google/uuid"11 "github.com/jackc/pgx/v5"1213 "clustr.spboucher.ai/mcc/internal/audit"14 "clustr.spboucher.ai/mcc/internal/authz"15 "clustr.spboucher.ai/mcc/internal/httpx"16 "clustr.spboucher.ai/mcc/internal/identity"17)1819// ── Users ──────────────────────────────────────────────────────────────────2021const admUserCols = `u.id, u.handle::text, u.display_name, u.role::text, u.locale, u.created_at, u.disabled_at,22 (select count(*) from passkeys p where p.user_id = u.id and p.revoked_at is null),23 (select max(s.last_seen_at) from sessions s where s.user_id = u.id)`2425func admScanUser(row pgx.Row) (User, error) {26 var u User27 var role, locale string28 var passkeys int29 err := row.Scan(&u.Id, &u.Handle, &u.DisplayName, &role, &locale, &u.CreatedAt, &u.DisabledAt, &passkeys, &u.LastSeenAt)30 u.Role, u.Locale, u.Disabled, u.PasskeyCount = UserRole(role), UserLocale(locale), u.DisabledAt != nil, &passkeys31 return u, err32}3334func (h *adminHandlers) adminUser(ctx context.Context, id uuid.UUID) (User, error) {35 u, err := admScanUser(h.Pool.QueryRow(ctx, `select `+admUserCols+` from users u where u.id = $1`, id))36 if errors.Is(err, pgx.ErrNoRows) {37 return u, httpx.ErrNotFound38 }39 return u, err40}4142func (h *adminHandlers) ListUsers(ctx context.Context, req ListUsersRequestObject) (ListUsersResponseObject, error) {43 p := req.Params44 limit, err := clLimit(p.Limit)45 if err != nil {46 return nil, err47 }48 q, err := clQuery(p.Q)49 if err != nil {50 return nil, err51 }52 b := &clSQL{}53 if q != "" {54 a := b.arg(clLike(q))55 b.and(`(u.handle::text ilike ` + a + ` escape '\' or u.display_name ilike ` + a + ` escape '\')`)56 }57 if p.Role != nil {58 if !authz.Role(*p.Role).Valid() {59 return nil, clInvalid("role", "must be owner, admin, operator or viewer")60 }61 b.and("u.role = " + b.arg(string(*p.Role)) + "::user_role")62 }63 if p.Disabled != nil {64 if *p.Disabled {65 b.and("u.disabled_at is not null")66 } else {67 b.and("u.disabled_at is null")68 }69 }70 cur, err := clDecodeCursor(p.Cursor, "users", 3)71 if err != nil {72 return nil, err73 }74 orderBy, err := b.clKeyset("lower(u.handle::text)", "text", "u.id", false, cur)75 if err != nil {76 return nil, err77 }78 // Handles are restricted to [a-z0-9._-] by the schema, so the handle itself is the sort key.79 rows, err := h.Pool.Query(ctx, `select `+admUserCols+` from users u`+b.where()+orderBy+` limit `+b.arg(limit+1), b.args...)80 if err != nil {81 return nil, err82 }83 items, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (User, error) { return admScanUser(r) })84 if err != nil {85 return nil, err86 }87 out := UserList{Items: items}88 if len(items) > limit {89 out.Items = items[:limit]90 last := out.Items[limit-1]91 out.NextCursor = clEncodeCursor("users", "0", strings.ToLower(last.Handle), last.Id.String())92 }93 if out.Items == nil {94 out.Items = []User{}95 }96 return ListUsers200JSONResponse{Body: out}, nil97}9899func (h *adminHandlers) GetUser(ctx context.Context, req GetUserRequestObject) (GetUserResponseObject, error) {100 u, err := h.adminUser(ctx, req.Id)101 if err != nil {102 return nil, err103 }104 return GetUser200JSONResponse{Body: u}, nil105}106107// UpdateUser changes a role or the disabled state. The rules live in108// identity.UpdateUser: no self-modification, only an owner touches an owner,109// the last active owner is protected, disabling revokes every session.110func (h *adminHandlers) UpdateUser(ctx context.Context, req UpdateUserRequestObject) (UpdateUserResponseObject, error) {111 if req.Body == nil {112 return nil, httpx.Validation("Body required.")113 }114 if req.Body.Role == nil && req.Body.Disabled == nil {115 return nil, httpx.Validation("Nothing to update: give role or disabled.")116 }117 var role *authz.Role118 if req.Body.Role != nil {119 r := authz.Role(*req.Body.Role)120 if !r.Valid() {121 return nil, clInvalid("role", "must be owner, admin, operator or viewer")122 }123 role = &r124 }125 if _, err := h.Identity.UpdateUser(ctx, principalFrom(ctx).Session, req.Id, role, req.Body.Disabled, h.meta(ctx)); err != nil {126 return nil, err127 }128 u, err := h.adminUser(ctx, req.Id)129 if err != nil {130 return nil, err131 }132 return UpdateUser200JSONResponse{Body: u}, nil133}134135// guardAccount applies the rule "only an owner acts on an owner's136// credentials" to the administration of passkeys, sessions and devices, and137// returns the account. A refusal is audited.138func (h *adminHandlers) guardAccount(ctx context.Context, userID uuid.UUID, action, targetKind, targetID string) (identity.User, error) {139 u, err := h.Identity.UserByID(ctx, userID)140 if err != nil {141 return u, err142 }143 actor := principalFrom(ctx).Session144 if u.Role == authz.Owner && actor.User.Role != authz.Owner {145 h.audit(ctx, h.Pool, action, targetKind, targetID, audit.Denied, "only an owner may act on an owner's credentials", map[string]any{"user_id": userID.String()})146 return u, httpx.ErrForbidden147 }148 return u, nil149}150151func (h *adminHandlers) ListUserPasskeys(ctx context.Context, req ListUserPasskeysRequestObject) (ListUserPasskeysResponseObject, error) {152 if _, err := h.Identity.UserByID(ctx, req.Id); err != nil {153 return nil, err154 }155 keys, err := h.Identity.ListAllPasskeys(ctx, req.Id)156 if err != nil {157 return nil, err158 }159 out := PasskeyList{Items: make([]Passkey, 0, len(keys))}160 for _, k := range keys {161 pk := toPasskey(k)162 // An all-zero AAGUID means the authenticator did not identify itself.163 if len(k.AAGUID) == 16 && slices.ContainsFunc(k.AAGUID, func(b byte) bool { return b != 0 }) {164 pk.Aaguid = ptr(hex.EncodeToString(k.AAGUID))165 }166 out.Items = append(out.Items, pk)167 }168 return ListUserPasskeys200JSONResponse{Body: out}, nil169}170171// RevokeUserPasskey never removes the last active passkey of an account172// (409 last_passkey): the way to lock an account is to disable it.173func (h *adminHandlers) RevokeUserPasskey(ctx context.Context, req RevokeUserPasskeyRequestObject) (RevokeUserPasskeyResponseObject, error) {174 if _, err := h.guardAccount(ctx, req.Id, "passkey.revoke", "passkey", req.PasskeyId.String()); err != nil {175 return nil, err176 }177 if err := h.Identity.RevokePasskey(ctx, principalFrom(ctx).Session, req.Id, req.PasskeyId, false, h.meta(ctx)); err != nil {178 return nil, err179 }180 return RevokeUserPasskey204Response{}, nil181}182183func (h *adminHandlers) ListUserSessions(ctx context.Context, req ListUserSessionsRequestObject) (ListUserSessionsResponseObject, error) {184 if _, err := h.Identity.UserByID(ctx, req.Id); err != nil {185 return nil, err186 }187 list, err := h.Identity.ListSessions(ctx, req.Id)188 if err != nil {189 return nil, err190 }191 current := principalFrom(ctx).Session.ID192 out := SessionList{Items: make([]Session, 0, len(list))}193 for _, s := range list {194 item := Session{Id: s.ID, Kind: SessionKind(s.Kind), DeviceId: s.DeviceID, PasskeyId: s.PasskeyID, CreatedAt: s.CreatedAt,195 LastSeenAt: s.LastSeenAt, AuthenticatedAt: s.AuthenticatedAt, IdleExpiresAt: s.IdleExpiresAt, AbsoluteExpiresAt: s.AbsoluteExpiresAt,196 StepUpValidUntil: s.AuthenticatedAt.Add(h.Cfg.StepUpWindow), Current: s.ID == current, UserId: &s.User.ID}197 if s.IP != "" {198 item.Ip = &s.IP199 }200 if s.UserAgent != "" {201 item.UserAgent = &s.UserAgent202 }203 out.Items = append(out.Items, item)204 }205 return ListUserSessions200JSONResponse{Body: out}, nil206}207208func (h *adminHandlers) RevokeSession(ctx context.Context, req RevokeSessionRequestObject) (RevokeSessionResponseObject, error) {209 owner, err := h.Identity.SessionOwner(ctx, req.Id)210 if err != nil {211 return nil, err212 }213 if _, err := h.guardAccount(ctx, owner, "session.revoke", "session", req.Id.String()); err != nil {214 return nil, err215 }216 if err := h.Identity.RevokeSession(ctx, principalFrom(ctx).Session, req.Id, "revoked_by_admin", h.meta(ctx)); err != nil {217 return nil, err218 }219 return RevokeSession204Response{}, nil220}221222func (h *adminHandlers) ListUserDevices(ctx context.Context, req ListUserDevicesRequestObject) (ListUserDevicesResponseObject, error) {223 if _, err := h.Identity.UserByID(ctx, req.Id); err != nil {224 return nil, err225 }226 list, err := h.Identity.ListDevices(ctx, req.Id)227 if err != nil {228 return nil, err229 }230 current := principalFrom(ctx).Session.DeviceID231 out := DeviceList{Items: make([]Device, 0, len(list))}232 for _, d := range list {233 out.Items = append(out.Items, toDevice(d, current))234 }235 return ListUserDevices200JSONResponse{Body: out}, nil236}237238func (h *adminHandlers) RevokeDevice(ctx context.Context, req RevokeDeviceRequestObject) (RevokeDeviceResponseObject, error) {239 owner, err := h.Identity.DeviceOwner(ctx, req.Id)240 if err != nil {241 return nil, err242 }243 if _, err := h.guardAccount(ctx, owner, "device.revoke", "device", req.Id.String()); err != nil {244 return nil, err245 }246 if err := h.Identity.RevokeDevice(ctx, principalFrom(ctx).Session, req.Id, h.meta(ctx)); err != nil {247 return nil, err248 }249 return RevokeDevice204Response{}, nil250}251