Files
iam/internal/oidc/workload.go
zeekayandHanzo Dev 0b0b3941d4 A session-cookie write comes only from the issuer's own page, and a process with no issuer names none
The session cookie is SameSite=Lax, which keeps it off requests from other
sites but not from other hosts of the same site. Once hanzo.ai signs people
in, any page on any *.hanzo.ai host could post a form to /v1/iam/login with
type=device and approve an attacker's `hanzo login` code, or with type=code
mint an authorization code, or edit the account. sessions.Forgeable is now
the one rule for a write the cookie authorizes: Sec-Fetch-Site must be
same-origin or none, and a request with a body must carry it as JSON.
sessions.Writer resolves the session only past it, and every cookie write
goes through it: the login SSO and device branches, callerOf/callerFrom
(profile, password rotation, terms, consent, preferences, onboarding,
link, unlink, passkey enrollment), and invitation accept. A refused write
is 403 before the session is read. The passkey finish, which the challenge
cookie authorizes, asks the same rule. A bearer from a client that is not a
browser needs no fetch metadata, with or without a cookie riding along.

Signing out ends sessions, so sessions.Clear asks the rule too, with one
exception: a top-level navigation (Sec-Fetch-Mode navigate, Sec-Fetch-Dest
document), which is how a relying party signs a person out. An image, a
frame or a sibling's form ends nothing.

The federation binding cookie is __Host-hanzo_fed and only that name is
read; a test now pins that the bare hanzo_fed name is refused.

server.RequireIssuer is the boot check for issuers: it installs IAM_ISSUER
and IAM_ISSUER_MAP, then IAM_FEDERATION_ORIGIN_MAP, and returns an error for
an empty or non-https IAM_ISSUER (outside IAM_DEV_HOST_RELATIVE=1), a
malformed issuer map, or a sign-in map that would strand the binding. `iam
serve` calls it, and a host that embeds IAM must call it before NewApp.
devFallbackIssuer and the lazy env resolvers are gone: a process that never
installed an issuer has none, so every issuer read is an error, discovery
answers 503, no token is minted and none is accepted, where it used to
answer https://hanzo.id. No issuer value changes.

Co-authored-by: Hanzo Dev <[email protected]>
2026-10-17 19:45:43 -07:00

602 lines
24 KiB
Go

