Files
iam/pkg/store/superadmin_key_test.go
zeekay ef2f42a2ec Decide SuperAdmin on the row's own org
schema.User.SuperAdmin is the one predicate: a person whose row's owner
is the admin org. The Guard sets Principal.Sudo from it when it loads
the caller, and assume/release, device approval, unlink, the bootstrap
credential freeze and the registry push gate ask the row directly.
store.IsSuperAdmin, which also admitted a membership of the admin org,
is gone. A brand org's user added to the admin org is an ordinary
member of their own org, and a service account or program in the admin
org is never SuperAdmin.

hanzoai/authz v1.10.42 reads the same rule off a token (Claims.Sudo on
orgs[0]) and lets a membership of the admin org open nothing, so such a
member no longer reads or edits the admin org's registry row either.
The token IAM mints is unchanged: orgs still opens with the row's
owner.

Two protective gates keep the whole admin org, machines and unheld
names included: no secret key names an account there
(store.SuperAdminKey), and only a SuperAdmin writes one
(users.Authorize). Both read the owner as written, so neither reads the
store.

Every request the Guard admits for a SuperAdmin is recorded as a
superadmin audit row, PlatformWritten, with its method, address, answer
and client address; so is a SuperAdmin's unlink of someone else's
sign-in method and a device approval into another org.

TestEverySuperAdminGateAdmitsTheAdminOrgsPeopleOnly drives ten
SuperAdmin-only requests through the router as two SuperAdmins, a brand
admin holding an admin-org membership and two admin-org machines, and
reads the trail row each one leaves.

Claude-Session: https://claude.ai/code/session_01HuMDfgFssPUptYUzgZ6Cp8
2026-09-27 19:24:51 -07:00

107 lines
4.2 KiB
Go

// Copyright 2026 Hanzo AI, Inc.
// SPDX-License-Identifier: MIT OR Apache-2.0
package store
import (
"context"
"errors"
"testing"
policy "github.com/hanzoai/authz"
"github.com/hanzoai/orm"
"github.com/hanzoai/iam/internal/testdb"
"github.com/hanzoai/iam/pkg/schema"
)
// operatorKeys seeds admin/root, a SuperAdmin; admin/svc, a service account in
// the admin org; hanzo/z, a brand org's person holding an admin-org membership and
// an orgb membership; and hanzo/alice, an ordinary member of orgb.
func operatorKeys(t *testing.T) orm.DB {
t.Helper()
ctx := context.Background()
db := memDB(t)
seedKeyUser(t, db, "hanzo", "z", "[email protected]", "")
seedKeyUser(t, db, "hanzo", "alice", "[email protected]", "")
seedKeyUser(t, db, policy.AdminOrg, "root", "[email protected]", "")
svc := seedKeyUser(t, db, policy.AdminOrg, "svc", "", "")
svc.Type = schema.ServiceAccount
if err := svc.UpdateCtx(ctx); err != nil {
t.Fatal(err)
}
for _, m := range [][2]string{{"hanzo/z", policy.AdminOrg}, {"hanzo/z", "orgb"}, {"hanzo/alice", "orgb"}} {
if _, err := EnsureMembership(ctx, db, m[0], m[1], RoleMember); err != nil {
t.Fatal(err)
}
}
return db
}
// A key is refused for every account in the admin org — its SuperAdmins, its
// machines, and a name nobody holds yet — in every spelling of the holder. A
// brand org's person is not one of them, whatever memberships they hold.
func TestSuperAdminKey_EverySpellingOfTheHolder(t *testing.T) {
for _, c := range []struct {
owner, user string
want bool
}{
{policy.AdminOrg, "root", true},
{policy.AdminOrg, "Root", true},
{policy.AdminOrg, "admin/root", true},
{policy.AdminOrg, "svc", true},
{policy.AdminOrg, "nobody-yet", true},
{"hanzo", "admin/root", true},
{"hanzo", "z", false},
{"hanzo", "hanzo/Z", false},
{"orgb", "hanzo/z", false},
{"hanzo", "alice", false},
{"orgb", "hanzo/alice", false},
{"hanzo", "", false},
{"Admin", "root", false},
} {
if got := SuperAdminKey(&schema.Key{Owner: c.owner, User: c.user}); got != c.want {
t.Errorf("SuperAdminKey(%s, %q) = %v; want %v", c.owner, c.user, got, c.want)
}
}
}
// No secret key resolves to an account in the admin org, however it came to
// exist; the reason names it. A brand org's person holding an admin-org
// membership is an ordinary person, and their keys resolve like anyone's.
func TestHolderByAccessKey_NoKeySpeaksForTheAdminOrg(t *testing.T) {
ctx := context.Background()
db := operatorKeys(t)
seedKey(t, db, policy.AdminOrg, "root-home", "root", "pk-live-ROOT", "sk-live-ROOT")
seedKey(t, db, policy.AdminOrg, "root-folded", "admin/Root", "pk-live-RFOLD", "sk-live-RFOLD")
seedKey(t, db, policy.AdminOrg, "svc-key", "svc", "pk-live-SVC", "sk-live-SVC")
seedKey(t, db, "hanzo", "z-home", "z", "pk-live-ZHOME", "sk-live-ZHOME")
seedKey(t, db, "orgb", "z-member", "hanzo/z", "pk-live-ZMEMBER", "sk-live-ZMEMBER")
seedKey(t, db, "orgb", "alice-member", "hanzo/alice", "pk-live-AMEMBER", "sk-live-AMEMBER")
for _, sk := range []string{"sk-live-ROOT", "sk-live-RFOLD", "sk-live-SVC"} {
h, err := HolderByAccessKey(ctx, db, sk)
if !errors.Is(err, orm.ErrNotFound) || h.User != nil || Reason(err) != KeySuperAdmin {
t.Errorf("%s resolved to %+v (err=%v, reason=%q), want nobody and %q", sk, h.User, err, Reason(err), KeySuperAdmin)
}
}
for sk, want := range map[string]string{"sk-live-ZHOME": "z", "sk-live-ZMEMBER": "z", "sk-live-AMEMBER": "alice"} {
if h, err := HolderByAccessKey(ctx, db, sk); err != nil || h.User == nil || h.User.Name != want {
t.Errorf("%s = %+v, %v; want hanzo/%s", sk, h.User, err, want)
}
}
}
// A member key is admitted by its membership row, so a roster the resolver cannot
// read is a store fault, never a holder and never a named refusal a caller would
// read as final.
func TestHolderByAccessKey_AnUnreadableRosterIsNotAnAnswer(t *testing.T) {
db := operatorKeys(t)
seedKey(t, db, "orgb", "alice-member", "hanzo/alice", "pk-live-AMEMBER", "sk-live-AMEMBER")
h, err := HolderByAccessKey(context.Background(), testdb.Unreadable(db, "memberships"), "sk-live-AMEMBER")
if !errors.Is(err, testdb.ErrUnreadable) || h.User != nil || Reason(err) != "" {
t.Fatalf("an unreadable roster answered %+v (err=%v, reason=%q), want the read error", h.User, err, Reason(err))
}
}