Skip to content

Modern Docker Management, Designed for Everyone

13.4 KB
Raw Blame
package passkey

import (
	"testing"
	"time"
	"uuid"

	"github.com/getarcaneapp/arcane/types/v2/auth"
	"github.com/libtnb/sqlite"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/config"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/session"
	userdomain "github.com/getarcaneapp/arcane/backend/v2/internal/user"
)

func newPasskeyServiceTestDB(t *testing.T) *database.DB {
	t.Helper()
	gormDB, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, gormDB.AutoMigrate(
		&userdomain.User{},
		&session.UserSession{},
		&Passkey{},
		&PasskeyCeremony{},
		&AuthTransaction{},
		&PasskeyRecoveryCode{},
	))

	db := &database.DB{DB: gormDB}
	t.Cleanup(func() {
		require.NoError(t, db.Close())
	})
	return db
}

func newPasskeyServiceForTest(t *testing.T, db *database.DB) *PasskeyService {
	t.Helper()
	return NewPasskeyService(db, &config.Config{AppUrl: "https://arcane.example.test"})
}

func createPasskeyTestUser(t *testing.T, db *database.DB, id string) *userdomain.User {
	t.Helper()
	user := &userdomain.User{
		ID:           id,
		Username:     id,
		PasswordHash: "stored-password-hash",
	}
	require.NoError(t, db.Create(user).Error)
	return user
}

func createPasskeyTestCredential(t *testing.T, db *database.DB, service *PasskeyService, userID, id string) *Passkey {
	t.Helper()
	credential := &Passkey{
		ID:           id,
		UserID:       userID,
		RPID:         service.rpID,
		CredentialID: []byte("credential-" + id),
		PublicKey:    []byte("public-key-" + id),
		Transports:   database.StringSlice{"internal"},
		Name:         "Test passkey",
	}
	require.NoError(t, db.Create(credential).Error)
	return credential
}

func TestPasskeyService_BeginPasskeyLoginStoresAndConsumesCeremony(t *testing.T) {
	db := newPasskeyServiceTestDB(t)
	service := newPasskeyServiceForTest(t, db)
	ctx := t.Context()

	challenge, err := service.BeginPasskeyLogin(ctx)
	require.NoError(t, err)
	require.NotEmpty(t, challenge.CeremonyID)
	require.NotNil(t, challenge.Options)

	var ceremony PasskeyCeremony
	require.NoError(t, db.Where("id = ?", challenge.CeremonyID).First(&ceremony).Error)
	require.Equal(t, passkeyCeremonyPurposeLogin, ceremony.Purpose)
	require.Equal(t, service.rpID, ceremony.RPID)
	require.Empty(t, ceremony.UserID)
	require.NotEmpty(t, ceremony.SessionData)
	require.WithinDuration(t, challenge.ExpiresAt, ceremony.ExpiresAt, time.Second)

	_, err = service.FinishPasskeyLogin(ctx, challenge.CeremonyID, []byte(`{}`))
	require.ErrorIs(t, err, ErrPasskeyResponse)

	var consumed PasskeyCeremony
	require.NoError(t, db.Where("id = ?", challenge.CeremonyID).First(&consumed).Error)
	require.NotNil(t, consumed.ConsumedAt)

	_, err = service.FinishPasskeyLogin(ctx, challenge.CeremonyID, []byte(`{}`))
	require.ErrorIs(t, err, ErrPasskeyCeremony)
}

