mirror of
https://github.com/hanzoai/iam.git
synced 2026-11-19 18:37:16 +00:00
173 lines
7.0 KiB
Go
173 lines
7.0 KiB
Go
// Copyright 2026 Hanzo AI, Inc.
|
|
// SPDX-License-Identifier: MIT OR Apache-2.0
|
|
|
|
package users
|
|
|
|
import (
|
|
"context"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/hanzoai/iam/pkg/schema"
|
|
"github.com/hanzoai/iam/pkg/store"
|
|
)
|
|
|
|
// A full-row update is fed by a masked read: every client that edits a user GETs the
|
|
// account, changes a field, and POSTs the whole row back. Mask blanks the secrets on
|
|
// the way out, so each one arrives back EMPTY — and a write that takes the body at
|
|
// its word erases it. These tests pin the inverse rule (schema.User.CarrySecretsFrom):
|
|
// what a reader cannot see, a writer cannot state.
|
|
|
|
// The authenticator seed and its recovery codes are the case that bit a real account.
|
|
// hanzo.id's onboarding read its own account and posted it back to bind a wallet; the
|
|
// seed and every recovery code went to zero while preferredMfaType stayed "app" — so
|
|
// sign-in still demanded a code, nothing could produce one, and the recovery codes
|
|
// that exist for exactly that moment were gone too. Enrolment lives in internal/mfa;
|
|
// this write never had standing to touch it.
|
|
//
|
|
// FAILS before the fix (seed and codes empty), PASSES after.
|
|
func TestUpdate_keepsAuthenticatorSeed(t *testing.T) {
|
|
ctx := context.Background()
|
|
db, err := store.Open("sqlite", filepath.Join(t.TempDir(), "mfa-update.db"), "")
|
|
if err != nil {
|
|
t.Fatalf("open store: %v", err)
|
|
}
|
|
defer db.Close()
|
|
|
|
const org, name = "hanzo", "alice"
|
|
const seed = "JBSWY3DPEHPK3PXP"
|
|
codes := []string{"aaaa-bbbb", "cccc-dddd"}
|
|
|
|
if _, err := New(db).Create(ctx, &CreateInput{
|
|
User: schema.User{Owner: org, Name: name, Email: "[email protected]"},
|
|
Password: "correct horse battery staple",
|
|
}); err != nil {
|
|
t.Fatalf("create: %v", err)
|
|
}
|
|
|
|
// Enrol an authenticator, the way internal/mfa does: load the stored row, set the
|
|
// multi-factor columns, write it back.
|
|
enrolled, _ := store.GetUserByName(ctx, db, org, name)
|
|
enrolled.TotpSecret = seed
|
|
enrolled.RecoveryCodes = codes
|
|
enrolled.PreferredMfaType = "app"
|
|
if err := enrolled.UpdateCtx(ctx); err != nil {
|
|
t.Fatalf("enrol: %v", err)
|
|
}
|
|
|
|
// The shipped read-merge-write: read the account (masked), merge a field, post the
|
|
// whole row back. Mask is what the client actually receives, so deriving the body
|
|
// from it is the faithful reproduction. The field that client merged in was
|
|
// `web3onboard`, which schema.User does not have — so the decoder drops it and the
|
|
// body below is what actually reached this write: a row asking for NO change,
|
|
// which nonetheless erased the seed.
|
|
stored, _ := store.GetUserByName(ctx, db, org, name)
|
|
body := *stored.Mask()
|
|
if body.TotpSecret != "" || len(body.RecoveryCodes) != 0 {
|
|
t.Fatalf("premise broken: Mask no longer blanks the seed (%q/%v) — this test would prove nothing",
|
|
body.TotpSecret, body.RecoveryCodes)
|
|
}
|
|
if _, err := New(db).Update(ctx, &UpdateInput{User: body}); err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
|
|
after, _ := store.GetUserByName(ctx, db, org, name)
|
|
if after.TotpSecret != seed {
|
|
t.Fatalf("totpSecret = %q, want %q — a profile edit erased the authenticator seed while preferredMfaType stayed %q: the account is locked out",
|
|
after.TotpSecret, seed, after.PreferredMfaType)
|
|
}
|
|
if len(after.RecoveryCodes) != len(codes) {
|
|
t.Fatalf("recoveryCodes = %v, want %v — the escape hatch for a lost seed was erased by the same write",
|
|
after.RecoveryCodes, codes)
|
|
}
|
|
if after.PreferredMfaType != "app" {
|
|
t.Fatalf("preferredMfaType = %q, want \"app\"", after.PreferredMfaType)
|
|
}
|
|
}
|
|
|
|
// The same rule, stated over Mask's whole set rather than one field, so a secret added
|
|
// to Mask without its sibling carry line fails here. A password digest that survives a
|
|
// profile edit is long-standing behaviour; a bearer token and a live one-time code are
|
|
// the same kind of thing and were not carried.
|
|
func TestUpdate_keepsEverySecretMaskHides(t *testing.T) {
|
|
ctx := context.Background()
|
|
db, err := store.Open("sqlite", filepath.Join(t.TempDir(), "secrets-update.db"), "")
|
|
if err != nil {
|
|
t.Fatalf("open store: %v", err)
|
|
}
|
|
defer db.Close()
|
|
|
|
const org, name, pw = "hanzo", "bob", "correct horse battery staple"
|
|
if _, err := New(db).Create(ctx, &CreateInput{
|
|
User: schema.User{Owner: org, Name: name, Email: "[email protected]"},
|
|
Password: pw,
|
|
}); err != nil {
|
|
t.Fatalf("create: %v", err)
|
|
}
|
|
|
|
// Put a distinct value in every field Mask blanks, so an erasure of any one of
|
|
// them is visible by name below.
|
|
seeded, _ := store.GetUserByName(ctx, db, org, name)
|
|
// argon2id carries its parameters inside the digest, so a freshly created account
|
|
// has no separate salt. A migrated account does, and it is masked either way.
|
|
seeded.PasswordSalt = "legacy-salt"
|
|
seeded.AccessSecret = "sk-secret"
|
|
seeded.AccessSecretHash = "sk-digest"
|
|
seeded.AccessToken = "bearer-token"
|
|
seeded.OriginalToken = "idp-token"
|
|
seeded.OriginalRefreshToken = "idp-refresh"
|
|
seeded.TotpSecret = "JBSWY3DPEHPK3PXP"
|
|
seeded.RecoveryCodes = []string{"aaaa-bbbb"}
|
|
seeded.VerificationCode = "123456"
|
|
if err := seeded.UpdateCtx(ctx); err != nil {
|
|
t.Fatalf("seed secrets: %v", err)
|
|
}
|
|
before, _ := store.GetUserByName(ctx, db, org, name)
|
|
|
|
body := *before.Mask()
|
|
body.DisplayName = "Bob B"
|
|
if _, err := New(db).Update(ctx, &UpdateInput{User: body}); err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
after, _ := store.GetUserByName(ctx, db, org, name)
|
|
|
|
for _, f := range []struct {
|
|
name string
|
|
want string
|
|
got string
|
|
}{
|
|
{"passwordHash", before.PasswordHash, after.PasswordHash},
|
|
{"passwordSalt", before.PasswordSalt, after.PasswordSalt},
|
|
{"accessSecret", before.AccessSecret, after.AccessSecret},
|
|
{"accessSecretHash", before.AccessSecretHash, after.AccessSecretHash},
|
|
{"accessToken", before.AccessToken, after.AccessToken},
|
|
{"originalToken", before.OriginalToken, after.OriginalToken},
|
|
{"originalRefreshToken", before.OriginalRefreshToken, after.OriginalRefreshToken},
|
|
{"totpSecret", before.TotpSecret, after.TotpSecret},
|
|
{"verificationCode", before.VerificationCode, after.VerificationCode},
|
|
} {
|
|
if f.want == "" {
|
|
t.Fatalf("setup: %s was not seeded, so this row proves nothing", f.name)
|
|
}
|
|
if f.got != f.want {
|
|
t.Fatalf("%s = %q, want %q — Mask hides this field, so the body arrived blank and the write erased it", f.name, f.got, f.want)
|
|
}
|
|
}
|
|
if len(after.RecoveryCodes) != len(before.RecoveryCodes) {
|
|
t.Fatalf("recoveryCodes = %v, want %v", after.RecoveryCodes, before.RecoveryCodes)
|
|
}
|
|
|
|
// The edit the caller actually asked for still lands, and a password reset — the
|
|
// one secret a caller may state, through its own field — still takes effect.
|
|
if after.DisplayName != "Bob B" {
|
|
t.Fatalf("displayName = %q, want %q — the intended edit was lost", after.DisplayName, "Bob B")
|
|
}
|
|
if _, err := New(db).Update(ctx, &UpdateInput{User: body, Password: "a whole new password"}); err != nil {
|
|
t.Fatalf("password reset: %v", err)
|
|
}
|
|
reset, _ := store.GetUserByName(ctx, db, org, name)
|
|
if reset.PasswordHash == before.PasswordHash {
|
|
t.Fatal("password reset did not change the digest — carrying secrets must not disable the reset seam")
|
|
}
|
|
}
|