Files
iam/internal/oidc/workload.go
zeekay 4b2ea484f5 oidc: a GitHub run's subject may carry its ids
GitHub signs some runs' subject with the account's and repository's
ids beside their names: a hanzo-inc/app run carries
repo:hanzo-inc@308927965/app@1345862086:ref:refs/heads/main. The
workload grant read only repo:<owner>/<name>:, so every such run was
refused with "the assertion does not name a repository" and fell back
to a stored KMS pair, or failed where none was set (zoo-apps/ngo).

The ids spelling names the repository only when both ids are the ones
the token states (repository_owner_id, repository_id); another id, or
a token that states none, is still refused.

Claude-Session: https://claude.ai/code/session_01BLLMyBFSvAfCt7ZGqYuiEz
2026-10-22 11:45:43 -07:00

624 lines
25 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"`
RepositoryID string `json:"repository_id"`
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+"/") || !namesRepository(claims) {
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)
}
// namesRepository reports whether the run's subject is the repository its claims
// name, in either spelling GitHub signs: `repo:<owner>/<name>:…`, or the
// immutable `repo:<owner>@<owner id>/<name>@<repository id>:…`, whose ids must
// be the ones the token states — the spelling a run of hanzo-inc/app carries.
func namesRepository(claims *assertionClaims) bool {
rest, ok := strings.CutPrefix(claims.Subject, "repo:")
if !ok {
return false
}
who, _, ok := strings.Cut(rest, ":")
if !ok {
return false
}
if who == claims.Repository {
return true
}
name := strings.TrimPrefix(claims.Repository, claims.RepositoryOwner+"/")
return claims.RepositoryOwnerID != "" && claims.RepositoryID != "" &&
who == claims.RepositoryOwner+"@"+claims.RepositoryOwnerID+"/"+name+"@"+claims.RepositoryID
}
// 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
}