func TestPasskeyService_LoginAvailability(t *testing.T) {
	for _, scenario := range []string{"empty", "registered", "other RP", "missing user", "deleted", "unavailable", "database error"} {
		t.Run(scenario, func(t *testing.T) {
			db := newPasskeyServiceTestDB(t)
			service := newPasskeyServiceForTest(t, db)
			if scenario != "empty" {
				user := createPasskeyTestUser(t, db, "availability-user")
				credential := createPasskeyTestCredential(t, db, service, user.ID, "availability-passkey")
				switch scenario {
				case "other RP":
					require.NoError(t, db.Model(credential).Update("rp_id", "other.example.test").Error)
				case "missing user":
					require.NoError(t, db.Model(credential).Update("user_id", "missing-user").Error)
				case "deleted":
					require.NoError(t, db.Delete(credential).Error)
				case "unavailable":
					service = NewPasskeyService(db, &config.Config{AppUrl: ":invalid"})
				case "database error":
					require.NoError(t, db.Migrator().DropTable(&Passkey{}))
				}
			}

			available, err := service.LoginAvailable(t.Context())
			if scenario == "database error" {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
			require.Equal(t, scenario == "registered", available)
		})
	}
}

func TestPasskeyService_FirstEnrollmentUsesActiveSession(t *testing.T) {
	db := newPasskeyServiceTestDB(t)
	service := newPasskeyServiceForTest(t, db)
	ctx := t.Context()
	user := createPasskeyTestUser(t, db, "first-enrollment-user")
	sessionService := session.NewSessionService(db)
	localSession, _, err := sessionService.CreateSession(ctx, user.ID, time.Now().Add(time.Hour), auth.SessionMeta{})
	require.NoError(t, err)

	capabilities, err := service.GetCapabilities(ctx, user.ID, false)
	require.NoError(t, err)
	require.Zero(t, capabilities.PasskeyCount)
	require.True(t, capabilities.CanEnrollWithActiveSession)
	require.False(t, capabilities.RequiresStepUp)

	challenge, err := service.BeginRegistration(ctx, user.ID, localSession.ID, "")
	require.NoError(t, err)
	require.NotEmpty(t, challenge.CeremonyID)
	require.NotNil(t, challenge.Options)

	createPasskeyTestCredential(t, db, service, user.ID, "existing-passkey")
	capabilities, err = service.GetCapabilities(ctx, user.ID, false)
	require.NoError(t, err)
	require.Equal(t, 1, capabilities.PasskeyCount)
	require.False(t, capabilities.CanEnrollWithActiveSession)
	require.True(t, capabilities.RequiresStepUp)

	_, err = service.BeginRegistration(ctx, user.ID, localSession.ID, "")
	require.ErrorIs(t, err, ErrPasskeyStepUpRequired)
}

func TestPasskeyService_DefaultPasskeyNameUsesAAGUIDCatalog(t *testing.T) {
	aaguid := uuid.MustParse("fbfc3007-154e-4ecc-8c0b-6e020557d7bd")
	require.Equal(t, "Apple Passwords Passkey", defaultPasskeyNameInternal(aaguid[:]))
	require.Equal(t, aaguid.String(), formatAAGUIDInternal(aaguid[:]))
	require.Equal(t, "New Passkey", defaultPasskeyNameInternal([]byte{0xff, 0xff, 0xff, 0xff}))

	summary := passkeySummaryInternal(Passkey{AAGUID: aaguid[:]})
	require.Equal(t, aaguid.String(), summary.AAGUID)
}

func TestPasskeyService_PasswordStepUpGrantIsBoundToActiveSessionAndReusableUntilExpiry(t *testing.T) {
	db := newPasskeyServiceTestDB(t)
	service := newPasskeyServiceForTest(t, db)
	ctx := t.Context()
	user := createPasskeyTestUser(t, db, "step-up-user")
	sessionService := session.NewSessionService(db)
	localSession, _, err := sessionService.CreateSession(ctx, user.ID, time.Now().Add(time.Hour), auth.SessionMeta{})
	require.NoError(t, err)

	_, err = service.CreatePasswordStepUpGrant(ctx, user.ID, "missing-session")
	require.ErrorIs(t, err, ErrPasskeyStepUpRequired)

	grant, err := service.CreatePasswordStepUpGrant(ctx, user.ID, localSession.ID)
	require.NoError(t, err)
	require.NotEmpty(t, grant.Token)
	require.True(t, grant.ExpiresAt.After(time.Now()))

	require.NoError(t, service.VerifyStepUpToken(ctx, user.ID, localSession.ID, grant.Token))
	require.NoError(t, service.VerifyStepUpToken(ctx, user.ID, localSession.ID, grant.Token))
	require.ErrorIs(t, service.VerifyStepUpToken(ctx, user.ID, "other-session", grant.Token), ErrPasskeyStepUpRequired)

	require.NoError(t, sessionService.RevokeSession(ctx, localSession.ID))
	_, err = service.CreatePasswordStepUpGrant(ctx, user.ID, localSession.ID)
	require.ErrorIs(t, err, ErrPasskeyStepUpRequired)
}

func TestPasskeyService_RecoveryCodeConsumptionIsAtomicAndSingleUse(t *testing.T) {
	db := newPasskeyServiceTestDB(t)
	service := newPasskeyServiceForTest(t, db)
	ctx := t.Context()
	user := createPasskeyTestUser(t, db, "recovery-user")

	codes, rows, err := generateRecoveryCodeRowsInternal(user.ID)
	require.NoError(t, err)
	require.Len(t, codes, recoveryCodeCount)
	require.NoError(t, db.Create(&rows).Error)

	transaction := newAuthTransactionInternal(user.ID, authTransactionKindMFA, session.UserSessionSourceLocal, auth.SessionMeta{
		UserAgent: "test-agent",
		IPAddress: "127.0.0.1",
	}, nil)
	require.NoError(t, db.Create(transaction).Error)

	_, err = service.FinishRecoveryCode(ctx, transaction.ID, "not-a-recovery-code")
	require.ErrorIs(t, err, ErrPasskeyRecoveryCode)

	var pending AuthTransaction
	require.NoError(t, db.Where("id = ?", transaction.ID).First(&pending).Error)
	require.Equal(t, authTransactionPending, pending.Status)

	completion, err := service.FinishRecoveryCode(ctx, transaction.ID, codes[0])
	require.NoError(t, err)
	require.Equal(t, user.ID, completion.User.ID)
	require.Equal(t, session.UserSessionSourceLocal, completion.Source)
	require.Equal(t, session.RecoveryCodeMFAMethod, completion.Meta.MFAMethod)
	require.Equal(t, "test-agent", completion.Meta.UserAgent)
	require.Equal(t, "127.0.0.1", completion.Meta.IPAddress)
	require.NotNil(t, completion.Meta.MFAVerifiedAt)

	var completed AuthTransaction
	require.NoError(t, db.Where("id = ?", transaction.ID).First(&completed).Error)
	require.Equal(t, authTransactionCompleted, completed.Status)
	require.NotNil(t, completed.CompletedAt)

	var consumed PasskeyRecoveryCode
	require.NoError(t, db.Where("user_id = ? AND code_hash = ?", user.ID, rows[0].CodeHash).First(&consumed).Error)
	require.NotNil(t, consumed.UsedAt)

	_, err = service.FinishRecoveryCode(ctx, transaction.ID, codes[0])
	require.ErrorIs(t, err, ErrPasskeyTransaction)
}

func TestPasskeyService_EnableAndDisableMFAManagesCodesAndSessions(t *testing.T) {
	db := newPasskeyServiceTestDB(t)
	service := newPasskeyServiceForTest(t, db)
	ctx := t.Context()
	user := createPasskeyTestUser(t, db, "mfa-user")
	createPasskeyTestCredential(t, db, service, user.ID, "mfa-passkey")
	sessionService := session.NewSessionService(db)
	currentSession, _, err := sessionService.CreateSession(ctx, user.ID, time.Now().Add(time.Hour), auth.SessionMeta{})
	require.NoError(t, err)
	otherSession, _, err := sessionService.CreateSession(ctx, user.ID, time.Now().Add(time.Hour), auth.SessionMeta{})
	require.NoError(t, err)

	grant, err := service.CreatePasswordStepUpGrant(ctx, user.ID, currentSession.ID)
	require.NoError(t, err)
	codes, err := service.EnableMFA(ctx, user.ID, currentSession.ID, grant.Token)
	require.NoError(t, err)
	require.Len(t, codes, recoveryCodeCount)

	var enabledUser userdomain.User
	require.NoError(t, db.Where("id = ?", user.ID).First(&enabledUser).Error)
	require.True(t, enabledUser.PasskeyMFAEnabled)
	var recoveryCodeCountInDB int64
	require.NoError(t, db.Model(&PasskeyRecoveryCode{}).Where("user_id = ? AND used_at IS NULL", user.ID).Count(&recoveryCodeCountInDB).Error)
	require.Equal(t, int64(recoveryCodeCount), recoveryCodeCountInDB)

	disableGrant, err := service.CreatePasswordStepUpGrant(ctx, user.ID, currentSession.ID)
	require.NoError(t, err)
	require.NoError(t, service.DisableMFA(ctx, user.ID, currentSession.ID, disableGrant.Token))

	var disabledUser userdomain.User
	require.NoError(t, db.Where("id = ?", user.ID).First(&disabledUser).Error)
	require.False(t, disabledUser.PasskeyMFAEnabled)
	require.NoError(t, db.Model(&PasskeyRecoveryCode{}).Where("user_id = ?", user.ID).Count(&recoveryCodeCountInDB).Error)
	require.Zero(t, recoveryCodeCountInDB)

	current, err := sessionService.GetSessionByID(ctx, currentSession.ID)
	require.NoError(t, err)
	require.Nil(t, current.RevokedAt)
	other, err := sessionService.GetSessionByID(ctx, otherSession.ID)
	require.NoError(t, err)
	require.NotNil(t, other.RevokedAt)
}

func TestPasskeyService_ResetMFARevokesSessionsAndPreservesPasskeys(t *testing.T) {
	db := newPasskeyServiceTestDB(t)
	service := newPasskeyServiceForTest(t, db)
	ctx := t.Context()
	user := createPasskeyTestUser(t, db, "reset-user")
	user.PasskeyMFAEnabled = true
	require.NoError(t, db.Save(user).Error)
	passkey := createPasskeyTestCredential(t, db, service, user.ID, "reset-passkey")
	sessionService := session.NewSessionService(db)
	firstSession, _, err := sessionService.CreateSession(ctx, user.ID, time.Now().Add(time.Hour), auth.SessionMeta{})
	require.NoError(t, err)
	secondSession, _, err := sessionService.CreateSession(ctx, user.ID, time.Now().Add(time.Hour), auth.SessionMeta{})
	require.NoError(t, err)

	_, rows, err := generateRecoveryCodeRowsInternal(user.ID)
	require.NoError(t, err)
	require.NoError(t, db.Create(&rows).Error)
	transaction := newAuthTransactionInternal(user.ID, authTransactionKindMFA, session.UserSessionSourceLocal, auth.SessionMeta{}, nil)
	require.NoError(t, db.Create(transaction).Error)
	ceremony := &PasskeyCeremony{
		ID:                "reset-ceremony",
		Purpose:           passkeyCeremonyPurposeMFA,
		UserID:            new(user.ID),
		AuthTransactionID: new(transaction.ID),
		RPID:              service.rpID,
		SessionData:       "{}",
		ExpiresAt:         time.Now().Add(time.Minute),
	}
	require.NoError(t, db.Create(ceremony).Error)

	require.NoError(t, service.ResetMFAForUser(ctx, user.ID))

	var resetUser userdomain.User
	require.NoError(t, db.Where("id = ?", user.ID).First(&resetUser).Error)
	require.False(t, resetUser.PasskeyMFAEnabled)
	var remaining int64
	require.NoError(t, db.Model(&PasskeyRecoveryCode{}).Where("user_id = ?", user.ID).Count(&remaining).Error)
	require.Zero(t, remaining)
	require.NoError(t, db.Model(&PasskeyCeremony{}).Where("user_id = ?", user.ID).Count(&remaining).Error)
	require.Zero(t, remaining)
	require.NoError(t, db.Model(&AuthTransaction{}).Where("user_id = ?", user.ID).Count(&remaining).Error)
	require.Zero(t, remaining)

	var preserved Passkey
	require.NoError(t, db.Where("id = ?", passkey.ID).First(&preserved).Error)
	require.Equal(t, passkey.ID, preserved.ID)

	first, err := sessionService.GetSessionByID(ctx, firstSession.ID)
	require.NoError(t, err)
	require.NotNil(t, first.RevokedAt)
	second, err := sessionService.GetSessionByID(ctx, secondSession.ID)
	require.NoError(t, err)
	require.NotNil(t, second.RevokedAt)
}