Skip to content

Modern Docker Management, Designed for Everyone

13.2 KB
Raw Blame
package federated

import (
	"context"
	"crypto/mldsa"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/federated"
	"github.com/lestrrat-go/jwx/v4/jwa"
	"github.com/lestrrat-go/jwx/v4/jws"
	"github.com/lestrrat-go/jwx/v4/jwt"
	"github.com/libtnb/sqlite"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/auth"
	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/config"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/event"
	"github.com/getarcaneapp/arcane/backend/v2/internal/role"
	"github.com/getarcaneapp/arcane/backend/v2/internal/session"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	"github.com/getarcaneapp/arcane/backend/v2/internal/user"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/oidcjwk"
)

type federatedTestIssuer struct {
	IssuerURL string
	private   *mldsa.PrivateKey
	keyID     string
	server    *httptest.Server
}

func newFederatedTestIssuer(t *testing.T) *federatedTestIssuer {
	t.Helper()

	privateKey, err := mldsa.GenerateKey(mldsa.MLDSA87())
	require.NoError(t, err)

	issuer := &federatedTestIssuer{
		private: privateKey,
		keyID:   "federated-test-key",
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, _ *http.Request) {
		if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]any{
			"issuer":                                issuer.IssuerURL,
			"jwks_uri":                              issuer.IssuerURL + "/jwks",
			"authorization_endpoint":                issuer.IssuerURL + "/authorize",
			"token_endpoint":                        issuer.IssuerURL + "/token",
			"subject_types_supported":               []string{"public"},
			"id_token_signing_alg_values_supported": []string{jwa.MLDSA87().String()},
		})) {
			return
		}
	})
	mux.HandleFunc("/jwks", func(w http.ResponseWriter, _ *http.Request) {
		pub := privateKey.PublicKey()
		if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]any{
			"keys": []map[string]any{
				{
					"kty": "AKP",
					"use": "sig",
					"kid": issuer.keyID,
					"alg": jwa.MLDSA87().String(),
					"pub": base64.RawURLEncoding.EncodeToString(pub.Bytes()),
				},
			},
		})) {
			return
		}
	})

	issuer.server = httptest.NewServer(mux)
	issuer.IssuerURL = issuer.server.URL
	t.Cleanup(issuer.server.Close)

	return issuer
}

func (i *federatedTestIssuer) token(t *testing.T, subject string, audience []string) string {
	t.Helper()

	now := time.Now()
	token, err := jwt.NewBuilder().
		Issuer(i.IssuerURL).
		Subject(subject).
		Audience(audience).
		IssuedAt(now).
		NotBefore(now.Add(-time.Minute)).
		Expiration(now.Add(5 * time.Minute)).
		Build()
	require.NoError(t, err)
	headers := jws.NewHeaders()
	require.NoError(t, headers.Set(jws.KeyIDKey, i.keyID))
	signed, err := jwt.Sign(token, jwt.WithKey(jwa.MLDSA87(), i.private, jws.WithProtectedHeaders(headers)))
	require.NoError(t, err)
	return string(signed)
}

func setupFederatedCredentialServiceTestDB(t *testing.T) *database.DB {
	t.Helper()

	dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()))
	db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(
		&settings.SettingVariable{},
		&user.User{},
		&session.UserSession{},
		&role.Role{},
		&role.UserRoleAssignment{},
		&FederatedCredential{},
		&FederatedTokenReplay{},
		&event.Event{},
	))

	sqlDB, err := db.DB()
	require.NoError(t, err)
	sqlDB.SetMaxOpenConns(1)
	sqlDB.SetMaxIdleConns(1)

	return &database.DB{DB: db}
}

