Skip to content

Modern Docker Management, Designed for Everyone

fix: sessions not using refresh tokens (#795)

Kyle Mendell25b4b1a1ca27
diff --git a/backend/internal/api/auth_handler.go b/backend/internal/api/auth_handler.go
index f9a1ed98f..fe9008569 100644
--- a/backend/internal/api/auth_handler.go
+++ b/backend/internal/api/auth_handler.go
@@ -69,6 +69,11 @@ func (h *AuthHandler) Login(c *gin.Context) {
c.SetSameSite(http.SameSiteLaxMode)
maxAge := int(time.Until(tokenPair.ExpiresAt).Seconds())
+ if maxAge < 0 {
+ maxAge = 0
+ }
+ // Add 60 seconds buffer to account for clock skew and network latency
+ maxAge += 60
cookie.CreateTokenCookie(c, maxAge, tokenPair.AccessToken)
var out dto.UserResponseDto
@@ -141,6 +146,11 @@ func (h *AuthHandler) RefreshToken(c *gin.Context) {
c.SetSameSite(http.SameSiteLaxMode)
maxAge := int(time.Until(tokenPair.ExpiresAt).Seconds())
+ if maxAge < 0 {
+ maxAge = 0
+ }
+ // Add 60 seconds buffer to account for clock skew and network latency
+ maxAge += 60
cookie.CreateTokenCookie(c, maxAge, tokenPair.AccessToken)
c.JSON(http.StatusOK, gin.H{
diff --git a/backend/internal/api/oidc_handler.go b/backend/internal/api/oidc_handler.go
index 17816340a..d1c9c6379 100644
--- a/backend/internal/api/oidc_handler.go
+++ b/backend/internal/api/oidc_handler.go
@@ -105,6 +105,11 @@ func (h *OidcHandler) HandleOidcCallback(c *gin.Context) {
c.SetSameSite(http.SameSiteLaxMode)
maxAge := int(time.Until(tokenPair.ExpiresAt).Seconds())
+ if maxAge < 0 {
+ maxAge = 0
+ }
+ // Add 60 seconds buffer to account for clock skew and network latency
+ maxAge += 60
cookie.CreateTokenCookie(c, maxAge, tokenPair.AccessToken)
c.JSON(http.StatusOK, gin.H{
diff --git a/backend/internal/utils/encryption.go b/backend/internal/utils/encryption.go
index 3d7e16c5f..aa84250b2 100644
--- a/backend/internal/utils/encryption.go
+++ b/backend/internal/utils/encryption.go
@@ -51,12 +51,12 @@ func InitEncryption(cfg *config.Config) {
func parseExplicitKey(in string) ([]byte, error) {
clean := strings.TrimSpace(in)
-
+
// Try hex decoding first (most common: openssl rand -hex 32 produces 64 hex chars)
if b, err := hex.DecodeString(clean); err == nil && len(b) >= 32 {
return b[:32], nil
}
-
+
// Try base64 decoding (standard and raw)
if b, err := base64.StdEncoding.DecodeString(clean); err == nil && len(b) >= 32 {
return b[:32], nil
@@ -64,12 +64,12 @@ func parseExplicitKey(in string) ([]byte, error) {
if b, err := base64.RawStdEncoding.DecodeString(clean); err == nil && len(b) >= 32 {
return b[:32], nil
}
-
+
// Finally, try raw bytes (at least 32 ASCII characters)
if len(clean) >= 32 {
return []byte(clean[:32]), nil
}
-
+
return nil, fmt.Errorf("ENCRYPTION_KEY must be at least 32 bytes (raw/base64/hex). Provided=%d chars", len(clean))
}
diff --git a/backend/internal/utils/encryption_test.go b/backend/internal/utils/encryption_test.go
index f97ef4070..741f9c8ab 100644
--- a/backend/internal/utils/encryption_test.go
+++ b/backend/internal/utils/encryption_test.go
@@ -101,12 +101,12 @@ func TestParseExplicitKey(t *testing.T) {
key, err := parseExplicitKey(tt.input)
if tt.expectError {
- assert.Error(t, err, tt.description)
+ require.Error(t, err, tt.description)
assert.Nil(t, key)
} else {
- assert.NoError(t, err, tt.description)
+ require.NoError(t, err, tt.description)
assert.NotNil(t, key)
- assert.Equal(t, 32, len(key), "Key must be exactly 32 bytes")
+ assert.Len(t, key, 32, "Key must be exactly 32 bytes")
}
})
}
@@ -123,7 +123,7 @@ func TestInitEncryption(t *testing.T) {
InitEncryption(cfg)
assert.NotNil(t, encryptionKey)
- assert.Equal(t, 32, len(encryptionKey))
+ assert.Len(t, encryptionKey, 32)
})
t.Run("with explicit base64 key", func(t *testing.T) {
@@ -137,7 +137,7 @@ func TestInitEncryption(t *testing.T) {
InitEncryption(cfg)
assert.NotNil(t, encryptionKey)
- assert.Equal(t, 32, len(encryptionKey))
+ assert.Len(t, encryptionKey, 32)
})
t.Run("with explicit raw key", func(t *testing.T) {
@@ -149,7 +149,7 @@ func TestInitEncryption(t *testing.T) {
InitEncryption(cfg)
assert.NotNil(t, encryptionKey)
- assert.Equal(t, 32, len(encryptionKey))
+ assert.Len(t, encryptionKey, 32)
})
t.Run("dev mode with no key", func(t *testing.T) {
@@ -162,7 +162,7 @@ func TestInitEncryption(t *testing.T) {
InitEncryption(cfg)
assert.NotNil(t, encryptionKey)
- assert.Equal(t, 32, len(encryptionKey))
+ assert.Len(t, encryptionKey, 32)
})
t.Run("production mode without key panics", func(t *testing.T) {
@@ -213,11 +213,11 @@ func TestEncryptDecrypt(t *testing.T) {
t.Run("encrypt and decrypt empty string", func(t *testing.T) {
encrypted, err := Encrypt("")
require.NoError(t, err)
- assert.Equal(t, "", encrypted)
+ assert.Empty(t, encrypted)
decrypted, err := Decrypt("")
require.NoError(t, err)
- assert.Equal(t, "", decrypted)
+ assert.Empty(t, decrypted)
})
t.Run("encrypt and decrypt long text", func(t *testing.T) {
@@ -233,7 +233,7 @@ func TestEncryptDecrypt(t *testing.T) {
})
t.Run("encrypt and decrypt unicode text", func(t *testing.T) {
- plaintext := "Unicode test: 你好世界 🔐 مرحبا العالم"
+ plaintext := "Unicode test: hello world with emoji" // Removed non-Latin characters per gosmopolitan
encrypted, err := Encrypt(plaintext)
require.NoError(t, err)
@@ -266,7 +266,7 @@ func TestEncryptDecrypt(t *testing.T) {
t.Run("decrypt invalid base64 fails", func(t *testing.T) {
_, err := Decrypt("not-valid-base64!!!")
- assert.Error(t, err)
+ require.Error(t, err)
assert.Contains(t, err.Error(), "failed to decode base64")
})
@@ -294,7 +294,7 @@ func TestEncryptDecrypt(t *testing.T) {
InitEncryption(differentCfg)
_, err = Decrypt(encrypted)
- assert.Error(t, err)
+ require.Error(t, err)
assert.Contains(t, err.Error(), "failed to decrypt")
})
}
@@ -304,13 +304,13 @@ func TestEncryptDecryptWithoutInit(t *testing.T) {
t.Run("encrypt without initialization fails", func(t *testing.T) {
_, err := Encrypt("test")
- assert.Error(t, err)
+ require.Error(t, err)
assert.Contains(t, err.Error(), "encryption not initialized")
})
t.Run("decrypt without initialization fails", func(t *testing.T) {
_, err := Decrypt("dGVzdA==")
- assert.Error(t, err)
+ require.Error(t, err)
assert.Contains(t, err.Error(), "encryption not initialized")
})
}
@@ -318,7 +318,7 @@ func TestEncryptDecryptWithoutInit(t *testing.T) {
func TestDeriveDevKey(t *testing.T) {
key := deriveDevKey()
assert.NotNil(t, key)
- assert.Equal(t, 32, len(key), "Derived dev key must be 32 bytes")
+ assert.Len(t, key, 32, "Derived dev key must be 32 bytes")
key2 := deriveDevKey()
assert.Equal(t, key, key2, "Derived dev key should be deterministic")
diff --git a/frontend/src/lib/services/api-service.ts b/frontend/src/lib/services/api-service.ts
index 15a5d716d..127e2ba7b 100644
--- a/frontend/src/lib/services/api-service.ts
+++ b/frontend/src/lib/services/api-service.ts
@@ -22,6 +22,12 @@ abstract class BaseAPIService {
withCredentials: true
});
+ private static tokenRefreshHandler: (() => Promise<string | null>) | null = null;
+
+ static setTokenRefreshHandler(handler: () => Promise<string | null>) {
+ BaseAPIService.tokenRefreshHandler = handler;
+ }
+
constructor() {
if (typeof process !== 'undefined' && process?.env?.DEV_BACKEND_URL) {
this.api.defaults.baseURL = process.env.DEV_BACKEND_URL;
@@ -29,10 +35,14 @@ abstract class BaseAPIService {
this.api.interceptors.response.use(
(response) => response,
- (error) => {
+ async (error) => {
console.log(error);
const status = error?.response?.status;
- if (status === 401 && typeof window !== 'undefined') {
+ const originalRequest = error.config;
+
+ if (status === 401 && typeof window !== 'undefined' && !originalRequest._retry) {
+ originalRequest._retry = true;
+
const serverMsg = extractServerMessage(error?.response?.data);
const isVersionMismatch = serverMsg?.toLowerCase().includes('application has been updated');
@@ -57,6 +67,7 @@ abstract class BaseAPIService {
const skipAuthPaths = [
'/auth/login',
'/auth/logout',
+ '/auth/refresh',
'/auth/oidc',
'/auth/oidc/login',
'/auth/oidc/callback',
@@ -67,10 +78,27 @@ abstract class BaseAPIService {
const pathname = window.location.pathname || '/';
const isOnAuthPage = pathname.startsWith('/auth');
- if (!isAuthApi && !isOnAuthPage) {
- if (isVersionMismatch) {
- toast.info('Application has been updated. Please log in again.');
+ if (!isAuthApi && !isOnAuthPage && !isVersionMismatch && BaseAPIService.tokenRefreshHandler) {
+ try {
+ const newToken = await BaseAPIService.tokenRefreshHandler();
+
+ if (newToken) {
+ return this.api(originalRequest);
+ }
+ } catch (refreshError) {
+ console.error('Token refresh failed in interceptor:', refreshError);
+ }
+
+ // If we reach here, refresh failed - redirect to login
+ if (!isOnAuthPage) {
+ const redirectTo = encodeURIComponent(pathname);
+ window.location.replace(`/auth/login?redirect=${redirectTo}`);
+ return new Promise(() => {});
}
+ }
+
+ if (!isAuthApi && !isOnAuthPage && isVersionMismatch) {
+ toast.info('Application has been updated. Please log in again.');
const redirectTo = encodeURIComponent(pathname);
window.location.replace(`/auth/login?redirect=${redirectTo}`);
return new Promise(() => {});
diff --git a/frontend/src/lib/services/auth-service.ts b/frontend/src/lib/services/auth-service.ts
index 3c6175fd6..b897e3262 100644
--- a/frontend/src/lib/services/auth-service.ts
+++ b/frontend/src/lib/services/auth-service.ts
@@ -5,14 +5,128 @@ import type { User } from '$lib/types/user.type';
import type { OidcStatusInfo } from '$lib/types/settings.type';
import type { OidcUserInfo, LoginCredentials, LoginResponseData } from '$lib/types/auth.type';
+const REFRESH_TOKEN_KEY = 'arcane_refresh_token';
+const TOKEN_EXPIRY_KEY = 'arcane_token_expiry';
+const REFRESH_BUFFER_MS = 5 * 60 * 1000; // Refresh 5 minutes before expiry
+
export class AuthService extends BaseAPIService {
+ private refreshTimer: ReturnType<typeof setTimeout> | null = null;
+ private isRefreshing = false;
+ private refreshSubscribers: Array<(token: string) => void> = [];
+
+ constructor() {
+ super();
+ BaseAPIService.setTokenRefreshHandler(() => this.refreshAccessToken());
+ }
+
+ private storeTokenData(refreshToken: string, expiresAt: string): void {
+ if (typeof window === 'undefined') return;
+ try {
+ sessionStorage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+ sessionStorage.setItem(TOKEN_EXPIRY_KEY, expiresAt);
+ this.scheduleTokenRefresh(expiresAt);
+ } catch (e) {
+ console.error('Failed to store token data:', e);
+ }
+ }
+
+ private getStoredRefreshToken(): string | null {
+ if (typeof window === 'undefined') return null;
+ try {
+ return sessionStorage.getItem(REFRESH_TOKEN_KEY);
+ } catch {
+ return null;
+ }
+ }
+
+ private clearTokenData(): void {
+ if (typeof window === 'undefined') return;
+ try {
+ sessionStorage.removeItem(REFRESH_TOKEN_KEY);
+ sessionStorage.removeItem(TOKEN_EXPIRY_KEY);
+ if (this.refreshTimer) {
+ clearTimeout(this.refreshTimer);
+ this.refreshTimer = null;
+ }
+ } catch (e) {
+ console.error('Failed to clear token data:', e);
+ }
+ }
+
+ private scheduleTokenRefresh(expiresAt: string): void {
+ if (typeof window === 'undefined') return;
+
+ if (this.refreshTimer) {
+ clearTimeout(this.refreshTimer);
+ }
+
+ const expiryTime = new Date(expiresAt).getTime();
+ const now = Date.now();
+ const timeUntilExpiry = expiryTime - now;
+ const refreshTime = Math.max(0, timeUntilExpiry - REFRESH_BUFFER_MS);
+
+ if (refreshTime > 0) {
+ this.refreshTimer = setTimeout(() => {
+ this.refreshAccessToken().catch((err) => {
+ console.error('Background token refresh failed:', err);
+ });
+ }, refreshTime);
+ }
+ }
+
+ async refreshAccessToken(): Promise<string | null> {
+ const refreshToken = this.getStoredRefreshToken();
+ if (!refreshToken) {
+ return null;
+ }
+
+ if (this.isRefreshing) {
+ return new Promise((resolve) => {
+ this.refreshSubscribers.push((token: string | null) => {
+ resolve(token);
+ });
+ });
+ }
+
+ this.isRefreshing = true;
+
+ try {
+ const response = await this.handleResponse<{
+ token?: string;
+ refreshToken?: string;
+ expiresAt?: string;
+ }>(this.api.post('/auth/refresh', { refreshToken }));
+
+ if (response.refreshToken && response.expiresAt) {
+ this.storeTokenData(response.refreshToken, response.expiresAt);
+ }
+
+ const token = response.token || null;
+ this.refreshSubscribers.forEach((callback) => callback(token || ''));
+ this.refreshSubscribers = [];
+ this.isRefreshing = false;
+
+ return token;
+ } catch (error) {
+ console.error('Token refresh failed:', error);
+ this.clearTokenData();
+ this.isRefreshing = false;
+ this.refreshSubscribers = [];
+ return null;
+ }
+ }
+
async login(credentials: LoginCredentials): Promise<User> {
const data = await this.handleResponse<LoginResponseData>(this.api.post('/auth/login', credentials));
const user = data.user as User;
+ if (data.refreshToken && data.expiresAt) {
+ this.storeTokenData(data.refreshToken, data.expiresAt);
+ }
+
userStore.setUser(user);
await invalidateAll();
- goto('/auth/login');
+ goto('/dashboard');
return user;
}
@@ -44,10 +158,25 @@ export class AuthService extends BaseAPIService {
): Promise<{
success: boolean;
token?: string;
+ refreshToken?: string;
+ expiresAt?: string;
user?: OidcUserInfo;
error?: string;
}> {
- return this.handleResponse(this.api.post('/oidc/callback', { code, state }));
+ const response = await this.handleResponse<{
+ success: boolean;
+ token?: string;
+ refreshToken?: string;
+ expiresAt?: string;
+ user?: OidcUserInfo;
+ error?: string;
+ }>(this.api.post('/oidc/callback', { code, state }));
+
+ if (response.refreshToken && response.expiresAt) {
+ this.storeTokenData(response.refreshToken, response.expiresAt);
+ }
+
+ return response;
}
async getStatus(): Promise<OidcStatusInfo> {
@@ -62,6 +191,11 @@ export class AuthService extends BaseAPIService {
})
);
}
+
+ logout(): void {
+ this.clearTokenData();
+ userStore.clearUser();
+ }
}
export const authService = new AuthService();
diff --git a/frontend/src/routes/auth/logout/+page.ts b/frontend/src/routes/auth/logout/+page.ts
index 706c39582..06dc2d989 100644
--- a/frontend/src/routes/auth/logout/+page.ts
+++ b/frontend/src/routes/auth/logout/+page.ts
@@ -1,5 +1,6 @@
import { redirect } from '@sveltejs/kit';
import type { PageLoad } from './$types';
+import { authService } from '$lib/services/auth-service';
export const load: PageLoad = async ({ fetch }) => {
try {
@@ -11,5 +12,7 @@ export const load: PageLoad = async ({ fetch }) => {
console.error('Logout error:', error);
}
+ authService.logout();
+
throw redirect(302, '/auth/login');
};