// Copyright 2026 Hanzo AI, Inc.
// SPDX-License-Identifier: MIT OR Apache-2.0
package oidc
import (
"crypto/tls"
"crypto/x509"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"strconv"
"strings"
"sync"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/hanzoai/orm"
"github.com/zap-proto/zip"
"github.com/hanzoai/iam/pkg/schema"
"github.com/hanzoai/iam/pkg/store"
)
// RFC 7523 — a workload authenticates with the ServiceAccount token its pod
// already carries, and receives the application token client_credentials would
// have given it for a stored secret.
//
// A secret in a pod is a secret in etcd, in whatever manifest names it, and in
// every `kubectl get secret` anyone with read access on the namespace runs. The
// projected ServiceAccount token is none of those: the kubelet mints it for one
// pod, for one audience, with a lifetime measured in hours, and rotates it in
// place. The cluster is already vouching for that pod — this grant reads what the
// cluster says instead of asking the deployment to carry a second credential
// asserting the same thing.
//
// What the assertion PROVES, checked here:
//
// - it is signed by a key the named cluster publishes in its own JWKS;
// - `aud` names THIS issuer, so a token the kubelet minted for some other
// audience cannot be replayed against the token endpoint;
// - it is inside its own validity window (`exp` required, `nbf` honoured);
// - `sub` is `system:serviceaccount:<namespace>:<name>`.
//
// What is CONFIGURED, not proved: which cluster issuers are trusted at all
// (IAM_CLUSTER_ISSUERS) and which ServiceAccounts speak, each named
// `<namespace>:<name>` with the org it speaks in (IAM_WORKLOADS). Both are exact
// — no globs, and never a whole namespace — because a ServiceAccount's name is
// chosen by whoever may write its namespace. A namespace-wide entry would let any
// account created there spell any app of that org; naming the account means
// minting an app's token takes that one account, which is the pod the app's own
// chart runs.
//
// The application is DECLARED, never created here, and it declares THIS grant:
// provision.yaml lists urn:ietf:params:oauth:grant-type:jwt-bearer on exactly the
// registrations a pod speaks for, so `<org>-<name>` either names a reviewed
// workload registration or the request is refused. Two declarations, each
// reviewed where it lives: the deployment names the account that speaks, the
// registration says it may be spoken for — client_credentials alone only says the
// app holds a secret. With neither variable set the grant does not exist and the
// endpoint answers unsupported_grant_type.
//
// A GitHub Actions job speaks the same way. GitHub's issuer is one more entry in
// IAM_CLUSTER_ISSUERS, and the job asks it for an ID token whose audience is this
// issuer. That token names the repository the run belongs to, and IAM_REPOSITORIES
// maps the repository to the CI application it speaks for. A pipeline then logs
// in to KMS with no stored secret: the credential is the run itself, minted per
// job by GitHub and good for minutes.
const (
// grantTypeAssertion is RFC 7523 §2.1's grant type — the assertion IS the
// authentication, so no client secret travels with it.
grantTypeAssertion = "urn:ietf:params:oauth:grant-type:jwt-bearer"
// saSubject is the prefix Kubernetes puts on every ServiceAccount subject.
saSubject = "system:serviceaccount:"
envClusters = "IAM_CLUSTER_ISSUERS"
envWorkloads = "IAM_WORKLOADS"
envRepositories = "IAM_REPOSITORIES"
// githubIssuer is the `iss` of every GitHub Actions ID token. An assertion
// from it names a repository, never a service account, so it is read by
// repository and nothing else.
githubIssuer = "https://token.actions.githubusercontent.com"
)
// assertionClaims is what an assertion states: the registered claims every
// issuer sets, and the repository claims GitHub adds to an Actions ID token.
type assertionClaims struct {
jwt.RegisteredClaims
RepositoryOwner string `json:"repository_owner"`
RepositoryOwnerID string `json:"repository_owner_id"`
Repository string `json:"repository"`
Ref string `json:"ref"`
}
// clusterAlgs is the closed set of algorithms a cluster assertion may be signed
// under — the asymmetric families kube-apiserver signs ServiceAccount tokens
// with. alg:none and every HMAC family are absent, so a forged header cannot
// select a verification path that trusts material the attacker supplied.
var clusterAlgs = []string{"RS256", "RS384", "RS512", "ES256", "ES384", "ES512"}
// workloadGrant handles grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer.
func workloadGrant(c *zip.Ctx, db orm.DB) error {
ctx := c.Context()
now := nowFunc()
// 1) Config. Unconfigured is not a refusal — it is a grant this deployment
// does not offer, which is what unsupported_grant_type says. A config that
// is present but unreadable is a different thing and says so: silently
// behaving as if nothing were configured would turn one bad JSON character
// into every workload in the fleet failing to authenticate, with nothing
// naming the reason.
set, err := clusters()
if err != nil {
return tokenError(c, 500, "server_error", err.Error())
}
orgs, err := workloads()
if err != nil {
return tokenError(c, 500, "server_error", err.Error())
}
repos, err := repositories()
if err != nil {
return tokenError(c, 500, "server_error", err.Error())
}
if len(set) == 0 && len(orgs) == 0 && len(repos) == 0 {
return tokenError(c, 400, "unsupported_grant_type", "unsupported grant_type")
}
// 2) The assertion (RFC 7523 §2.1, required) is the whole credential.
assertion := param(c, "assertion")
if assertion == "" {
return tokenError(c, 400, "invalid_request", "assertion is required")
}
iss, err := tokenIssuer(c)
if err != nil {
return tokenError(c, 500, "server_error", "")
}
claims, err := verifyAssertion(assertion, iss, set)
if err != nil {
return tokenError(c, 400, "invalid_grant", "the assertion is invalid or expired")
}
// 3) Identity. The configuration names this exact account and the org it
// speaks in, and the account's name is the app's; together they ARE the
// clientId provision.yaml derives, so a workload can only ever reach the
// registration configured for it — and the same name in another namespace
// is another account, which reaches nothing. A GitHub run is named by its
// repository instead (repositoryApp), and reaches the one CI application
// configured for it.
var org, clientID string
if claims.Issuer == githubIssuer {
if org, clientID, err = repositoryApp(claims, repos); err != nil {
return tokenError(c, 403, "unauthorized_client", err.Error())
}
} else {
namespace, account := serviceAccount(claims.Subject)
if namespace == "" {
return tokenError(c, 400, "invalid_grant", "the assertion does not name a service account")
}
org = orgs[namespace+":"+account]
if org == "" {
return tokenError(c, 403, "unauthorized_client", "no organization is configured for the service account "+namespace+":"+account)
}
clientID = org + "-" + account
}
app, err := store.GetApplicationByClientId(ctx, db, clientID)
if err != nil {
return tokenError(c, 500, "server_error", "")
}
// The application must ALREADY exist, belong to the org the account is
// configured in, and declare BOTH grants in play: jwt-bearer, which says a pod may speak
// for it, and client_credentials, whose token it is about to be handed. Never
// auto-created: a registration that appears because a pod asked for one is a
// registration nobody reviewed. The org check is what keeps the mapping
// honest — a clientId is a globally unique STRING, so `zoo-pkg` registered
// under some other org would otherwise let a zoo account mint that org's
// token. The jwt-bearer check is what keeps the REGISTRATION honest: an account
// configured to speak reaches only an app that agreed to be spoken for.
if app == nil || app.Organization != org ||
!appGrants(app, grantTypeAssertion) || !appGrants(app, "client_credentials") ||
publicTokenEndpointForbidden(app) {
return tokenError(c, 403, "unauthorized_client", clientID+" is not a declared workload application")
}
// 4) Mint what client_credentials would mint for this application — same
// signer, same claims, azp = the app — and record who obtained it.
resp, err := machineToken(ctx, db, app, iss, param(c, "scope"), resourceOf(c), "wl", now)
if err != nil {
return mintError(c, err)
}
// The row records the service account that PRESENTED the assertion against the
// application the credential is FOR, so it is owned by the tenant that may read
// it — the same shape the exchange grant writes, with the workload standing
// where the acting client stands there.
auditMint(ctx, db, c, schema.ActionWorkloadToken, claims.Subject, org+"/"+app.Name)
return c.JSON(200, resp)
}
// serviceAccount splits a Kubernetes subject into the namespace and the account
// it names. Anything else — a human's subject, a node's, a truncated one —
// yields empty strings and is refused: this grant speaks for service accounts,
// and a subject it cannot read is not one it may guess at.
func serviceAccount(sub string) (namespace, name string) {
rest, ok := strings.CutPrefix(sub, saSubject)
if !ok {
return "", ""
}
namespace, name, ok = strings.Cut(rest, ":")
if !ok || namespace == "" || name == "" || strings.ContainsRune(name, ':') {
return "", ""
}
return namespace, name
}
// verifyAssertion checks an assertion against the cluster that issued it and
// returns its validated claims. Fail-closed by construction: the issuer selects
// the key source, so an issuer nobody configured has no keys and therefore no
// verification path at all — there is nothing to relax.
func verifyAssertion(assertion, audience string, set map[string]*cluster) (*assertionClaims, error) {
claims := &assertionClaims{}
key := func(t *jwt.Token) (any, error) {
// ParseWithClaims decodes the claims before it asks for a key, so `iss` is
// readable here and is the ONLY thing that chooses where the key comes from.
k := set[claims.Issuer]
if k == nil {
return nil, fmt.Errorf("workload: %q is not a configured cluster issuer", claims.Issuer)
}
kid, _ := t.Header["kid"].(string)
if kid == "" {
return nil, errors.New("workload: the assertion carries no kid")
}
return k.key(kid)
}
if _, err := jwt.ParseWithClaims(assertion, claims, key,
jwt.WithValidMethods(clusterAlgs),
jwt.WithTimeFunc(nowFunc),
jwt.WithAudience(audience),
jwt.WithExpirationRequired(),
); err != nil {
return nil, err
}
return claims, nil
}
// cluster is one trusted Kubernetes issuer: where its key set is published, what
// it takes to read it, and the keys read so far.
type cluster struct {
iss string
uri string
bearer string // path to the token that reads the key set; "" where it is public
client *http.Client
mu sync.Mutex
keys map[string]any
until time.Time // when the held set goes stale
reread bool // an unknown kid already made this set re-read once
}
const (
// keyLife is how long a key set stands when the issuer states nothing.
keyLife = 10 * time.Minute
// keyRetry is how long a held set stands after a read that did not answer,
// so a failing apiserver costs one attempt rather than one per request.
keyRetry = 30 * time.Second
// readLimit and readTimeout bound a JWKS read. A key set is a small document;
// anything larger is not one.
readLimit = 1 << 20
readTimeout = 10 * time.Second
)
// errNoKey is a kid the issuer does not publish — after a re-read, so a rotation
// the cluster performed without telling anyone is not mistaken for a forgery.
var errNoKey = errors.New("workload: the cluster publishes no such key")
// key returns the verification key for kid, reading the issuer's JWKS when the
// held set cannot answer.
//
// A cluster rotates its signing key on its own schedule, so the first token
// carrying the new kid is what asks for it — the held set is re-read even though
// it has not aged out.
//
// An UNPRODUCTIVE re-read is the one such read a held set gets: a kid nobody
// publishes costs a single read and then nothing, while a rotation that the
// re-read did resolve leaves the set answering as it always did. Without that,
// anyone who can reach the token endpoint has an amplifier pointed at the
// apiserver — a made-up kid per request is a JWKS read per request.
func (k *cluster) key(kid string) (any, error) {
k.mu.Lock()
defer k.mu.Unlock()
fresh := k.keys != nil && nowFunc().Before(k.until)
if fresh {
if key, ok := k.keys[kid]; ok {
return key, nil
}
if k.reread {
return nil, errNoKey
}
}
keys, life, err := k.read()
if err != nil {
if key, ok := k.keys[kid]; ok {
k.until = nowFunc().Add(keyRetry) // it did not answer; what we hold still verifies
return key, nil
}
return nil, err
}
key, ok := keys[kid]
k.keys, k.until, k.reread = keys, nowFunc().Add(life), fresh && !ok
if !ok {
return nil, errNoKey
}
return key, nil
}
// read fetches and decodes the issuer's key set, with the lifetime the response
// asks for.
//
// Some apiservers — k3s among them — refuse an anonymous read of the key set and
// answer 401. IAM then reads it as a client of that cluster too, presenting its
// own ServiceAccount token bound to nothing but
// system:service-account-issuer-discovery: the least authority that can see a
// document whose whole content is public keys.
//
// That token is read from disk at EVERY fetch and never held, because the kubelet
// projecting it rotates it in place — a copy taken at boot is a copy that stops
// working somewhere in the middle of a Tuesday, and the failure would look like a
// cluster that had gone away.
func (k *cluster) read() (map[string]any, time.Duration, error) {
req, err := http.NewRequest(http.MethodGet, k.uri, nil)
if err != nil {
return nil, 0, err
}
if k.bearer != "" {
token, err := os.ReadFile(k.bearer)
if err != nil {
return nil, 0, fmt.Errorf("workload: %s: cannot read the discovery token: %w", k.iss, err)
}
req.Header.Set("Authorization", "Bearer "+strings.TrimSpace(string(token)))
}
resp, err := k.client.Do(req)
if err != nil {
return nil, 0, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, 0, fmt.Errorf("workload: %s answered %d for %s", k.iss, resp.StatusCode, k.uri)
}
body, err := io.ReadAll(io.LimitReader(resp.Body, readLimit))
if err != nil {
return nil, 0, err
}
keys, err := parseKeys(body)
if err != nil {
return nil, 0, err
}
return keys, lifeOf(resp.Header.Get("Cache-Control")), nil
}
// lifeOf reads the lifetime a Cache-Control header asks for, falling back to
// keyLife. Honouring it keeps the server's idea of freshness the issuer's own;
// a header that asks for nothing cacheable would otherwise mean a read per
// request against the apiserver, which is why "no max-age" lands on the default
// rather than on zero.
func lifeOf(header string) time.Duration {
for _, part := range strings.Split(header, ",") {
age, ok := strings.CutPrefix(strings.TrimSpace(part), "max-age=")
if !ok {
continue
}
if n, err := strconv.Atoi(age); err == nil && n > 0 {
return time.Duration(n) * time.Second
}
}
return keyLife
}
// parseKeys decodes a cluster's key set into verification keys by kid, through
// the SAME JWK decoder the federation leg verifies an external id_token with
// (federation_idp.go). One decoder: a second one would be a second opinion about
// what a published key is, and the weaker of the two would be the one an attacker
// picks.
//
// A key it cannot read is skipped rather than failing the set — an issuer that
// also publishes a key type we do not verify still publishes the ones we do — but
// a set with nothing readable in it is an error, because holding one would mean
// answering errNoKey forever without ever reading again.
func parseKeys(body []byte) (map[string]any, error) {
var set jwkSet
if err := json.Unmarshal(body, &set); err != nil {
return nil, err
}
out := make(map[string]any, len(set.Keys))
for _, k := range set.Keys {
pub, err := k.publicKey()
if err != nil || k.Kid == "" {
continue
}
out[k.Kid] = pub
}
if len(out) == 0 {
return nil, errors.New("workload: the cluster key set carries no readable key")
}
return out, nil
}
// trusted holds the cluster set built from IAM_CLUSTER_ISSUERS, rebuilt only when
// the value itself changes. The keys a cluster has read live ON the cluster, so
// the set has to be the same objects from one request to the next — a per-request
// parse would throw the key cache away with the structs that held it.
var trusted struct {
sync.Mutex
built bool
raw string
set map[string]*cluster
err error
}
// clusters is the trusted cluster issuers, by issuer. Empty means the grant is
// not offered here; an error means the config is present and unreadable, which
// is a different answer and gets a different one.
func clusters() (map[string]*cluster, error) {
raw := strings.TrimSpace(os.Getenv(envClusters))
trusted.Lock()
defer trusted.Unlock()
if !trusted.built || raw != trusted.raw {
trusted.built, trusted.raw = true, raw
trusted.set, trusted.err = buildClusters(raw)
}
return trusted.set, trusted.err
}
// buildClusters parses IAM_CLUSTER_ISSUERS:
//
// {"https://kubernetes.default.svc.cluster.local":
// {"jwks_uri": "https://10.0.0.19:6443/openid/v1/jwks",
// "ca_file": "/etc/iam/cluster-ca.crt",
// "bearer_file":"/var/run/secrets/kubernetes.io/serviceaccount/token"}}
//
// ca_file is the certificate that reads the apiserver; bearer_file is optional
// and names the ServiceAccount token to present where the apiserver refuses an
// anonymous read (see cluster.read).
//
// An entry missing its jwks_uri, or naming a CA file that is not a certificate,
// fails the WHOLE set rather than dropping that issuer: a half-built trust set
// looks exactly like a working one until the workloads of the dropped cluster
// start failing to authenticate.
func buildClusters(raw string) (map[string]*cluster, error) {
if raw == "" {
return nil, nil
}
var doc map[string]struct {
JWKS string `json:"jwks_uri"`
CA string `json:"ca_file"`
Bearer string `json:"bearer_file"`
}
if err := json.Unmarshal([]byte(raw), &doc); err != nil {
return nil, fmt.Errorf("%s: invalid JSON: %w", envClusters, err)
}
set := make(map[string]*cluster, len(doc))
for iss, cfg := range doc {
if iss == "" || cfg.JWKS == "" {
return nil, fmt.Errorf("%s: entry %q states no jwks_uri", envClusters, iss)
}
client, err := reader(cfg.CA)
if err != nil {
return nil, fmt.Errorf("%s: entry %q: %w", envClusters, iss, err)
}
set[iss] = &cluster{iss: iss, uri: cfg.JWKS, bearer: cfg.Bearer, client: client}
}
return set, nil
}
// reader builds the client that reads one issuer's key set. The CA is the
// cluster's own: an apiserver serves its key set under a certificate no public
// root signs, so a client carrying only the system pool cannot read it at all.
// An empty ca_file keeps the system pool, for an issuer published behind a
// public CA.
func reader(caFile string) (*http.Client, error) {
transport := http.DefaultTransport.(*http.Transport).Clone()
if caFile != "" {
pem, err := os.ReadFile(caFile)
if err != nil {
return nil, err
}
pool := x509.NewCertPool()
if !pool.AppendCertsFromPEM(pem) {
return nil, fmt.Errorf("%s carries no certificate", caFile)
}
transport.TLSClientConfig = &tls.Config{RootCAs: pool, MinVersion: tls.VersionTLS12}
}
return &http.Client{Transport: transport, Timeout: readTimeout}, nil
}
// workloads reads IAM_WORKLOADS — {"hanzo:pkg":"hanzo","hanzo:chat":"hanzo"} —
// the exact ServiceAccount→org map. Parsed per request rather than held, because
// unlike the cluster set it anchors no cache and a map this size costs less to
// read than to keep in step.
//
// Every key must name ONE account the way a subject does, and every entry an
// org, or the whole map is refused. A bare namespace reads as "every account in
// it", which is exactly what this map exists not to say; matching nothing instead
// would make that mistake look like a deployment where no workload speaks.
func workloads() (map[string]string, error) {
raw := strings.TrimSpace(os.Getenv(envWorkloads))
if raw == "" {
return nil, nil
}
var orgs map[string]string
if err := json.Unmarshal([]byte(raw), &orgs); err != nil {
return nil, fmt.Errorf("%s: invalid JSON: %w", envWorkloads, err)
}
for sa, org := range orgs {
if ns, _ := serviceAccount(saSubject + sa); ns == "" || org == "" {
return nil, fmt.Errorf("%s: %q must map one service account, named <namespace>:<name>, to an org", envWorkloads, sa)
}
}
return orgs, nil
}
// repository is one IAM_REPOSITORIES entry: the CI application a repository's
// runs speak for, as the org it belongs to and its name in that org, and the id
// of the GitHub account that must own the repository.
type repository struct {
Org string `json:"org"`
App string `json:"app"`
OwnerID string `json:"owner_id"`
}
// repositories reads IAM_REPOSITORIES — which GitHub repositories speak, and
// for which CI application:
//
// {"hanzoai": {"org":"hanzo","app":"ci","owner_id":"76520960"},
// "hanzo-apps/network": {"org":"hanzo","app":"sites-ci","owner_id":"…"},
// "luxfi/node@refs/heads/main": {"org":"lux","app":"ci","owner_id":"…"}}
//
// A key is an account, one repository of it, or one ref of that repository,
// always exact. The account id is required: a GitHub account can be renamed and
// its old name registered by someone else, and the id is the one claim that
// cannot follow the name. An entry missing any field refuses the whole map, for
// the reason workloads gives.
func repositories() (map[string]repository, error) {
raw := strings.TrimSpace(os.Getenv(envRepositories))
if raw == "" {
return nil, nil
}
var repos map[string]repository
if err := json.Unmarshal([]byte(raw), &repos); err != nil {
return nil, fmt.Errorf("%s: invalid JSON: %w", envRepositories, err)
}
for key, r := range repos {
name, ref, _ := strings.Cut(key, "@")
owner, repo, hasRepo := strings.Cut(name, "/")
bad := owner == "" || strings.ContainsAny(key, " *?") ||
(hasRepo && (repo == "" || strings.Contains(repo, "/"))) ||
(strings.Contains(key, "@") && (!hasRepo || !strings.HasPrefix(ref, "refs/")))
if _, err := strconv.ParseInt(r.OwnerID, 10, 64); bad || err != nil || r.Org == "" || r.App == "" {
return nil, fmt.Errorf("%s: %q must map an account, <owner>/<repo> or <owner>/<repo>@<ref> to {org, app, owner_id}", envRepositories, key)
}
}
return repos, nil
}
// repositoryApp is the org and clientId a GitHub run speaks for: the most
// specific entry that names it — the ref, then the repository, then the account
// — provided the account that owns the repository is the one the entry was
// written for.
func repositoryApp(claims *assertionClaims, repos map[string]repository) (string, string, error) {
owner, repo := claims.RepositoryOwner, claims.Repository
if owner == "" || !strings.HasPrefix(repo, owner+"/") || !strings.HasPrefix(claims.Subject, "repo:"+repo+":") {
return "", "", errors.New("the assertion does not name a repository")
}
for _, key := range []string{repo + "@" + claims.Ref, repo, owner} {
r, ok := repos[key]
if !ok {
continue
}
if r.OwnerID != claims.RepositoryOwnerID {
return "", "", fmt.Errorf("%s is configured for GitHub account %s, and this run belongs to account %s", key, r.OwnerID, claims.RepositoryOwnerID)
}
return r.Org, r.Org + "-" + r.App, nil
}
return "", "", fmt.Errorf("no CI application is configured for the repository %s", repo)
}
// grantsSupported is the grant list discovery advertises. Every entry is
// implemented AND reachable here: the workload grant appears only where a cluster
// issuer is configured, because a deployment without one does not offer it and a
// document that says otherwise sends clients at a grant that refuses them.
func grantsSupported() []string {
g := []string{"authorization_code", "refresh_token", "client_credentials", "password", grantTypeTokenExchange, deviceGrant}
if set, err := clusters(); err == nil && len(set) > 0 {
g = append(g, grantTypeAssertion)
}
return g
}