mirror of
https://github.com/hanzoai/iam.git
synced 2026-11-19 18:37:16 +00:00
WorkOS auth.md agent registration, the service_auth shape only. An agent names its person's email at POST /v1/iam/oauth/agent/identity (no credential) and gets a claim_token, stored only as its SHA-256, and a user code. The person approves on the device page they already use, under a stricter rule than a device sign-in: only the account whose verified email is the login_hint, and only an admin of a tenant home org, checked at approval and again at the claim. The agent polls the token endpoint with the claim grant and is answered as a device is. On approval, once, a service account is filed in the person's org (no sk- key, its tag the registration) with an agent-claim audit row, and the answer is its access token and a 7-day identity_assertion, never a refresh token. jwt-bearer exchanges that assertion for a fresh token for as long as the account exists; deleting it revokes the agent. Any other jwt-bearer assertion is the workload grant's, unchanged. A registration is a device row named ag-<reg>: the device poll never redeems one, the claim poll never redeems a device row, and neither is an authorization code. Discovery carries agent_auth only where IAM_AGENT_SKILL_MAP names the issuer, and only what is implemented: no anonymous, no identity_assertion, no claim or events endpoint. IAM_AGENT_CLIENT names the app registrations belong to; the boot refuses half a configuration. Refs hanzo-inc/app#85
549 lines
25 KiB
Go
549 lines
25 KiB
Go
// Copyright 2026 Hanzo AI, Inc.
|
|
// SPDX-License-Identifier: MIT OR Apache-2.0
|
|
|
|
package oidc
|
|
|
|
import (
|
|
"crypto"
|
|
"crypto/ecdsa"
|
|
"crypto/rsa"
|
|
"crypto/x509"
|
|
"encoding/pem"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/golang-jwt/jwt/v5"
|
|
policy "github.com/hanzoai/authz"
|
|
|
|
"github.com/hanzoai/iam/pkg/schema"
|
|
)
|
|
|
|
// JWT token signing. The signing algorithm is a property of the signing Cert's
|
|
// key, not a global: an RSA cert signs RS256 (the interoperable default that the
|
|
// live hanzo.id JWKS serves), an EC cert signs ES256/384/512, and a post-quantum
|
|
// ML-DSA-65 cert signs MLDSA65 (mldsa.go, behind the same jwt.SigningMethod
|
|
// seam). The classical path is the load-bearing interop path — every existing
|
|
// verifier reads the RS256 keys published in the JWKS; ML-DSA is additive and
|
|
// inert until an ML-DSA Cert is configured.
|
|
//
|
|
// A Signer's key arrives on the Cert the store hands it. The Cert ROW carries
|
|
// only the key's identity — the `kid`, the algorithm; the private half is not
|
|
// stored and is filled in on load, in memory, from the material the deployment
|
|
// mounts (internal/keyring).
|
|
|
|
// Claims is the iam token claim set: the standard registered claims plus the
|
|
// Hanzo first-class claims the SDK and downstream validators read. owner and
|
|
// organization are the tenant (both the org slug); scope carries the granted
|
|
// scopes; nonce is echoed into the id_token; tokenType distinguishes an
|
|
// access-token from an id-token. A field is emitted only when populated, so one
|
|
// struct serves both token shapes without leaking empty claims.
|
|
type Claims struct {
|
|
jwt.RegisteredClaims
|
|
Scope string `json:"scope,omitempty"`
|
|
Owner string `json:"owner,omitempty"`
|
|
Organization string `json:"organization,omitempty"`
|
|
Email string `json:"email,omitempty"`
|
|
// Name is the IAM USERNAME (the `<name>` half of `<owner>/<name>`, e.g. "z"),
|
|
// never a display name. With Owner it forms the ONE address every Hanzo surface
|
|
// names a principal by — `hanzo auth login` files its credential under
|
|
// `owner/name` read straight off these claims, so whatever lands here IS the
|
|
// principal downstream believes it holds.
|
|
//
|
|
// OIDC gives `name` display semantics and this token used to honour that,
|
|
// carrying DisplayName ("Grace Hopper") while the account was "z". Adding
|
|
// preferred_username gave the username somewhere to live but left `name`
|
|
// display-sourced, so the wrong-principal reading stayed on the wire for every
|
|
// consumer that reads `name` — the CLI among them. The display name now has its
|
|
// own claim (Display) and `name` states the username, always. That is a
|
|
// deliberate divergence from OIDC's display reading of `name`, taken because
|
|
// one address for a principal beats two spellings that disagree.
|
|
Name string `json:"name,omitempty"`
|
|
// PreferredUsername is the OIDC-standard spelling of the same username, kept
|
|
// because discovery advertises it in claims_supported and cloud's money path
|
|
// already reads it: a wallet is addressed `<org>/<username>`, and when the only
|
|
// username-shaped claim was a display-sourced `name` it addressed
|
|
// `hanzo/Grace Hopper` — a wallet no funding path can name — while the balance
|
|
// sat in `hanzo/z`. It is sourced from the SAME field as Name (Identity.Name),
|
|
// so the two cannot drift apart the way `name` drifted from the account.
|
|
PreferredUsername string `json:"preferred_username,omitempty"`
|
|
// Display is the human-facing name — what a console greets you by. It is
|
|
// profile data, never an address: nothing may resolve a principal from it.
|
|
// `displayName` is the spelling schema.User, SCIM and whoami already use, so
|
|
// this value keeps its one name across every surface that carries it.
|
|
Display string `json:"displayName,omitempty"`
|
|
// BillingAccount names WHICH LEDGER this token spends from — the org pool, or
|
|
// empty to let the consumer's shape rule pick. account.Payer honours it above
|
|
// every other signal precisely because it is SIGNED: a caller cannot name its
|
|
// own payer, so this is IAM stating who is entitled to spend what.
|
|
//
|
|
// Empty is meaningful, not missing: it means "no explicit entitlement", and
|
|
// the consumer falls back to the behaviour it already had.
|
|
BillingAccount string `json:"billing_account,omitempty"`
|
|
// Type is the principal's identity CLASS — schema.Program for a token
|
|
// the client_credentials grant minted, absent for a person. It is the same fact
|
|
// billing_account already states, said as identity rather than as money, and
|
|
// it is stated for the same reason: IAM resolves it from the GRANT SHAPE, so
|
|
// only IAM can say it and a caller cannot forge it.
|
|
//
|
|
// A consumer needs both because they answer different questions. Money asks
|
|
// which ledger (the org pool); attribution asks whose spend this is, and a
|
|
// program's spend is nobody's — it belongs in an agent column with the person
|
|
// column left empty. Without this claim a consumer had to INFER the class,
|
|
// and the available inference (the token's audience equals its name) is true
|
|
// only while the app is single-tenant: audienceFor qualifies a SHARED app's
|
|
// audience with its org, so the inference silently reports every shared app's
|
|
// machine as a person.
|
|
Type string `json:"type,omitempty"`
|
|
Nonce string `json:"nonce,omitempty"`
|
|
Azp string `json:"azp,omitempty"`
|
|
TokenType string `json:"tokenType,omitempty"`
|
|
// Orgs is the membership set — the tenancy the identity may act in, home org
|
|
// first — a resource server reads to authorize an org-switch (X-Org-Id ∈ orgs)
|
|
// with no round-trip. omitempty ⇒ a nil set omits the claim entirely (a machine
|
|
// token, which has no membership, never carries it), so one struct still serves
|
|
// both an app token and a user token without emitting an empty claim.
|
|
Orgs []schema.OrgRef `json:"orgs,omitempty"`
|
|
// Act names the ACTOR a delegated token was minted BY — the org key behind
|
|
// as(), or the SuperAdmin impersonating the subject. RFC 8693 §4.1: a nested
|
|
// object a resource server reads to see WHO acted for the subject, kept
|
|
// distinct from the subject the token authorizes. It attributes; it never
|
|
// authorizes — authority is the subject's. Absent on every ordinary token.
|
|
// An exchange carries it forward only from an impersonated subject_token.
|
|
Act *Actor `json:"act,omitempty"`
|
|
// Imp marks an IMPERSONATED token: a platform operator signed in as the
|
|
// subject, named in Act. A client shows a banner on it; a resource server
|
|
// refuses it any durable credential or money act. Absent everywhere else.
|
|
Imp bool `json:"imp,omitempty"`
|
|
// Assumed names the organization a platform operator has stepped into
|
|
// (/v1/iam/assume). Absent on every ordinary token.
|
|
//
|
|
// It does not replace anybody. Subject, owner and name remain the operator's
|
|
// own, so the act is attributed to the person who performed it and metering
|
|
// bills the account that did the work; this claim says WHERE they were
|
|
// working. `orgs` carries the tenant beside it, which is how the assumed
|
|
// organization is reached — through the org switch a resource server already
|
|
// implements, rather than a second one taught to every consumer.
|
|
//
|
|
// It is a LABEL, not a sandbox. An operator keeps the authority they already
|
|
// held: IAM resolves SuperAdmin from the membership rows, never from a token
|
|
// claim, so a claim could not withdraw it here and pretending otherwise
|
|
// downstream would mean two answers to one question.
|
|
Assumed string `json:"assumed,omitempty"`
|
|
// Groups is the same membership set as flat names, under the name OIDC
|
|
// consumers already read. `orgs` carries a role per org, which is what our own
|
|
// resource servers need and what a generic consumer cannot parse: a relying
|
|
// party that maps a groups claim reads strings, so an object list stringifies
|
|
// to `map[Org:admin Role:admin]` and matches nothing.
|
|
//
|
|
// It is DERIVED from Orgs at the one place Orgs is set, so the two cannot
|
|
// disagree about who belongs where — a second list assembled from a second
|
|
// query is how a consumer comes to grant on stale membership.
|
|
//
|
|
// It lists MEMBERSHIP, so "admin" among a person's groups says they belong to
|
|
// the reserved org, not that they are a SuperAdmin: a brand org's person added
|
|
// to it appears here too. SuperAdmin is the person's own org being "admin",
|
|
// which is the FIRST entry of `orgs` (authz.Claims.Sudo). A relying party that
|
|
// grants platform authority on `groups` grants it by membership.
|
|
Groups []string `json:"groups,omitempty"`
|
|
// Wallets is the chain-qualified addresses this person has PROVED control
|
|
// of — each one the result of a CAIP-122 challenge IAM minted, bound to its
|
|
// issuing host, and verified against a burned single-use nonce
|
|
// (internal/wallet). A relying party reading it is reading IAM's assertion
|
|
// that the holder controlled that key, at some point, to this issuer.
|
|
//
|
|
// It is stated in the token because the alternative is every service that
|
|
// cares about a wallet asking IAM at request time, or worse, accepting an
|
|
// address the client names. A signed claim removes both.
|
|
//
|
|
// What it is NOT: proof the holder controls the key RIGHT NOW. A key can be
|
|
// sold, lost, or compromised between the link and this token; the claim is
|
|
// as fresh as the token's lifetime and no fresher. A payment authorization
|
|
// wants its own signature, not this.
|
|
Wallets []schema.WalletRef `json:"wallets,omitempty"`
|
|
// DID is the account's decentralized identifier, `did:lux:<subject>`,
|
|
// derived from `sub` (schema.DID) rather than stored beside it. It is
|
|
// present on every user token — deriving it needs no registry, and a
|
|
// deployment that anchors documents on chain (internal/did) writes the same
|
|
// string this claim carries. Absent only for a subject the derivation
|
|
// refuses, and on machine tokens, which have no person to name.
|
|
DID string `json:"did,omitempty"`
|
|
}
|
|
|
|
// Identity is WHO a token speaks for: the caller-resolved values every mint
|
|
// path turns into claims. It exists because those values used to travel as six
|
|
// adjacent positional strings, two of which — the username and the display name
|
|
// — are both human-readable and were therefore swappable at the call site. They
|
|
// were swapped, on all three mint paths at once, and the swap type-checks.
|
|
//
|
|
// One field per value, resolved in ONE place (identityOf), makes the swap
|
|
// unrepresentable: Name is the username, Display is the human's name, and no
|
|
// call site restates the difference. Zero value = no principal profile (a
|
|
// machine token, or a since-deleted user); every claim it feeds is omitempty, so
|
|
// the token omits them rather than emitting them empty.
|
|
type Identity struct {
|
|
Id string // the OIDC `sub` — stable and opaque
|
|
Email string
|
|
Name string // the IAM USERNAME, the `<name>` half of `<owner>/<name>`
|
|
Display string // the human-facing name; never an address
|
|
Billing string
|
|
Type string // the identity CLASS; empty for a person (schema.Program)
|
|
Orgs []schema.OrgRef
|
|
Assumed string // the organization a platform operator has stepped into
|
|
// Wallets is the set of chain-qualified addresses the person has proved
|
|
// control of, and DID is the identifier derived from Id (schema.DID). Both
|
|
// are resolved in identityOf beside everything else, so a mint path cannot
|
|
// state one of them differently from another path.
|
|
Wallets []schema.WalletRef
|
|
DID string
|
|
// Act and Imp are who is ACTING for this identity, when it is not the
|
|
// person: an operator impersonating them (Imp). Nil and false for a person
|
|
// acting as themselves.
|
|
Act *Actor
|
|
Imp bool
|
|
}
|
|
|
|
// Actor is the RFC 8693 `act` claim value: the identity that requested a
|
|
// delegated token. `sub` is the actor's own subject; an operator impersonating
|
|
// someone is also named by `owner`/`name`, the address a banner and an audit
|
|
// trail print. A longer delegation chain nests another Actor the same way, if
|
|
// one is ever needed.
|
|
type Actor struct {
|
|
Sub string `json:"sub,omitempty"`
|
|
Owner string `json:"owner,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
}
|
|
|
|
// Signer signs tokens with one key under one algorithm. Immutable after
|
|
// construction; the (method, key, kid, alg) tuple is fixed to the Cert it was
|
|
// built from so a token can never be signed under a key/alg mismatch.
|
|
type Signer struct {
|
|
method jwt.SigningMethod
|
|
key any // *rsa.PrivateKey | *ecdsa.PrivateKey | *mldsa65.PrivateKey
|
|
kid string // JWKS key id — the Cert name
|
|
alg string // JOSE alg — "RS256" | "ES256" | … | "MLDSA65"
|
|
issuer string
|
|
}
|
|
|
|
// NewSignerFromCert builds a Signer from a Cert, selecting the algorithm from
|
|
// the cert's key type: RSA → RS256 (or RS512 when the app pins it), EC → ES256/
|
|
// ES384/ES512 by curve, ML-DSA → MLDSA65. issuer is the canonical OIDC issuer
|
|
// (https://<host>) that discovery advertises; it is pinned into every token so
|
|
// id_token `iss` matches the discovery document. app may be nil (the method is
|
|
// then chosen purely from the key type).
|
|
func NewSignerFromCert(cert *schema.Cert, app *schema.Application, issuer string) (*Signer, error) {
|
|
if cert == nil {
|
|
return nil, errors.New("jwt: nil cert")
|
|
}
|
|
// Post-quantum ML-DSA-65 cert: raw key material, own signing method.
|
|
if isMLDSACert(cert) {
|
|
key, err := parseMLDSA65PrivateKey(cert.PrivateKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Signer{method: SigningMethodMLDSA65, key: key, kid: cert.Name, alg: algMLDSA65, issuer: issuer}, nil
|
|
}
|
|
if cert.PrivateKey == "" {
|
|
return nil, errors.New("jwt: cert has no private key")
|
|
}
|
|
key, err := parsePrivateKeyPEM(cert.PrivateKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
method, alg, err := methodForKey(key, pinnedMethod(app))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Signer{method: method, key: key, kid: cert.Name, alg: alg, issuer: issuer}, nil
|
|
}
|
|
|
|
// NewRSASignerFromCert builds an RS256 Signer from a Cert whose PrivateKey is a
|
|
// PEM RSA key. Retained as the explicit RSA constructor; NewSignerFromCert is
|
|
// the general dispatch used by the token endpoint.
|
|
func NewRSASignerFromCert(cert *schema.Cert, issuer string) (*Signer, error) {
|
|
if cert == nil || cert.PrivateKey == "" {
|
|
return nil, errors.New("jwt: cert has no private key")
|
|
}
|
|
key, err := parseRSAPrivateKeyPEM(cert.PrivateKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Signer{method: jwt.SigningMethodRS256, key: key, kid: cert.Name, alg: "RS256", issuer: issuer}, nil
|
|
}
|
|
|
|
// NewRSASigner builds an RS256 Signer directly from an RSA key, for a test that
|
|
// wants to sign with a key it holds rather than one a Cert names.
|
|
func NewRSASigner(key *rsa.PrivateKey, kid, issuer string) *Signer {
|
|
return &Signer{method: jwt.SigningMethodRS256, key: key, kid: kid, alg: "RS256", issuer: issuer}
|
|
}
|
|
|
|
// claims is the ONE place an Identity becomes a claim set. Every mint path goes
|
|
// through it, so `name`, `preferred_username` and `displayName` are sourced from
|
|
// the same two fields on every token shape and cannot be filled differently by
|
|
// one path than another. The caller supplies only what genuinely differs between
|
|
// shapes: the tenant, the audience, the acting client, and the token type.
|
|
func (s *Signer) claims(id Identity, owner string, aud jwt.ClaimStrings, azp, scope, kind string, ttl time.Duration, now time.Time) (Claims, error) {
|
|
jti, err := newOpaqueToken()
|
|
if err != nil {
|
|
return Claims{}, err
|
|
}
|
|
return Claims{
|
|
RegisteredClaims: jwt.RegisteredClaims{
|
|
Issuer: s.issuer,
|
|
Subject: id.Id,
|
|
Audience: aud,
|
|
ExpiresAt: jwt.NewNumericDate(now.Add(ttl)),
|
|
NotBefore: jwt.NewNumericDate(now),
|
|
IssuedAt: jwt.NewNumericDate(now),
|
|
ID: jti,
|
|
},
|
|
Scope: scope,
|
|
Owner: owner,
|
|
Organization: owner,
|
|
Email: id.Email,
|
|
Name: id.Name,
|
|
PreferredUsername: id.Name,
|
|
Display: id.Display,
|
|
BillingAccount: id.Billing,
|
|
Type: id.Type,
|
|
Azp: azp,
|
|
TokenType: kind,
|
|
Orgs: id.Orgs,
|
|
Groups: groupsOf(id.Orgs, id.Type),
|
|
Assumed: id.Assumed,
|
|
Wallets: id.Wallets,
|
|
DID: id.DID,
|
|
Act: id.Act,
|
|
Imp: id.Imp,
|
|
}, nil
|
|
}
|
|
|
|
// groupsOf flattens the membership set to the names a groups claim carries. A
|
|
// relying party maps a group onto access, so a membership that makes no one a
|
|
// tenant is no group: a brand's directory, and an org the platform runs held as a
|
|
// plain member (authz Claims.Tenancy says the same of both). A machine's set is
|
|
// its explicit grants and is carried whole. The admin org is carried as it is
|
|
// held, which is how a federated app sees the operator. Nil in, nil out, so a
|
|
// machine token omits the claim exactly as it omits orgs.
|
|
func groupsOf(orgs []schema.OrgRef, typ string) []string {
|
|
if len(orgs) == 0 {
|
|
return nil
|
|
}
|
|
out := make([]string, 0, len(orgs))
|
|
for _, o := range orgs {
|
|
if o.Org == "" {
|
|
continue
|
|
}
|
|
if typ != schema.Program && (policy.IsDirectory(o.Org) ||
|
|
(policy.IsPlatformOrg(o.Org) && !policy.Role(o.Role).Admits(policy.Write))) {
|
|
continue
|
|
}
|
|
out = append(out, o.Org)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Sign issues a signed access token for (app, identity) with the given scope. now
|
|
// is injected for testability; ttl is the token lifetime. The audience is the
|
|
// app's clientId (validators fail closed when aud != clientId). The owner claim is
|
|
// the APP's org. id.Orgs is the caller-resolved membership set — home org first for
|
|
// a user (store.MemberOrgRefs), the explicit grants for a machine (granted) — and
|
|
// nil omits the claim. The Signer stays decoupled from schema.User; the caller
|
|
// resolves the tenancy and passes it.
|
|
func (s *Signer) Sign(app *schema.Application, id Identity, scope, resource string, ttl time.Duration, now time.Time) (string, error) {
|
|
if s == nil {
|
|
return "", errors.New("jwt: nil signer")
|
|
}
|
|
claims, err := s.claims(id, app.Organization, audienceFor(app, resource), app.ClientId, scope, "access-token", ttl, now)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return s.signClaims(claims)
|
|
}
|
|
|
|
// SignUserToken mints an access token a confidential client issues ON BEHALF OF a
|
|
// target user — the RFC 8693 Token Exchange grant. Unlike Sign (which stamps the
|
|
// APP's org as the owner claim), every authority claim here is the TARGET USER's:
|
|
// the subject and owner are the user's, so a resource server that scopes on the
|
|
// validated `owner` claim (cloud's SanitizeIdentity) scopes to the USER's tenant,
|
|
// never the minting client's. `aud` is the caller-resolved audience (an explicit
|
|
// RFC 8707 resource, else the user's own app) and `azp` records the minting
|
|
// client. Signed under this signer's trusted cert + canonical issuer, so the same
|
|
// JWKS verifies it — the token is indistinguishable from one the user obtained
|
|
// directly, which is the point. The Signer stays decoupled from schema.User: the
|
|
// handler resolves and passes the values it authorized.
|
|
func (s *Signer) SignUserToken(id Identity, owner, aud, azp, scope string, ttl time.Duration, now time.Time) (string, error) {
|
|
if s == nil {
|
|
return "", errors.New("jwt: nil signer")
|
|
}
|
|
claims, err := s.claims(id, owner, jwt.ClaimStrings{aud}, azp, scope, "access-token", ttl, now)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return s.signClaims(claims)
|
|
}
|
|
|
|
// SignAct mints a user-bound access token that ALSO records the actor that
|
|
// requested it — the credential behind as(). It is SignUserToken plus the RFC 8693
|
|
// `act` claim: every authority claim is the TARGET USER's (subject, owner), so a
|
|
// resource server scopes to the user's tenant exactly as for a token the user
|
|
// obtained directly, while `act` names, separately, the org key that acted for
|
|
// them. `azp` records the party the token is authorized to; scope is empty (an
|
|
// as() token carries the user's full authority, narrowed only by its short life).
|
|
// SignUserToken stays act-less, so token exchange is unchanged.
|
|
func (s *Signer) SignAct(id Identity, owner, aud, azp string, act Actor, ttl time.Duration, now time.Time) (string, error) {
|
|
if s == nil {
|
|
return "", errors.New("jwt: nil signer")
|
|
}
|
|
claims, err := s.claims(id, owner, jwt.ClaimStrings{aud}, azp, "", "access-token", ttl, now)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
claims.Act = &act
|
|
return s.signClaims(claims)
|
|
}
|
|
|
|
// SignID issues an OIDC id_token for (app, user). It differs from the access
|
|
// token by carrying the echoed nonce and by declaring tokenType "id-token"; the
|
|
// audience is the client the token was minted for (the RP), and iss matches the
|
|
// discovery issuer so a standard OIDC client validates it.
|
|
func (s *Signer) SignID(app *schema.Application, id Identity, scope, nonce string, ttl time.Duration, now time.Time) (string, error) {
|
|
if s == nil {
|
|
return "", errors.New("jwt: nil signer")
|
|
}
|
|
claims, err := s.claims(id, app.Organization, jwt.ClaimStrings{app.ClientId}, app.ClientId, scope, "id-token", ttl, now)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
claims.Nonce = nonce
|
|
return s.signClaims(claims)
|
|
}
|
|
|
|
// signClaims is the single choke point that turns a claim set into a signed
|
|
// compact JWS under this signer's fixed (method, key, kid).
|
|
func (s *Signer) signClaims(claims Claims) (string, error) {
|
|
return s.signTyped(claims, "")
|
|
}
|
|
|
|
// signTyped signs claims under this signer's fixed (method, key, kid), with the
|
|
// JOSE `typ` header set to typ when it is not empty. Only a token that is not a
|
|
// Claims set takes a typ of its own: an agent's identity assertion (agent.go),
|
|
// whose `oauth-id-jag+jwt` is what tells the jwt-bearer grant it is IAM's.
|
|
func (s *Signer) signTyped(claims jwt.Claims, typ string) (string, error) {
|
|
if s == nil {
|
|
return "", errors.New("jwt: nil signer")
|
|
}
|
|
tok := jwt.NewWithClaims(s.method, claims)
|
|
if typ != "" {
|
|
tok.Header["typ"] = typ
|
|
}
|
|
if s.kid != "" {
|
|
tok.Header["kid"] = s.kid
|
|
}
|
|
return tok.SignedString(s.key)
|
|
}
|
|
|
|
// PublicKey returns the signer's RSA public key, or nil for a non-RSA signer
|
|
// (JWKS + verification read the public key from the Cert, not the Signer).
|
|
func (s *Signer) PublicKey() *rsa.PublicKey {
|
|
if k, ok := s.key.(*rsa.PrivateKey); ok {
|
|
return &k.PublicKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Kid returns the key id (the Cert name).
|
|
func (s *Signer) Kid() string { return s.kid }
|
|
|
|
// Alg returns the JOSE algorithm this signer uses (matches the JWKS `alg`).
|
|
func (s *Signer) Alg() string { return s.alg }
|
|
|
|
// audienceFor computes the token audience per RFC 8707: an explicit resource
|
|
// indicator wins; a shared application scopes the audience to the org; otherwise
|
|
// the audience is the client id (the value validators check).
|
|
func audienceFor(app *schema.Application, resource string) jwt.ClaimStrings {
|
|
if resource != "" {
|
|
return jwt.ClaimStrings{resource}
|
|
}
|
|
if app.IsShared && app.Organization != "" {
|
|
return jwt.ClaimStrings{app.ClientId + "-org-" + app.Organization}
|
|
}
|
|
return jwt.ClaimStrings{app.ClientId}
|
|
}
|
|
|
|
// pinnedMethod is the app's requested signing method (TokenSigningMethod), or ""
|
|
// to let the key type decide.
|
|
func pinnedMethod(app *schema.Application) string {
|
|
if app == nil {
|
|
return ""
|
|
}
|
|
return app.TokenSigningMethod
|
|
}
|
|
|
|
// methodForKey maps a parsed private key (and an optional app-pinned method
|
|
// within the same family) to a jwt.SigningMethod and its JOSE alg name.
|
|
func methodForKey(key any, pinned string) (jwt.SigningMethod, string, error) {
|
|
switch k := key.(type) {
|
|
case *rsa.PrivateKey:
|
|
if pinned == "RS512" {
|
|
return jwt.SigningMethodRS512, "RS512", nil
|
|
}
|
|
return jwt.SigningMethodRS256, "RS256", nil
|
|
case *ecdsa.PrivateKey:
|
|
switch k.Curve.Params().BitSize {
|
|
case 256:
|
|
return jwt.SigningMethodES256, "ES256", nil
|
|
case 384:
|
|
return jwt.SigningMethodES384, "ES384", nil
|
|
case 521:
|
|
return jwt.SigningMethodES512, "ES512", nil
|
|
}
|
|
return nil, "", fmt.Errorf("jwt: unsupported EC curve bit size %d", k.Curve.Params().BitSize)
|
|
default:
|
|
return nil, "", errors.New("jwt: unsupported private key type")
|
|
}
|
|
}
|
|
|
|
// parsePrivateKeyPEM decodes a classical (RSA or EC) PEM private key.
|
|
func parsePrivateKeyPEM(pemText string) (crypto.Signer, error) {
|
|
block, _ := pem.Decode([]byte(pemText))
|
|
if block == nil {
|
|
return nil, errors.New("jwt: private key is not valid PEM")
|
|
}
|
|
if k, err := x509.ParsePKCS1PrivateKey(block.Bytes); err == nil {
|
|
return k, nil
|
|
}
|
|
if k, err := x509.ParseECPrivateKey(block.Bytes); err == nil {
|
|
return k, nil
|
|
}
|
|
k8, err := x509.ParsePKCS8PrivateKey(block.Bytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("jwt: parse private key: %w", err)
|
|
}
|
|
signer, ok := k8.(crypto.Signer)
|
|
if !ok {
|
|
return nil, errors.New("jwt: PKCS#8 key is not a signing key")
|
|
}
|
|
return signer, nil
|
|
}
|
|
|
|
// parseRSAPrivateKeyPEM decodes a PEM RSA private key (PKCS#1 or PKCS#8).
|
|
func parseRSAPrivateKeyPEM(pemText string) (*rsa.PrivateKey, error) {
|
|
block, _ := pem.Decode([]byte(pemText))
|
|
if block == nil {
|
|
return nil, errors.New("jwt: private key is not valid PEM")
|
|
}
|
|
if k, err := x509.ParsePKCS1PrivateKey(block.Bytes); err == nil {
|
|
return k, nil
|
|
}
|
|
k8, err := x509.ParsePKCS8PrivateKey(block.Bytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("jwt: parse private key: %w", err)
|
|
}
|
|
rk, ok := k8.(*rsa.PrivateKey)
|
|
if !ok {
|
|
return nil, errors.New("jwt: private key is not RSA")
|
|
}
|
|
return rk, nil
|
|
}
|