func setupFederatedCredentialService(t *testing.T, issuer *federatedTestIssuer) (*FederatedCredentialService, *auth.AuthService, *database.DB) {
	t.Helper()

	ctx := t.Context()
	db := setupFederatedCredentialServiceTestDB(t)
	roleSvc := role.NewRoleService(db)
	userSvc := user.NewUserService(db, roleSvc, session.RevokeAllUserSessionsExceptInDB)
	sessionSvc := session.NewSessionService(db)
	settingsSvc, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	eventSvc := event.NewEventService(db, &config.Config{}, nil)
	signingKey, err := mldsa.GenerateKey(mldsa.MLDSA87())
	require.NoError(t, err)
	authSvc := auth.NewAuthService(userSvc, settingsSvc, eventSvc, sessionSvc, roleSvc, &config.Config{
		JWTRefreshExpiry: 24 * time.Hour,
	}).WithSigningKey(signingKey)

	keySetManager := oidcjwk.NewKeySetManager(t.Context())
	t.Cleanup(func() {
		shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(t.Context()), time.Second)
		defer cancel()
		require.NoError(t, keySetManager.Shutdown(shutdownCtx))
	})
	service := NewFederatedCredentialService(db, authSvc, userSvc, settingsSvc, eventSvc, issuer.server.Client(), keySetManager, roleSvc)

	viewerRole := role.Role{
		ID:          "role-federated-viewer",
		Name:        "Federated Viewer",
		Permissions: database.StringSlice{authz.PermProjectsList},
	}
	require.NoError(t, db.WithContext(ctx).Create(&viewerRole).Error)

	serviceUser := user.User{
		ID:               "user-federated-service",
		Username:         "svc-federated-demo",
		IsServiceAccount: true,
	}
	require.NoError(t, db.WithContext(ctx).Create(&serviceUser).Error)
	require.NoError(t, db.WithContext(ctx).Create(&role.UserRoleAssignment{
		UserID: serviceUser.ID,
		RoleID: viewerRole.ID,
	}).Error)

	credential := FederatedCredential{
		ID:              "cred-github-actions",
		Name:            "GitHub Actions",
		Enabled:         true,
		IssuerURL:       issuer.IssuerURL,
		Audiences:       database.StringSlice{"arcane-ci"},
		SubjectClaim:    "sub",
		SubjectMatch:    "repo:getarcaneapp/arcane:*",
		MatchType:       federated.MatchTypeGlob,
		RoleID:          viewerRole.ID,
		IdentityUserID:  serviceUser.ID,
		TokenTTLSeconds: 900,
	}
	require.NoError(t, db.WithContext(ctx).Create(&credential).Error)

	return service, authSvc, db
}

func TestFederatedCredentialServiceExchangeToken(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	service, authSvc, db := setupFederatedCredentialService(t, issuer)
	ctx := t.Context()

	tests := []struct {
		name      string
		token     string
		wantError func(error) bool
	}{
		{
			name:  "issues an Arcane bearer token for a matching issuer audience and subject",
			token: issuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),
		},
		{
			name:  "rejects audience mismatch",
			token: issuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"other-audience"}),
			wantError: func(err error) bool {
				return errors.Is(err, common.ErrFederatedCredentialInvalidGrant)
			},
		},
		{
			name:  "rejects subject mismatch",
			token: issuer.token(t, "repo:other/repo:ref:refs/heads/main", []string{"arcane-ci"}),
			wantError: func(err error) bool {
				return errors.Is(err, common.ErrFederatedCredentialInvalidGrant)
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			resp, err := service.ExchangeToken(ctx, federated.TokenExchangeRequest{
				GrantType:        federated.TokenExchangeGrantType,
				SubjectToken:     tt.token,
				SubjectTokenType: federated.SubjectTokenTypeJWT,
				Audience:         "https://arcane.example.com",
			})
			if tt.wantError != nil {
				require.Error(t, err)
				require.True(t, tt.wantError(err), "unexpected error: %v", err)
				require.Nil(t, resp)
				return
			}

			require.NoError(t, err)
			require.NotNil(t, resp)
			require.Equal(t, "Bearer", resp.TokenType)
			require.Equal(t, federated.IssuedTokenTypeAccessToken, resp.IssuedTokenType)
			require.Positive(t, resp.ExpiresIn)
			require.NotEmpty(t, resp.AccessToken)

			localUser, sessionID, err := authSvc.VerifyToken(ctx, resp.AccessToken)
			require.NoError(t, err)
			require.Equal(t, "user-federated-service", localUser.ID)

			var userSession session.UserSession
			require.NoError(t, db.WithContext(ctx).Where("id = ?", sessionID).First(&userSession).Error)
			require.Equal(t, session.UserSessionSourceFederated, userSession.Source)
			require.NotNil(t, userSession.FederatedCredentialID)
			require.Equal(t, "cred-github-actions", *userSession.FederatedCredentialID)
		})
	}
}

func TestFederatedCredentialServiceExchangeTokenRejectsIssuerWithoutCredential(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	otherIssuer := newFederatedTestIssuer(t)
	service, _, _ := setupFederatedCredentialService(t, issuer)

	resp, err := service.ExchangeToken(t.Context(), federated.TokenExchangeRequest{
		GrantType:        federated.TokenExchangeGrantType,
		SubjectToken:     otherIssuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),
		SubjectTokenType: federated.SubjectTokenTypeJWT,
		Audience:         "https://arcane.example.com",
	})

	require.Error(t, err)
	require.ErrorIs(t, err, common.ErrFederatedCredentialInvalidGrant, "unexpected error: %v", err)
	require.Nil(t, resp)
}

