Files
iam/internal/users/authorize_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

46 lines
1.8 KiB
Go

// Copyright 2026 Hanzo AI, Inc.
// SPDX-License-Identifier: MIT OR Apache-2.0
package users
import (
"context"
"errors"
"net/http"
"testing"
policy "github.com/hanzoai/authz"
"github.com/zap-proto/zip"
"github.com/hanzoai/iam/internal/principal"
)
// An account in the admin org is written only by a SuperAdmin. An org admin, an
// org admin holding an admin-org membership, and an application are all refused
// it — including a name nobody holds yet — while every other account is left to
// the ordinary gates.
func TestAuthorizeKeepsTheAdminOrgToSuperAdmins(t *testing.T) {
as := func(p *principal.Principal) context.Context { return principal.Bind(context.Background(), p) }
boss := as(&principal.Principal{Org: "hanzo", User: "boss", Admin: true})
member := as(&principal.Principal{Org: "hanzo", User: "z", Admin: true, Orgs: map[string]policy.Role{policy.AdminOrg: policy.Admin}})
app := as(&principal.Principal{Org: "hanzo", App: &policy.App{Name: "hanzo-visor", Owner: policy.AdminOrg}})
super := as(&principal.Principal{Org: policy.AdminOrg, User: "z", Sudo: true})
for name, ctx := range map[string]context.Context{"org admin": boss, "admin-org member": member, "application": app} {
err := Authorize(ctx, policy.AdminOrg)
var he *zip.HTTPError
if !errors.As(err, &he) || he.Status != http.StatusForbidden {
t.Errorf("%s writing an admin-org account: %v, want 403", name, err)
}
if err := Authorize(ctx, "hanzo"); err != nil {
t.Errorf("%s writing a hanzo account: %v, want the ordinary gates to decide", name, err)
}
}
if err := Authorize(super, policy.AdminOrg); err != nil {
t.Errorf("a SuperAdmin writing an admin-org account: %v", err)
}
if err := Authorize(context.Background(), "Admin"); err != nil {
t.Errorf("a look-alike org read as the admin org: %v", err)
}
}