Skip to content

Modern Docker Management, Designed for Everyone

8.1 KB
Raw Blame
package auth

import (
	"cmp"
	"encoding/json/v2"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/federated"
	"github.com/spf13/cobra"

	"github.com/getarcaneapp/arcane/cli/v2/internal/ci"
	"github.com/getarcaneapp/arcane/cli/v2/internal/client"
	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/config"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

const (
	maxFederatedErrorBody    = 4096
	maxFederatedResponseBody = 1 << 20
)

func newFederatedCmd() *cobra.Command {
	var opts struct {
		server     string
		audience   string
		provider   string
		token      string
		tokenFile  string
		tokenStdin bool
		persist    bool
		export     bool
	}
	cmd := &cobra.Command{
		Use:          "federated",
		Short:        "Exchange a CI OIDC token for a short-lived Arcane token",
		SilenceUsage: true,
		Long: `Exchange an external OIDC token for a short-lived Arcane bearer token.

GitHub Actions example:
  permissions: { id-token: write, contents: read }
  steps:
    - run: |
        eval "$(arcane-cli auth federated \
          --server https://arcane.example.com \
          --audience https://arcane.example.com --export)"
    - run: arcane-cli projects up my-app`,
		Args: cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			if cmdutil.JSONOutputEnabled(cmd) && opts.export {
				return errors.New("flags --json and --export cannot be used together")
			}
			audience := opts.audience

			cfg, err := config.Load()
			if err != nil {
				return fmt.Errorf("failed to load config: %w", err)
			}
			if strings.TrimSpace(opts.server) != "" {
				cfg.ServerURL = strings.TrimSpace(opts.server)
			}
			if strings.TrimSpace(audience) == "" {
				audience = cfg.FederatedAudience
			}

			subjectToken, tokenSource, err := resolveFederatedSubjectToken(cmd, opts.provider, audience, opts.token, opts.tokenFile, opts.tokenStdin)
			if err != nil {
				return err
			}

			c, err := client.NewUnauthenticated(cfg)
			if err != nil {
				return err
			}

			tokenResp, err := exchangeFederatedToken(cmd, c, strings.TrimSpace(subjectToken), strings.TrimSpace(audience))
			if err != nil {
				return err
			}
			if tokenResp.AccessToken == "" {
				return errors.New("federated token exchange failed: empty access token")
			}

			expiresAt := time.Now().UTC().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)

			if opts.persist {
				cfg.JWTToken = tokenResp.AccessToken
				cfg.APIKey = ""
				cfg.RefreshToken = ""
				if saveErr := config.SaveTokens(cmd.Context(), cfg); saveErr != nil {
					return fmt.Errorf("failed to save federated token: %w", saveErr)
				}
			}

			switch {
			case cmdutil.JSONOutputEnabled(cmd):
				return cmdutil.PrintJSON(struct {
					Token           string `json:"token"`
					TokenType       string `json:"tokenType"`
					ExpiresIn       int    `json:"expiresIn"`
					ExpiresAt       string `json:"expiresAt"`
					IssuedTokenType string `json:"issuedTokenType"`
					Source          string `json:"source"`
					Persisted       bool   `json:"persisted"`
				}{
					Token:           tokenResp.AccessToken,
					TokenType:       tokenResp.TokenType,
					ExpiresIn:       tokenResp.ExpiresIn,
					ExpiresAt:       expiresAt.Format(time.RFC3339),
					IssuedTokenType: tokenResp.IssuedTokenType,
					Source:          tokenSource,
					Persisted:       opts.persist,
				})
			case opts.export:
				_, _ = fmt.Fprintf(output.Stdout(), "export ARCANE_TOKEN=%s\n", "'"+strings.ReplaceAll(tokenResp.AccessToken, "'", "'\\''")+"'")
				_, _ = fmt.Fprintf(output.Stdout(), "export ARCANE_TOKEN_EXPIRES_AT=%s\n", "'"+strings.ReplaceAll(expiresAt.Format(time.RFC3339), "'", "'\\''")+"'")
			default:
				output.Success("Federated token exchange successful")
				output.KeyValue("Token source", tokenSource)
				output.KeyValue("Expires at", expiresAt.Format(time.RFC3339))
				if opts.persist {
					path, _ := config.AuthPath()
					output.KeyValue("Session saved to", path)
				} else {
					output.Info("Use --export, --json, or --persist to consume the token.")
				}
			}

			return nil
		},
	}
	cmd.Flags().StringVar(&opts.server, "server", "", "Arcane server URL for this exchange")
	cmd.Flags().StringVar(&opts.audience, "audience", "", "Audience to request from the external OIDC provider")
	cmd.Flags().StringVar(&opts.token, "token", "", "External OIDC token to exchange")
	cmd.Flags().StringVar(&opts.tokenFile, "token-file", "", "Path to a file containing the external OIDC token")
	cmd.Flags().BoolVar(&opts.tokenStdin, "token-stdin", false, "Read the external OIDC token from stdin")
	cmdutil.EnumVarP(cmd, cmd.Flags(), &opts.provider, "provider", "", ci.ProviderAuto, "OIDC token source",
		ci.ProviderAuto, ci.ProviderGitHub, ci.ProviderGitLab, ci.ProviderGeneric)
	cmd.Flags().BoolVar(&opts.persist, "persist", false, "Persist the exchanged Arcane token in CLI config")
	cmd.Flags().BoolVar(&opts.export, "export", false, "Print shell exports for ARCANE_TOKEN and ARCANE_TOKEN_EXPIRES_AT")
	return cmd
}

