mirror of
https://github.com/hanzoai/iam.git
synced 2026-11-19 18:37:16 +00:00
This repo is public and its LICENSE called the source "confidential and
proprietary ... All rights reserved". Public visibility contradicts
confidentiality, and HIP-0130 puts `iam` in the OSS core tier. The declaration
now matches both.
LICENSE-APACHE and LICENSE-MIT carry the canonical texts, unedited —
LICENSE-APACHE is byte-identical to apache.org/licenses/LICENSE-2.0.txt
(sha256 cfc7749b…, 11358 bytes, blob d645695). LICENSE declares the pair.
LICENSE-MIT carries the copyright line the notice requires.
249 Go files led with `// Copyright 2026 Hanzo AI, Inc. All rights reserved.`
— the classic proprietary reservation, and a per-file contradiction of the new
grant. Each now carries `// SPDX-License-Identifier: MIT OR Apache-2.0`. The
word "confidential" survives untouched in the OIDC sense (confidential client),
which is protocol vocabulary, not a licence claim.
There is nothing else to declare: `go.mod` has no licence field and this repo
ships no Cargo/npm/PyPI manifest.
Relicensing is ours alone to do. The tree is original work, not a fork:
`fork: false` with no parent, its own root commit, and no Casdoor-lineage tag
is an ancestor of `main`. The retired Casdoor fork is `hanzoai/iam-v1`; the
provenance note in LICENSE names it, restoring the vendor name a clean-room
assertion needs in order to say what it is clean of.
Build, vet and all 29 test packages green.
Co-authored-by: Hanzo Dev <[email protected]>
135 lines
4.8 KiB
Go
135 lines
4.8 KiB
Go
// Copyright 2026 Hanzo AI, Inc.
|
|
// SPDX-License-Identifier: MIT OR Apache-2.0
|
|
|
|
package oidc
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hanzoai/iam/pkg/pkce"
|
|
"github.com/hanzoai/iam/pkg/schema"
|
|
)
|
|
|
|
func testApp() *schema.Application {
|
|
a := &schema.Application{Organization: "hanzo"}
|
|
a.Name = "hanzo-console"
|
|
a.ClientId = "hanzo-console"
|
|
return a
|
|
}
|
|
|
|
func TestMintCode_BindsPKCEAndExpiry(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
verifier := "verifier-abc-000000000000000000000000000000000"
|
|
ch := pkce.Challenge(verifier)
|
|
tok, err := MintCode(testApp(), "hanzo/alice", "openid profile", ch, "S256", "", now)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if tok.Code == "" || len(tok.Code) < 40 {
|
|
t.Fatalf("code not a 256-bit token: %q", tok.Code)
|
|
}
|
|
if tok.CodeIsUsed {
|
|
t.Fatal("fresh code must not be used")
|
|
}
|
|
if tok.CodeExpireIn != now.Add(codeTTL).Unix() {
|
|
t.Fatalf("expiry = %d, want %d", tok.CodeExpireIn, now.Add(codeTTL).Unix())
|
|
}
|
|
if tok.Application != "hanzo-console" || tok.User != "hanzo/alice" {
|
|
t.Fatalf("binding wrong: app=%q user=%q", tok.Application, tok.User)
|
|
}
|
|
}
|
|
|
|
func TestMintCode_RefusesPlain(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
if _, err := MintCode(testApp(), "u", "", "some-challenge", "plain", "", now); !errors.Is(err, ErrPKCEPlainRejected) {
|
|
t.Fatalf("mint with plain: got %v, want ErrPKCEPlainRejected", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_HappyPath(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
verifier := "verifier-happy-0000000000000000000000000000000"
|
|
tok, _ := MintCode(testApp(), "hanzo/alice", "openid", pkce.Challenge(verifier), "S256", "", now)
|
|
if err := RedeemCode(tok, "hanzo-console", verifier, now.Add(30*time.Second)); err != nil {
|
|
t.Fatalf("valid redemption rejected: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_ReplayRejected(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
verifier := "verifier-replay-000000000000000000000000000000"
|
|
tok, _ := MintCode(testApp(), "u", "openid", pkce.Challenge(verifier), "S256", "", now)
|
|
// First redemption + issue marks it used.
|
|
if err := RedeemCode(tok, "hanzo-console", verifier, now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := IssueAccessToken(tok, 3600, now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Replay must now fail.
|
|
if err := RedeemCode(tok, "hanzo-console", verifier, now); !errors.Is(err, ErrCodeUsed) {
|
|
t.Fatalf("replay: got %v, want ErrCodeUsed", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_ExpiredRejected(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
verifier := "verifier-exp-00000000000000000000000000000000000"
|
|
tok, _ := MintCode(testApp(), "u", "openid", pkce.Challenge(verifier), "S256", "", now)
|
|
past := now.Add(codeTTL + time.Second)
|
|
if err := RedeemCode(tok, "hanzo-console", verifier, past); !errors.Is(err, ErrCodeExpired) {
|
|
t.Fatalf("expired code: got %v, want ErrCodeExpired", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_ClientMismatchRejected(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
verifier := "verifier-cli-00000000000000000000000000000000000"
|
|
tok, _ := MintCode(testApp(), "u", "openid", pkce.Challenge(verifier), "S256", "", now)
|
|
if err := RedeemCode(tok, "some-other-app", verifier, now); !errors.Is(err, ErrClientMismatch) {
|
|
t.Fatalf("client mismatch: got %v, want ErrClientMismatch", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_WrongVerifierRejected(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
tok, _ := MintCode(testApp(), "u", "openid", pkce.Challenge("the-right-verifier-0000000000000000000000000"), "S256", "", now)
|
|
if err := RedeemCode(tok, "hanzo-console", "the-WRONG-verifier-0000000000000000000000000", now); !errors.Is(err, ErrPKCEMismatch) {
|
|
t.Fatalf("wrong verifier: got %v, want ErrPKCEMismatch", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_PublicClientMustPresentVerifier(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
// Code minted WITH a challenge (public client) but token request omits the verifier.
|
|
tok, _ := MintCode(testApp(), "u", "openid", pkce.Challenge("v-000000000000000000000000000000000000000000000"), "S256", "", now)
|
|
if err := RedeemCode(tok, "hanzo-console", "", now); !errors.Is(err, ErrPKCEMissing) {
|
|
t.Fatalf("missing verifier: got %v, want ErrPKCEMissing", err)
|
|
}
|
|
}
|
|
|
|
func TestRedeemCode_UnknownCode(t *testing.T) {
|
|
if err := RedeemCode(nil, "hanzo-console", "v", time.Now()); !errors.Is(err, ErrCodeUnknown) {
|
|
t.Fatalf("nil token: got %v, want ErrCodeUnknown", err)
|
|
}
|
|
}
|
|
|
|
func TestIssueAccessToken_MintsAndMarksUsed(t *testing.T) {
|
|
now := time.Unix(1_800_000_000, 0)
|
|
tok, _ := MintCode(testApp(), "u", "openid", "", "", "", now)
|
|
if err := IssueAccessToken(tok, 3600, now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if tok.AccessToken == "" || len(tok.AccessToken) < 40 {
|
|
t.Fatalf("access token not minted: %q", tok.AccessToken)
|
|
}
|
|
if !tok.CodeIsUsed {
|
|
t.Fatal("code must be marked used after issue")
|
|
}
|
|
if tok.ExpiresIn != 3600 {
|
|
t.Fatalf("expiresIn = %d, want 3600", tok.ExpiresIn)
|
|
}
|
|
}
|