mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-20 14:13:23 +00:00
382 lines
17 KiB
Go
382 lines
17 KiB
Go
// Copyright 2023-2026 Hanzo AI Inc. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package controllers
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/golang-jwt/jwt/v4"
|
|
"github.com/hanzoai/ai/internal/authtest"
|
|
iam "github.com/hanzoai/ai/internal/iam"
|
|
)
|
|
|
|
// newUsageController builds an ApiController for the GetCloudUsages auth+scope
|
|
// tests: the request URL (carrying ?org= / ?owner=), an optional Authorization
|
|
// header and an optional X-Org-Id tenant header.
|
|
//
|
|
// IT TAKES NO PRINCIPAL. Identity here is a VERIFIED token, so a test that needs an
|
|
// authenticated caller presents one — mintUsageJWT signs it against the installed
|
|
// certificate and the code under test then authenticates exactly the way production
|
|
// does. The fake session this used to seed could assert any identity it liked, which
|
|
// made an authorisation test a test of a path production never takes.
|
|
func newUsageController(url, authHeader, orgHeader string) *ApiController {
|
|
c := visit(http.MethodGet, url)
|
|
if authHeader != "" {
|
|
c.Fiber().Request().Header.Set("Authorization", authHeader)
|
|
}
|
|
if orgHeader != "" {
|
|
c.Fiber().Request().Header.Set("X-Org-Id", orgHeader)
|
|
}
|
|
return c
|
|
}
|
|
|
|
// usageClaims builds a standard claim set: owner/name identity + iss/aud + a fresh
|
|
// validity window. Callers override individual keys (iss for a cross-brand token,
|
|
// exp for an expired one) before signing.
|
|
func usageClaims(owner, name, iss, aud string) jwt.MapClaims {
|
|
return jwt.MapClaims{
|
|
"owner": owner,
|
|
"name": name,
|
|
"iss": iss,
|
|
"aud": aud,
|
|
"iat": time.Now().Unix(),
|
|
"exp": time.Now().Add(time.Hour).Unix(),
|
|
}
|
|
}
|
|
|
|
// mintUsageJWT installs a fresh cert and returns a valid OWN-brand (iss=hanzo.id)
|
|
// RS256 token for owner/name — the common case for the accept-and-scope tests.
|
|
func mintUsageJWT(t *testing.T, owner, name string) string {
|
|
t.Helper()
|
|
key := authtest.Signing(t)
|
|
tok, err := jwt.NewWithClaims(jwt.SigningMethodRS256, usageClaims(owner, name, "https://hanzo.id", "hanzo-cloud")).SignedString(key)
|
|
if err != nil {
|
|
t.Fatalf("sign token: %v", err)
|
|
}
|
|
return tok
|
|
}
|
|
|
|
// TestResolveCloudUsageScope is the scope-safety invariant, proved as a pure
|
|
// function of the RESOLVED principal + request params. Because
|
|
// resolveCloudUsageScope only ever sees the *iam.User (never how it was
|
|
// authenticated), this table holds identically for a session OR a Bearer
|
|
// principal: a non-super-admin is ALWAYS pinned to its own org, and only a
|
|
// super-admin (Owner=="admin") can target another org / the all-orgs view.
|
|
func TestResolveCloudUsageScope(t *testing.T) {
|
|
nonAdmin := &iam.User{Owner: "maxpower", Name: "dave", IsAdmin: true} // org-admin, NOT super
|
|
superAdmin := &iam.User{Owner: "admin", Name: "z", IsAdmin: true}
|
|
|
|
cases := []struct {
|
|
name string
|
|
url string
|
|
orgHeader string
|
|
user *iam.User
|
|
wantOrg string
|
|
wantAllOrg bool
|
|
wantAdmin bool
|
|
}{
|
|
// A non-super-admin can never escape its own org, whatever it asks for —
|
|
// and never reads through the admin lens, whatever it asks for.
|
|
{"non-admin + ?org=all -> pinned", "/x?org=all", "", nonAdmin, "maxpower", false, false},
|
|
{"non-admin + ?org=hanzo (other) -> pinned", "/x?org=hanzo", "", nonAdmin, "maxpower", false, false},
|
|
{"non-admin + ?org=* -> pinned", "/x?org=*", "", nonAdmin, "maxpower", false, false},
|
|
{"non-admin + ?owner=hanzo -> pinned", "/x?owner=hanzo", "", nonAdmin, "maxpower", false, false},
|
|
{"non-admin + X-Org-Id: hanzo -> pinned", "/x", "hanzo", nonAdmin, "maxpower", false, false},
|
|
{"non-admin + ?org=all + X-Org-Id: hanzo -> pinned", "/x?org=all", "hanzo", nonAdmin, "maxpower", false, false},
|
|
// A super-admin drives the god-view / targeting, and carries the admin lens
|
|
// in BOTH — narrowing the window does not narrow the principal.
|
|
{"super + ?org=all -> god-view", "/x?org=all", "", superAdmin, "", true, true},
|
|
{"super + no scope -> god-view", "/x", "", superAdmin, "", true, true},
|
|
{"super + ?org=maxpower -> targeted", "/x?org=maxpower", "", superAdmin, "maxpower", false, true},
|
|
{"super + ?owner=zoo -> targeted", "/x?owner=zoo", "", superAdmin, "zoo", false, true},
|
|
{"super + X-Org-Id: maxpower -> targeted", "/x", "maxpower", superAdmin, "maxpower", false, true},
|
|
}
|
|
for _, tc := range cases {
|
|
// THE REQUEST MUST CARRY THE CREDENTIAL THAT PRODUCED THE PRINCIPAL. The
|
|
// scope is not a function of the user alone: a god-view also requires the
|
|
// credential to be own-brand, which is read off the request. Handing the user
|
|
// as an argument while the request carries nothing pins every super-admin to
|
|
// its own org — the table said so, before this line did.
|
|
c := newUsageController(tc.url, authtest.Bearer(t, *tc.user), tc.orgHeader)
|
|
gotOrg, gotAll, gotAdmin := c.resolveCloudUsageScope(tc.user)
|
|
if gotOrg != tc.wantOrg || gotAll != tc.wantAllOrg || gotAdmin != tc.wantAdmin {
|
|
t.Errorf("%s: scope = (%q, %v, admin=%v), want (%q, %v, admin=%v)",
|
|
tc.name, gotOrg, gotAll, gotAdmin, tc.wantOrg, tc.wantAllOrg, tc.wantAdmin)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestRequirePrincipal_NoCredentialIs401 — task test (d): a request with NEITHER
|
|
// a session NOR a Bearer is denied a real 401 (never a 200, never a fabricated
|
|
// principal). This is the fail-closed floor of the Bearer-enabled read.
|
|
func TestRequirePrincipal_NoCredentialIs401(t *testing.T) {
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "", "hanzo")
|
|
user, ok := c.RequirePrincipal()
|
|
if ok || user != nil {
|
|
t.Fatalf("RequirePrincipal with no credential = (%+v, %v), want (nil, false)", user, ok)
|
|
}
|
|
if answered(c) != http.StatusUnauthorized {
|
|
t.Errorf("no-credential status = %d, want 401", answered(c))
|
|
}
|
|
}
|
|
|
|
// TestGetCloudUsagesBearerScope is the end-to-end proof over a REAL signed Bearer
|
|
// (no session): the principal — and thus the super-admin decision — is derived
|
|
// SOLELY from the verified token, never from a header or param.
|
|
//
|
|
// - task test (a): a NON-admin Bearer asking for ?org=all with a spoofed
|
|
// X-Org-Id is pinned to its OWN org; it cannot read all-orgs or another org.
|
|
// - task test (b): a super-admin Bearer gets the god-view, and can target a
|
|
// single org.
|
|
func TestGetCloudUsagesBearerScope(t *testing.T) {
|
|
// Deterministic audience policy: a non-empty allowlist that includes our aud.
|
|
t.Setenv("GATEWAY_ALLOWED_AUDIENCES", "hanzo-cloud")
|
|
|
|
t.Run("non-admin bearer pinned despite ?org=all + X-Org-Id", func(t *testing.T) {
|
|
tok := mintUsageJWT(t, "maxpower", "dave")
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "Bearer "+tok, "hanzo")
|
|
|
|
user, ok := c.RequirePrincipal()
|
|
if !ok || user == nil {
|
|
t.Fatalf("RequirePrincipal(bearer) = (%+v, %v), want the token principal", user, ok)
|
|
}
|
|
if sent(c) != "" {
|
|
t.Fatalf("bearer auth wrote a denial body %q; the token must be accepted", sent(c))
|
|
}
|
|
if user.Owner != "maxpower" {
|
|
t.Fatalf("bearer resolved Owner = %q, want maxpower (from the token, not the X-Org-Id header)", user.Owner)
|
|
}
|
|
org, allOrgs, admin := c.resolveCloudUsageScope(user)
|
|
if org != "maxpower" || allOrgs || admin {
|
|
t.Errorf("non-admin bearer scope = (%q, %v, admin=%v), want (maxpower, false, admin=false) — a tenant must never reach ?org=all", org, allOrgs, admin)
|
|
}
|
|
})
|
|
|
|
t.Run("super-admin bearer god-view", func(t *testing.T) {
|
|
tok := mintUsageJWT(t, "admin", "z")
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "Bearer "+tok, "")
|
|
|
|
user, ok := c.RequirePrincipal()
|
|
if !ok || user == nil || user.Owner != "admin" {
|
|
t.Fatalf("RequirePrincipal(super bearer) = (%+v, %v), want Owner=admin", user, ok)
|
|
}
|
|
if org, allOrgs, admin := c.resolveCloudUsageScope(user); org != "" || !allOrgs || !admin {
|
|
t.Errorf("super-admin bearer + ?org=all scope = (%q, %v, admin=%v), want (\"\", true, admin=true) god-view", org, allOrgs, admin)
|
|
}
|
|
})
|
|
|
|
t.Run("super-admin bearer can target one org", func(t *testing.T) {
|
|
tok := mintUsageJWT(t, "admin", "z")
|
|
c := newUsageController("/v1/get-cloud-usages?org=maxpower", "Bearer "+tok, "")
|
|
|
|
user, ok := c.RequirePrincipal()
|
|
if !ok || user == nil {
|
|
t.Fatalf("RequirePrincipal(super bearer) failed")
|
|
}
|
|
if org, allOrgs, admin := c.resolveCloudUsageScope(user); org != "maxpower" || allOrgs || !admin {
|
|
t.Errorf("super-admin bearer + ?org=maxpower scope = (%q, %v, admin=%v), want (maxpower, false, admin=true)", org, allOrgs, admin)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestGetCloudUsagesRejectsForgedBearer — the tenant-safety of the whole feature
|
|
// rests on ParseAndValidateJWT rejecting anything it did not sign. A token signed
|
|
// by a DIFFERENT key than the installed IAM cert (a forgery, e.g. an attacker
|
|
// claiming owner=admin) resolves to NO principal, so RequirePrincipal 401s and no
|
|
// scope is ever computed from it.
|
|
func TestGetCloudUsagesRejectsForgedBearer(t *testing.T) {
|
|
t.Setenv("GATEWAY_ALLOWED_AUDIENCES", "hanzo-cloud")
|
|
|
|
// Install a legitimate cert for one identity...
|
|
_ = mintUsageJWT(t, "maxpower", "dave")
|
|
|
|
// ...then forge a token for a DIFFERENT key claiming owner=admin.
|
|
attackerKey, err := rsa.GenerateKey(rand.Reader, 2048)
|
|
if err != nil {
|
|
t.Fatalf("rsa key: %v", err)
|
|
}
|
|
forged, err := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{
|
|
"owner": "admin", "name": "z", "iss": "https://hanzo.id", "aud": "hanzo-cloud",
|
|
"iat": time.Now().Unix(), "exp": time.Now().Add(time.Hour).Unix(),
|
|
}).SignedString(attackerKey)
|
|
if err != nil {
|
|
t.Fatalf("sign forged: %v", err)
|
|
}
|
|
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "Bearer "+forged, "")
|
|
if user, ok := c.RequirePrincipal(); ok || user != nil {
|
|
t.Fatalf("forged bearer resolved a principal %+v — signature verification failed to reject it", user)
|
|
}
|
|
if answered(c) != http.StatusUnauthorized {
|
|
t.Errorf("forged bearer status = %d, want 401", answered(c))
|
|
}
|
|
}
|
|
|
|
// TestResolveCloudUsageScope_BrandScopedGodView is RED hardening #1: the all-orgs
|
|
// god-view and cross-org targeting are granted ONLY to a SAME-BRAND super admin.
|
|
// A sibling white-label brand's super admin (a lux.id owner=admin token that the
|
|
// auth layer trusts for sign-in) is pinned to its own org — it can NEVER read this
|
|
// brand's all-customer spend, independent of whatever the IAM SDK later verifies.
|
|
func TestResolveCloudUsageScope_BrandScopedGodView(t *testing.T) {
|
|
// Non-empty allowlist folds in every brand aud (withBrandAudiences), so a lux
|
|
// token's aud=lux-cloud is accepted for SIGN-IN — proving the brand gate, not an
|
|
// audience reject, is what pins it.
|
|
t.Setenv("GATEWAY_ALLOWED_AUDIENCES", "hanzo-cloud")
|
|
|
|
t.Run("same-brand super-admin BEARER (iss=hanzo.id) -> god-view", func(t *testing.T) {
|
|
tok := mintUsageJWT(t, "admin", "z") // iss=hanzo.id == expectedJWTIssuer()
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "Bearer "+tok, "")
|
|
user, ok := c.RequirePrincipal()
|
|
if !ok || user == nil {
|
|
t.Fatalf("own-brand super-admin bearer not accepted")
|
|
}
|
|
if org, allOrgs, admin := c.resolveCloudUsageScope(user); org != "" || !allOrgs || !admin {
|
|
t.Errorf("same-brand bearer super-admin scope = (%q, %v, admin=%v), want (\"\", true, admin=true)", org, allOrgs, admin)
|
|
}
|
|
})
|
|
|
|
t.Run("cross-brand super-admin BEARER (iss=lux.id) -> PINNED, not god-view", func(t *testing.T) {
|
|
key := authtest.Signing(t)
|
|
tok, err := jwt.NewWithClaims(jwt.SigningMethodRS256,
|
|
usageClaims("admin", "z", "https://lux.id", "lux-cloud")).SignedString(key)
|
|
if err != nil {
|
|
t.Fatalf("sign lux token: %v", err)
|
|
}
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "Bearer "+tok, "")
|
|
|
|
// The lux token is a VALID sign-in credential (trusted issuer + brand aud)...
|
|
user, ok := c.RequirePrincipal()
|
|
if !ok || user == nil || user.Owner != "admin" {
|
|
t.Fatalf("cross-brand admin bearer = (%+v, %v); expected it to authenticate as owner=admin (the whole point: auth trusts it, scope must not)", user, ok)
|
|
}
|
|
// ...but it is NOT own-brand, so the god-view is denied and it is pinned.
|
|
// ...and the lens is pinned with the scope: a sibling brand's admin reads the
|
|
// CUSTOMER shape, so it cannot see which upstream served another brand's calls.
|
|
if org, allOrgs, admin := c.resolveCloudUsageScope(user); org != "admin" || allOrgs || admin {
|
|
t.Errorf("cross-brand admin scope = (%q, %v, admin=%v), want (\"admin\", false, admin=false) — sibling brand admin MUST NOT reach the all-orgs god-view or the admin lens", org, allOrgs, admin)
|
|
}
|
|
})
|
|
|
|
t.Run("cross-brand super-admin BEARER cannot target another org", func(t *testing.T) {
|
|
key := authtest.Signing(t)
|
|
tok, err := jwt.NewWithClaims(jwt.SigningMethodRS256,
|
|
usageClaims("admin", "z", "https://lux.id", "lux-cloud")).SignedString(key)
|
|
if err != nil {
|
|
t.Fatalf("sign lux token: %v", err)
|
|
}
|
|
c := newUsageController("/v1/get-cloud-usages?org=maxpower", "Bearer "+tok, "")
|
|
user, _ := c.RequirePrincipal()
|
|
if org, allOrgs, admin := c.resolveCloudUsageScope(user); org != "admin" || allOrgs || admin {
|
|
t.Errorf("cross-brand admin + ?org=maxpower scope = (%q, %v, admin=%v), want (\"admin\", false, admin=false) — cannot target another tenant", org, allOrgs, admin)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestResolveCloudUsageScope_EmptyOwner — a principal with an empty Owner scopes to
|
|
// organization=” (a real, empty tenant filter: whereClause adds `organization = ?`
|
|
// with p.Org=""), never the all-orgs view. Fail-secure: absence of an org is NOT
|
|
// the god-view.
|
|
func TestResolveCloudUsageScope_EmptyOwner(t *testing.T) {
|
|
ghost := &iam.User{Owner: "", Name: "ghost"}
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "", "")
|
|
if org, allOrgs, admin := c.resolveCloudUsageScope(ghost); org != "" || allOrgs || admin {
|
|
t.Errorf("empty-Owner scope = (%q, %v, admin=%v), want (\"\", false, admin=false) — empty org filter, NOT all-orgs", org, allOrgs, admin)
|
|
}
|
|
}
|
|
|
|
// TestGetCloudUsages_RejectsAnonymous is RED hardening #2: an anonymous guest
|
|
// (anonymousSignin binds Owner=IAM_ORG) must not read org-aggregate spend. The
|
|
// handler rejects it BEFORE any warehouse read, so this drives the real handler.
|
|
func TestGetCloudUsages_RejectsAnonymous(t *testing.T) {
|
|
for _, anon := range []iam.User{
|
|
{Owner: "hanzo", Type: "anonymous-user", Name: "someone"},
|
|
{Owner: "hanzo", Name: "u-12345678"}, // anonymous by u-<hash> username (len 10)
|
|
} {
|
|
c := newUsageController("/v1/get-cloud-usages", authtest.Bearer(t, anon), "")
|
|
|
|
// THE CREDENTIAL IS GOOD, and proving that first is what keeps the 401 below
|
|
// worth anything: a missing principal and an anonymous one are refused with the
|
|
// same sentence, so a token that failed to verify would pass this test without
|
|
// the handler ever reaching the check it is about.
|
|
if user, ok := c.RequirePrincipal(); !ok || user == nil {
|
|
t.Fatalf("the guest's own credential did not verify, so this proves nothing about %+v", anon)
|
|
}
|
|
|
|
c.GetCloudUsages()
|
|
if answered(c) != http.StatusUnauthorized {
|
|
t.Errorf("anonymous %+v -> GetCloudUsages status = %d, want 401 (rejected before any warehouse read)", anon, answered(c))
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestRequirePrincipal_RejectsMalformedBearer covers the RED-flagged token-forgery
|
|
// classes on the Bearer path: alg=none, the RS256→HS256 confusion (a symmetric
|
|
// token signed with the public-cert bytes as an HMAC key), and an expired token.
|
|
// Each must resolve NO principal (401), so no scope is ever computed from them.
|
|
func TestRequirePrincipal_RejectsMalformedBearer(t *testing.T) {
|
|
t.Setenv("GATEWAY_ALLOWED_AUDIENCES", "hanzo-cloud")
|
|
|
|
t.Run("alg=none", func(t *testing.T) {
|
|
authtest.Signing(t) // the verifier needs its certificate for the keyfunc to run
|
|
tok, err := jwt.NewWithClaims(jwt.SigningMethodNone,
|
|
usageClaims("admin", "z", "https://hanzo.id", "hanzo-cloud")).
|
|
SignedString(jwt.UnsafeAllowNoneSignatureType)
|
|
if err != nil {
|
|
t.Fatalf("sign none: %v", err)
|
|
}
|
|
assertBearerRejected(t, tok)
|
|
})
|
|
|
|
t.Run("HS256 confusion", func(t *testing.T) {
|
|
authtest.Signing(t)
|
|
tok, err := jwt.NewWithClaims(jwt.SigningMethodHS256,
|
|
usageClaims("admin", "z", "https://hanzo.id", "hanzo-cloud")).
|
|
SignedString([]byte("attacker-chosen-hmac-secret"))
|
|
if err != nil {
|
|
t.Fatalf("sign hs256: %v", err)
|
|
}
|
|
assertBearerRejected(t, tok)
|
|
})
|
|
|
|
t.Run("expired", func(t *testing.T) {
|
|
key := authtest.Signing(t)
|
|
claims := usageClaims("admin", "z", "https://hanzo.id", "hanzo-cloud")
|
|
claims["iat"] = time.Now().Add(-2 * time.Hour).Unix()
|
|
claims["exp"] = time.Now().Add(-time.Hour).Unix()
|
|
tok, err := jwt.NewWithClaims(jwt.SigningMethodRS256, claims).SignedString(key)
|
|
if err != nil {
|
|
t.Fatalf("sign expired: %v", err)
|
|
}
|
|
assertBearerRejected(t, tok)
|
|
})
|
|
}
|
|
|
|
// assertBearerRejected drives RequirePrincipal with a Bearer token and asserts it
|
|
// resolves no principal and writes a 401.
|
|
func assertBearerRejected(t *testing.T, token string) {
|
|
t.Helper()
|
|
c := newUsageController("/v1/get-cloud-usages?org=all", "Bearer "+token, "")
|
|
if user, ok := c.RequirePrincipal(); ok || user != nil {
|
|
t.Fatalf("malformed bearer resolved a principal %+v; want none", user)
|
|
}
|
|
if answered(c) != http.StatusUnauthorized {
|
|
t.Errorf("malformed bearer status = %d, want 401", answered(c))
|
|
}
|
|
}
|