func resolveFederatedSubjectToken(cmd *cobra.Command, provider, audience, federatedToken, federatedTokenFile string, federatedTokenStdin bool) (string, string, error) {
	token := federatedToken
	if strings.TrimSpace(token) != "" {
		return strings.TrimSpace(token), "flag", nil
	}

	if strings.TrimSpace(federatedTokenFile) != "" {
		data, err := os.ReadFile(strings.TrimSpace(federatedTokenFile))
		if err != nil {
			return "", "", fmt.Errorf("failed to read token file: %w", err)
		}
		token = strings.TrimSpace(string(data))
		if token == "" {
			return "", "", errors.New("token file is empty")
		}
		return token, "file", nil
	}

	input := cmd.InOrStdin()
	stdinHasData := false
	if file, ok := input.(interface{ Stat() (os.FileInfo, error) }); ok {
		info, err := file.Stat()
		stdinHasData = err == nil && info.Mode()&os.ModeCharDevice == 0
	}
	if federatedTokenStdin || stdinHasData {
		data, err := output.ReadWithContext(cmd.Context(), input, io.ReadAll)
		if err != nil {
			return "", "", fmt.Errorf("failed to read token from stdin: %w", err)
		}
		token = strings.TrimSpace(string(data))
		if token == "" {
			return "", "", errors.New("stdin token is empty")
		}
		return token, "stdin", nil
	}

	return ci.DetectToken(cmd.Context(), provider, audience, os.Getenv, &http.Client{Timeout: 10 * time.Second})
}

func exchangeFederatedToken(cmd *cobra.Command, c *client.Client, subjectToken, audience string) (*federated.FederatedTokenResponse, error) {
	form := url.Values{
		"grant_type":           {federated.TokenExchangeGrantType},
		"subject_token":        {subjectToken},
		"subject_token_type":   {federated.SubjectTokenTypeJWT},
		"requested_token_type": {federated.RequestedTokenTypeAccessJWT},
	}
	if strings.TrimSpace(audience) != "" {
		form.Set("audience", strings.TrimSpace(audience))
	}

	resp, err := c.RequestRaw(cmd.Context(), http.MethodPost, types.AuthFederated(), strings.NewReader(form.Encode()), map[string]string{
		"Content-Type": "application/x-www-form-urlencoded",
	})
	if err != nil {
		return nil, fmt.Errorf("federated token exchange failed: %w", err)
	}
	defer func() { _ = resp.Body.Close() }()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		body, _ := io.ReadAll(io.LimitReader(resp.Body, maxFederatedErrorBody))
		var oauthErr struct {
			Error            string `json:"error"`
			ErrorDescription string `json:"error_description"` //nolint:tagliatelle // RFC 6749 wire shape is snake_case.
		}
		_ = json.Unmarshal(body, &oauthErr)
		message := cmp.Or(strings.TrimSpace(oauthErr.ErrorDescription), strings.TrimSpace(oauthErr.Error), strings.TrimSpace(string(body)), "request rejected")
		return nil, fmt.Errorf("federated token exchange failed (status %d): %s", resp.StatusCode, message)
	}

	body, err := io.ReadAll(io.LimitReader(resp.Body, maxFederatedResponseBody))
	if err != nil {
		return nil, fmt.Errorf("failed to read federated token response: %w", err)
	}

	var tokenResp federated.FederatedTokenResponse
	if unmarshalErr := json.Unmarshal(body, &tokenResp); unmarshalErr != nil {
		return nil, fmt.Errorf("failed to parse federated token response: %w", unmarshalErr)
	}
	return &tokenResp, nil
}