Skip to content

Modern Docker Management, Designed for Everyone

fix: move ios app passkey logic to backend

Kyle Mendell3b0fc6aabea5
diff --git a/backend/api/handlers/passkey.go b/backend/api/handlers/passkey.go
index 7368f29bc..d9dafb1ab 100644
--- a/backend/api/handlers/passkey.go
+++ b/backend/api/handlers/passkey.go
@@ -38,6 +38,17 @@ type mfaFinishBody struct {
Credential map[string]any `json:"credential"`
}
+type mobilePasskeyFinishBody struct {
+ CeremonyID string `json:"ceremonyId"`
+ Credential map[string]any `json:"credential"`
+ CodeChallenge string `json:"codeChallenge" minLength:"43" maxLength:"43"`
+}
+
+type mobilePasskeyExchangeBody struct {
+ TransactionID string `json:"transactionId"`
+ CodeVerifier string `json:"codeVerifier" minLength:"43" maxLength:"43"`
+}
+
type stepUpFinishBody struct {
TransactionID string `json:"transactionId"`
Credential map[string]any `json:"credential"`
@@ -70,6 +81,24 @@ type PasskeyLoginFinishOutput struct {
Body base.ApiResponse[auth.AuthenticationResponse]
}
+type MobilePasskeyFinishInput struct {
+ Body mobilePasskeyFinishBody
+}
+
+type MobilePasskeyFinishOutput struct {
+ Body base.ApiResponse[auth.MobilePasskeyCompletion]
+}
+
+type MobilePasskeyExchangeInput struct {
+ UserAgent string `header:"User-Agent"`
+ Body mobilePasskeyExchangeBody
+}
+
+type MobilePasskeyExchangeOutput struct {
+ SetCookie []string `header:"Set-Cookie" doc:"Session cookie"`
+ Body base.ApiResponse[auth.AuthenticationResponse]
+}
+
type PasskeyMFAStartInput struct {
Body mfaBeginBody
}
@@ -208,6 +237,24 @@ func RegisterPasskeys(api huma.API, passkeyService *services.PasskeyService, aut
Tags: []string{"Auth", "Passkeys"},
Security: public,
}, h.FinishPasskeyLogin)
+ huma.Register(api, huma.Operation{
+ OperationID: "finish-mobile-passkey-login",
+ Method: http.MethodPost,
+ Path: "/auth/passkey/mobile/finish",
+ Summary: "Finish mobile passkey login",
+ Description: "Validate a browser assertion and create a one-time mobile exchange",
+ Tags: []string{"Auth", "Passkeys"},
+ Security: public,
+ }, h.FinishMobilePasskeyLogin)
+ huma.Register(api, huma.Operation{
+ OperationID: "exchange-mobile-passkey-login",
+ Method: http.MethodPost,
+ Path: "/auth/passkey/mobile/exchange",
+ Summary: "Exchange mobile passkey login",
+ Description: "Consume a verifier-bound mobile passkey transaction and create a session",
+ Tags: []string{"Auth", "Passkeys"},
+ Security: public,
+ }, h.ExchangeMobilePasskeyLogin)
huma.Register(api, huma.Operation{
OperationID: "begin-passkey-mfa",
@@ -376,6 +423,38 @@ func (h *PasskeyHandler) FinishPasskeyLogin(ctx context.Context, input *PasskeyL
}, nil
}
+func (h *PasskeyHandler) FinishMobilePasskeyLogin(ctx context.Context, input *MobilePasskeyFinishInput) (*MobilePasskeyFinishOutput, error) {
+ payload, err := marshalCredentialInternal(input.Body.Credential)
+ if err != nil {
+ return nil, huma.Error400BadRequest("invalid passkey response")
+ }
+ completion, err := h.passkeyService.FinishMobilePasskeyLogin(ctx, input.Body.CeremonyID, payload, input.Body.CodeChallenge)
+ if err != nil {
+ return nil, passkeyHTTPErrorInternal(err)
+ }
+ return &MobilePasskeyFinishOutput{Body: base.ApiResponse[auth.MobilePasskeyCompletion]{Success: true, Data: *completion}}, nil
+}
+
+func (h *PasskeyHandler) ExchangeMobilePasskeyLogin(ctx context.Context, input *MobilePasskeyExchangeInput) (*MobilePasskeyExchangeOutput, error) {
+ userModel, err := h.passkeyService.ExchangeMobilePasskeyLogin(ctx, input.Body.TransactionID, input.Body.CodeVerifier)
+ if err != nil {
+ return nil, passkeyHTTPErrorInternal(err)
+ }
+ meta := auth.SessionMeta{UserAgent: input.UserAgent, IPAddress: humamw.GetRemoteAddrFromContext(ctx)}
+ tokenPair, err := h.authService.CompleteLogin(ctx, userModel, meta, models.UserSessionSourcePasskey, "")
+ if err != nil {
+ return nil, huma.Error500InternalServerError("authentication failed")
+ }
+ response, err := h.authenticationResponseInternal(ctx, userModel, tokenPair)
+ if err != nil {
+ return nil, err
+ }
+ return &MobilePasskeyExchangeOutput{
+ SetCookie: tokenCookieInternal(ctx, tokenPair),
+ Body: base.ApiResponse[auth.AuthenticationResponse]{Success: true, Data: *response},
+ }, nil
+}
+
func (h *PasskeyHandler) BeginMFA(ctx context.Context, input *PasskeyMFAStartInput) (*PasskeyMFAStartOutput, error) {
challenge, err := h.passkeyService.BeginMFAForTransaction(ctx, input.Body.TransactionID)
if err != nil {
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index 0440ab30a..084b2d2eb 100644
--- a/backend/internal/bootstrap/router_bootstrap.go
+++ b/backend/internal/bootstrap/router_bootstrap.go
@@ -206,6 +206,8 @@ func newRouter(p RouterParams) (*echo.Echo, *edge.TunnelServer) {
"/api/auth/refresh",
"/api/auth/passkey/login/begin",
"/api/auth/passkey/login/finish",
+ "/api/auth/passkey/mobile/finish",
+ "/api/auth/passkey/mobile/exchange",
"/api/auth/mfa/passkey/begin",
"/api/auth/mfa/passkey/finish",
"/api/auth/mfa/recovery",
diff --git a/backend/internal/services/passkey_service.go b/backend/internal/services/passkey_service.go
index 4c0f36fde..888a13666 100644
--- a/backend/internal/services/passkey_service.go
+++ b/backend/internal/services/passkey_service.go
@@ -9,6 +9,7 @@ import (
"encoding/base64"
"encoding/hex"
"encoding/json"
+ "log/slog"
"net/url"
"strings"
"sync"
@@ -37,10 +38,11 @@ const (
passkeyCeremonyPurposeRegistration = "registration"
passkeyCeremonyPurposeStepUp = "step_up"
- authTransactionKindMFA = "mfa"
- authTransactionKindStepUp = "step_up"
- authTransactionPending = "pending"
- authTransactionCompleted = "completed"
+ authTransactionKindMFA = "mfa"
+ authTransactionKindStepUp = "step_up"
+ authTransactionKindMobilePasskey = "mobile_passkey"
+ authTransactionPending = "pending"
+ authTransactionCompleted = "completed"
passkeyCeremonyTTL = 5 * time.Minute
passkeyStepUpTTL = 5 * time.Minute
@@ -536,19 +538,25 @@ func (s *passkeyService) FinishPasskeyLogin(ctx context.Context, ceremonyID stri
}
parsed, err := protocol.ParseCredentialRequestResponseBytes(payload)
if err != nil {
+ slog.WarnContext(ctx, "passkey login validation failed", "stage", "parse", "error", err)
return nil, ErrPasskeyResponse
}
- var resolved *webAuthnUser
- user, credential, err := s.webAuthn.ValidatePasskeyLogin(func(rawID, userHandle []byte) (webauthn.User, error) {
- adapter, lookupErr := s.lookupDiscoverableUserInternal(ctx, rawID, userHandle)
- if lookupErr != nil {
- return nil, lookupErr
- }
- resolved = adapter
- return adapter, nil
- }, session, parsed)
- if err != nil || user == nil || credential == nil || resolved == nil {
+ resolved, err := s.lookupDiscoverableUserInternal(ctx, parsed.RawID)
+ if err != nil {
+ slog.WarnContext(ctx, "passkey login validation failed", "stage", "credential_lookup", "error", err)
+ return nil, ErrPasskeyResponse
+ }
+
+ // The credential ID is globally unique for this RP and its signature proves
+ // ownership. Resolve the user from that ID instead of relying on the optional
+ // userHandle returned by a password manager. Some providers omit or transform
+ // that handle even for a discoverable credential.
+ session.UserID = resolved.WebAuthnID()
+ parsed.Response.UserHandle = nil
+ credential, err := s.webAuthn.ValidateLogin(resolved, session, parsed)
+ if err != nil || credential == nil {
+ slog.WarnContext(ctx, "passkey login validation failed", "stage", "assertion", "error", err)
return nil, ErrPasskeyResponse
}
@@ -558,6 +566,60 @@ func (s *passkeyService) FinishPasskeyLogin(ctx context.Context, ceremonyID stri
return &resolved.model, nil
}
+func (s *passkeyService) FinishMobilePasskeyLogin(ctx context.Context, ceremonyID string, payload []byte, codeChallenge string) (*auth.MobilePasskeyCompletion, error) {
+ codeChallenge, err := normalizeMobilePasskeyCodeChallengeInternal(codeChallenge)
+ if err != nil {
+ return nil, err
+ }
+ user, err := s.FinishPasskeyLogin(ctx, ceremonyID, payload)
+ if err != nil {
+ return nil, err
+ }
+
+ transaction := newAuthTransactionInternal(user.ID, authTransactionKindMobilePasskey, models.UserSessionSourcePasskey, auth.SessionMeta{}, nil, passkeyStepUpTTL)
+ transaction.SecretHash = &codeChallenge
+ if err := s.db.WithContext(ctx).Create(transaction).Error; err != nil {
+ return nil, errors.WrapIf(err, "failed to create mobile passkey transaction")
+ }
+ return &auth.MobilePasskeyCompletion{TransactionID: transaction.ID, ExpiresAt: transaction.ExpiresAt}, nil
+}
+
+func (s *passkeyService) ExchangeMobilePasskeyLogin(ctx context.Context, transactionID, codeVerifier string) (*models.User, error) {
+ if err := s.readyInternal(); err != nil {
+ return nil, err
+ }
+ codeChallenge, err := mobilePasskeyCodeChallengeInternal(codeVerifier)
+ if err != nil {
+ return nil, err
+ }
+
+ var transaction models.AuthTransaction
+ err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Where("id = ? AND kind = ? AND status = ? AND secret_hash = ? AND expires_at > ?", transactionID, authTransactionKindMobilePasskey, authTransactionPending, codeChallenge, time.Now()).First(&transaction).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return ErrPasskeyTransaction
+ }
+ return errors.WrapIf(err, "failed to load mobile passkey transaction")
+ }
+
+ now := time.Now()
+ result := tx.Model(&models.AuthTransaction{}).
+ Where("id = ? AND status = ? AND expires_at > ?", transaction.ID, authTransactionPending, now).
+ Updates(map[string]any{"status": authTransactionCompleted, "completed_at": now, "updated_at": now})
+ if result.Error != nil {
+ return errors.WrapIf(result.Error, "failed to complete mobile passkey transaction")
+ }
+ if result.RowsAffected != 1 {
+ return ErrPasskeyTransaction
+ }
+ return nil
+ })
+ if err != nil {
+ return nil, err
+ }
+ return s.loadUserModelInternal(ctx, transaction.UserID)
+}
+
func (s *passkeyService) FinishMFA(ctx context.Context, transactionID string, payload []byte) (*AuthenticationCompletion, error) {
transaction, err := s.loadPendingTransactionInternal(ctx, transactionID, authTransactionKindMFA)
if err != nil {
@@ -1181,17 +1243,14 @@ func (s *passkeyService) countPasskeysInternal(ctx context.Context, userID strin
return int(count), nil
}
-func (s *passkeyService) lookupDiscoverableUserInternal(ctx context.Context, rawID, userHandle []byte) (*webAuthnUser, error) {
- if len(rawID) == 0 || len(userHandle) == 0 {
+func (s *passkeyService) lookupDiscoverableUserInternal(ctx context.Context, rawID []byte) (*webAuthnUser, error) {
+ if len(rawID) == 0 {
return nil, ErrPasskeyResponse
}
var row models.Passkey
if err := s.db.WithContext(ctx).Where("rp_id = ? AND credential_id = ?", s.rpID, rawID).First(&row).Error; err != nil {
return nil, ErrPasskeyResponse
}
- if subtle.ConstantTimeCompare([]byte(row.UserID), userHandle) != 1 {
- return nil, ErrPasskeyResponse
- }
return s.loadWebAuthnUserInternal(ctx, row.UserID)
}
@@ -1393,6 +1452,25 @@ func hashSecretInternal(secret string) string {
return hex.EncodeToString(sum[:])
}
+func normalizeMobilePasskeyCodeChallengeInternal(codeChallenge string) (string, error) {
+ codeChallenge = strings.TrimSpace(codeChallenge)
+ decoded, err := base64.RawURLEncoding.DecodeString(codeChallenge)
+ if err != nil || len(decoded) != sha256.Size || base64.RawURLEncoding.EncodeToString(decoded) != codeChallenge {
+ return "", ErrPasskeyResponse
+ }
+ return codeChallenge, nil
+}
+
+func mobilePasskeyCodeChallengeInternal(codeVerifier string) (string, error) {
+ codeVerifier = strings.TrimSpace(codeVerifier)
+ decoded, err := base64.RawURLEncoding.DecodeString(codeVerifier)
+ if err != nil || len(decoded) != 32 || base64.RawURLEncoding.EncodeToString(decoded) != codeVerifier {
+ return "", ErrPasskeyTransaction
+ }
+ sum := sha256.Sum256([]byte(codeVerifier))
+ return base64.RawURLEncoding.EncodeToString(sum[:]), nil
+}
+
func randomSecretInternal() (string, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
diff --git a/frontend/src/lib/services/passkey-service.ts b/frontend/src/lib/services/passkey-service.ts
index bca42224f..63939cf89 100644
--- a/frontend/src/lib/services/passkey-service.ts
+++ b/frontend/src/lib/services/passkey-service.ts
@@ -4,6 +4,7 @@ import type {
AuthenticationResponse,
MFAChallenge,
MFAStatus,
+ MobilePasskeyCompletion,
Passkey,
PasskeyCapabilities,
PasskeyChallenge,
@@ -25,6 +26,20 @@ class PasskeyService extends BaseAPIService {
);
}
+ async finishMobileLogin(
+ ceremonyId: string,
+ credential: AuthenticationResponseJSON,
+ codeChallenge: string
+ ): Promise<MobilePasskeyCompletion> {
+ return this.handleResponse(
+ this.api.post('/auth/passkey/mobile/finish', {
+ ceremonyId,
+ credential,
+ codeChallenge
+ })
+ );
+ }
+
async beginMFA(transactionId: string): Promise<MFAChallenge> {
return this.handleResponse(this.api.post('/auth/mfa/passkey/begin', { transactionId }));
}
diff --git a/frontend/src/lib/types/auth.ts b/frontend/src/lib/types/auth.ts
index fb4b0bb1e..ae06d8b09 100644
--- a/frontend/src/lib/types/auth.ts
+++ b/frontend/src/lib/types/auth.ts
@@ -206,6 +206,11 @@ export type PasskeyChallenge = {
expiresAt: string;
};
+export type MobilePasskeyCompletion = {
+ transactionId: string;
+ expiresAt: string;
+};
+
export type MFAChallenge = {
transactionId: string;
method: string;
diff --git a/frontend/src/routes/(auth)/mobile/passkey/+page.svelte b/frontend/src/routes/(auth)/mobile/passkey/+page.svelte
index 3f39e01d5..0cba5101e 100644
--- a/frontend/src/routes/(auth)/mobile/passkey/+page.svelte
+++ b/frontend/src/routes/(auth)/mobile/passkey/+page.svelte
@@ -13,12 +13,14 @@
import { Spinner } from '#lib/components/ui/spinner/index.js';
import { AlertIcon, ApiKeyIcon, ShieldCheckIcon, SuccessIcon } from '#lib/icons';
import { m } from '#lib/paraglide/messages';
+ import { passkeyService } from '#lib/services/passkey-service';
import { getApplicationLogo } from '#lib/utils/docker';
import {
MobilePasskeyBridgeRequestError,
classifyMobilePasskeyError,
decodeMobilePasskeyBridgeRequest,
makeMobilePasskeyErrorCallback,
+ makeMobilePasskeyLoginCallback,
makeMobilePasskeySuccessCallback,
type MobilePasskeyBridgeRequest,
type MobilePasskeyCredential
@@ -77,6 +79,15 @@
credential = await startAuthentication({
optionsJSON: request.options as unknown as PublicKeyCredentialRequestOptionsJSON
});
+ if (request.mobileLogin) {
+ const completion = await passkeyService.finishMobileLogin(
+ request.mobileLogin.ceremonyId,
+ credential,
+ request.mobileLogin.codeChallenge
+ );
+ returnToArcaneMobile(makeMobilePasskeyLoginCallback(request.state, completion.transactionId));
+ return;
+ }
} else {
credential = await startRegistration({
optionsJSON: request.options as unknown as PublicKeyCredentialCreationOptionsJSON
diff --git a/frontend/src/routes/(auth)/mobile/passkey/passkey-bridge.ts b/frontend/src/routes/(auth)/mobile/passkey/passkey-bridge.ts
index 59e15e906..3b3acb73d 100644
--- a/frontend/src/routes/(auth)/mobile/passkey/passkey-bridge.ts
+++ b/frontend/src/routes/(auth)/mobile/passkey/passkey-bridge.ts
@@ -1,6 +1,6 @@
import type { AuthenticationResponseJSON, RegistrationResponseJSON } from '@simplewebauthn/browser';
-export const MOBILE_PASSKEY_BRIDGE_VERSION = 1;
+export const MOBILE_PASSKEY_BRIDGE_VERSION = 2;
export const MOBILE_PASSKEY_MAX_REQUEST_BYTES = 65_536;
export const MOBILE_PASSKEY_MAX_RESPONSE_BYTES = 65_536;
@@ -14,10 +14,14 @@ export type MobilePasskeyErrorCode = 'invalid_request' | 'oversized' | 'unsuppor
export type MobilePasskeyCredential = AuthenticationResponseJSON | RegistrationResponseJSON;
export interface MobilePasskeyBridgeRequest {
- version: 1;
+ version: 2;
state: string;
operation: MobilePasskeyOperation;
options: Record<string, unknown>;
+ mobileLogin?: {
+ ceremonyId: string;
+ codeChallenge: string;
+ };
}
export class MobilePasskeyBridgeRequestError extends Error {
@@ -96,16 +100,34 @@ export function decodeMobilePasskeyBridgeRequest(fragment: string): MobilePasske
const state = isValidState(candidate['state']) ? candidate['state'] : undefined;
const keys = Object.keys(candidate).sort();
+ const mobileLogin = candidate['mobileLogin'];
const hasExactShape =
- keys.length === 4 && keys[0] === 'operation' && keys[1] === 'options' && keys[2] === 'state' && keys[3] === 'version';
+ (keys.length === 4 && keys[0] === 'operation' && keys[1] === 'options' && keys[2] === 'state' && keys[3] === 'version') ||
+ (keys.length === 5 &&
+ keys[0] === 'mobileLogin' &&
+ keys[1] === 'operation' &&
+ keys[2] === 'options' &&
+ keys[3] === 'state' &&
+ keys[4] === 'version');
const operation = candidate['operation'];
+ const hasValidMobileLogin =
+ mobileLogin === undefined ||
+ (isRecord(mobileLogin) &&
+ Object.keys(mobileLogin).length === 2 &&
+ typeof mobileLogin['ceremonyId'] === 'string' &&
+ mobileLogin['ceremonyId'].length > 0 &&
+ mobileLogin['ceremonyId'].length <= 128 &&
+ typeof mobileLogin['codeChallenge'] === 'string' &&
+ /^[A-Za-z0-9_-]{43}$/.test(mobileLogin['codeChallenge']));
if (
!hasExactShape ||
candidate['version'] !== MOBILE_PASSKEY_BRIDGE_VERSION ||
!state ||
(operation !== 'authenticate' && operation !== 'register') ||
- !isRecord(candidate['options'])
+ !isRecord(candidate['options']) ||
+ !hasValidMobileLogin ||
+ (mobileLogin !== undefined && operation !== 'authenticate')
) {
throw new MobilePasskeyBridgeRequestError('invalid_request', state);
}
@@ -114,7 +136,15 @@ export function decodeMobilePasskeyBridgeRequest(fragment: string): MobilePasske
version: MOBILE_PASSKEY_BRIDGE_VERSION,
state,
operation,
- options: candidate['options']
+ options: candidate['options'],
+ ...(mobileLogin === undefined
+ ? {}
+ : {
+ mobileLogin: {
+ ceremonyId: mobileLogin['ceremonyId'] as string,
+ codeChallenge: mobileLogin['codeChallenge'] as string
+ }
+ })
};
}
@@ -130,6 +160,13 @@ export function makeMobilePasskeySuccessCallback(state: string, credential: Mobi
return callback.toString();
}
+export function makeMobilePasskeyLoginCallback(state: string, transactionId: string): string {
+ const callback = new URL(CALLBACK_URL);
+ callback.searchParams.set('state', state);
+ callback.searchParams.set('transaction', transactionId);
+ return callback.toString();
+}
+
export function makeMobilePasskeyErrorCallback(state: string, code: MobilePasskeyErrorCode): string {
const callback = new URL(CALLBACK_URL);
callback.searchParams.set('state', state);
diff --git a/frontend/static/arcane-mobile-passkey.json b/frontend/static/arcane-mobile-passkey.json
index c075528b1..e164b9fe5 100644
--- a/frontend/static/arcane-mobile-passkey.json
+++ b/frontend/static/arcane-mobile-passkey.json
@@ -1,5 +1,5 @@
{
- "version": 1,
+ "version": 2,
"path": "/mobile/passkey",
"requestFragmentParameter": "request",
"maximumRequestBytes": 65536
diff --git a/types/auth/auth.go b/types/auth/auth.go
index 7c6faa20d..2b20c9ddb 100644
--- a/types/auth/auth.go
+++ b/types/auth/auth.go
@@ -62,6 +62,13 @@ type AuthenticationResponse struct {
MFA *MFAChallenge `json:"mfa,omitempty" doc:"Pending MFA challenge"`
}
+// MobilePasskeyCompletion identifies a validated passkey login waiting for
+// its initiating mobile client to perform the one-time verifier exchange.
+type MobilePasskeyCompletion struct {
+ TransactionID string `json:"transactionId" doc:"Opaque mobile passkey transaction identifier"`
+ ExpiresAt time.Time `json:"expiresAt" doc:"Mobile passkey transaction expiration time"`
+}
+
// TokenRefreshResponse represents the successful token refresh response data.
type TokenRefreshResponse struct {
Token string `json:"token" doc:"New JWT access token"`