func TestFederatedCredentialServiceExchangeTokenDoesNotRequireGlobalFeatureFlag(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	service, _, _ := setupFederatedCredentialService(t, issuer)
	service.settingsService = nil

	resp, err := service.ExchangeToken(t.Context(), federated.TokenExchangeRequest{
		GrantType:        federated.TokenExchangeGrantType,
		SubjectToken:     issuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),
		SubjectTokenType: federated.SubjectTokenTypeJWT,
		Audience:         "https://arcane.example.com",
	})

	require.NoError(t, err)
	require.NotNil(t, resp)
	require.NotEmpty(t, resp.AccessToken)
}

func TestFederatedCredentialServiceExchangeTokenRejectsExpiredCredential(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	service, _, db := setupFederatedCredentialService(t, issuer)
	expiredAt := time.Now().Add(-time.Minute)
	require.NoError(t, db.WithContext(t.Context()).
		Model(&FederatedCredential{}).
		Where("id = ?", "cred-github-actions").
		Update("expires_at", expiredAt).Error)

	resp, err := service.ExchangeToken(t.Context(), federated.TokenExchangeRequest{
		GrantType:        federated.TokenExchangeGrantType,
		SubjectToken:     issuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),
		SubjectTokenType: federated.SubjectTokenTypeJWT,
		Audience:         "https://arcane.example.com",
	})

	require.Error(t, err)
	require.ErrorIs(t, err, common.ErrFederatedCredentialInvalidGrant, "unexpected error: %v", err)
	require.Nil(t, resp)
}

func TestFederatedCredentialServiceUpdateDisableRevokesIssuedSessions(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	service, authSvc, _ := setupFederatedCredentialService(t, issuer)
	ctx := t.Context()

	resp, err := service.ExchangeToken(ctx, federated.TokenExchangeRequest{
		GrantType:        federated.TokenExchangeGrantType,
		SubjectToken:     issuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),
		SubjectTokenType: federated.SubjectTokenTypeJWT,
		Audience:         "https://arcane.example.com",
	})
	require.NoError(t, err)
	require.NotNil(t, resp)

	_, err = service.Update(ctx, "admin-user", "cred-github-actions", federated.UpdateFederatedCredential{
		Enabled: new(false),
	})
	require.NoError(t, err)

	_, _, err = authSvc.VerifyToken(ctx, resp.AccessToken)
	require.Error(t, err)
	require.ErrorIs(t, err, common.ErrSessionRevoked, "unexpected error: %v", err)
}

func TestFederatedCredentialServiceRejectsReplayedSubjectToken(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	service, _, _ := setupFederatedCredentialService(t, issuer)
	ctx := t.Context()
	subjectToken := issuer.token(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"})
	req := federated.TokenExchangeRequest{
		GrantType:        federated.TokenExchangeGrantType,
		SubjectToken:     subjectToken,
		SubjectTokenType: federated.SubjectTokenTypeJWT,
		Audience:         "https://arcane.example.com",
	}

	first, err := service.ExchangeToken(ctx, req)
	require.NoError(t, err)
	require.NotNil(t, first)

	second, err := service.ExchangeToken(ctx, req)
	require.Error(t, err)
	require.ErrorIs(t, err, common.ErrFederatedCredentialInvalidGrant, "unexpected error: %v", err)
	require.Nil(t, second)
}

func TestFederatedCredentialServiceCreateRejectsBareWildcardGlob(t *testing.T) {
	issuer := newFederatedTestIssuer(t)
	service, _, _ := setupFederatedCredentialService(t, issuer)

	_, err := service.Create(t.Context(), "admin-user", federated.CreateFederatedCredential{
		Name:            "Unsafe wildcard",
		IssuerURL:       "https://token.actions.githubusercontent.com",
		Audiences:       []string{"arcane-ci"},
		SubjectMatch:    "*",
		MatchType:       federated.MatchTypeGlob,
		RoleID:          "role-federated-viewer",
		TokenTTLSeconds: 900,
	})

	require.Error(t, err)
	require.ErrorIs(t, err, common.ErrFederatedCredentialInvalid, "unexpected error: %v", err)
}

func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
	t.Helper()
	svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
	if err == nil {
		t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
	}
	return svc, err
}