The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Fail closed when issuing required user sessions (#25079)
Félix Malfait7db0c4ad15c0
diff --git a/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.spec.ts b/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.spec.tsnew file mode 100644index 00000000000..6c36b391b18--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.spec.ts@@ -0,0 +1,88 @@+import { JwtTokenTypeEnum } from 'src/engine/core-modules/auth/types/jwt-token-type.enum';+import { AuthProviderEnum } from 'src/engine/core-modules/workspace/types/workspace.type';++import { UserSessionService } from './user-session.service';++describe('UserSessionService.issueSessionForTokenPair', () => {+ const userSessionRepository = {+ create: jest.fn((input) => input),+ save: jest.fn(),+ };+ const jwtWrapperService = {+ decode: jest.fn().mockReturnValue({+ type: JwtTokenTypeEnum.ACCESS,+ userId: 'user-id',+ workspaceId: 'workspace-id',+ userWorkspaceId: 'user-workspace-id',+ authProvider: AuthProviderEnum.Password,+ }),+ };+ const twentyConfigService = {+ get: jest.fn().mockReturnValue('30d'),+ };+ const userSessionCookieService = {+ attachSessionTokenToResponse: jest.fn(),+ clearSessionCookie: jest.fn(),+ extractSessionTokenFromRequest: jest.fn(),+ };+ const service = new UserSessionService(+ userSessionRepository as never,+ {} as never,+ {} as never,+ twentyConfigService as never,+ jwtWrapperService as never,+ {} as never,+ userSessionCookieService as never,+ );+ const tokenPair = {+ accessOrWorkspaceAgnosticToken: {+ token: 'access-token',+ expiresAt: new Date('2026-01-01T00:00:00.000Z'),+ },+ refreshToken: {+ token: 'refresh-token',+ expiresAt: new Date('2026-01-01T00:00:00.000Z'),+ },+ };++ beforeEach(() => {+ jest.clearAllMocks();+ });++ it('preserves the presented session when replacement creation fails', async () => {+ const creationError = new Error('session insert failed');++ userSessionCookieService.extractSessionTokenFromRequest.mockReturnValue(+ 'presented-session-token',+ );+ userSessionRepository.save.mockRejectedValue(creationError);++ const revokeSessionByToken = jest.spyOn(service, 'revokeSessionByToken');++ await expect(+ service.issueSessionForTokenPair({+ tokenPair,+ request: { headers: {}, ip: '127.0.0.1', res: {} } as never,+ origin: 'sign_in',+ }),+ ).rejects.toBe(creationError);++ expect(revokeSessionByToken).not.toHaveBeenCalled();+ expect(+ userSessionCookieService.attachSessionTokenToResponse,+ ).not.toHaveBeenCalled();+ expect(userSessionCookieService.clearSessionCookie).not.toHaveBeenCalled();+ });++ it('fails when the required response is unavailable', async () => {+ await expect(+ service.issueSessionForTokenPair({+ tokenPair,+ request: { headers: {} } as never,+ origin: 'sign_in',+ }),+ ).rejects.toThrow('Cannot issue a user session without an HTTP response');++ expect(userSessionRepository.save).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.ts b/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.tsindex 94c9a865775..7e21daaa795 100644--- a/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.ts+++ b/packages/twenty-server/src/engine/core-modules/user-session/services/user-session.service.ts@@ -66,8 +66,6 @@ export class UserSessionService {private readonly userSessionCookieService: UserSessionCookieService,) {}- // Best effort by design: while token pairs remain the primary credential, a- // session failure must never break an otherwise successful sign-in.async issueSessionForTokenPair({tokenPair,request,@@ -80,7 +78,7 @@ export class UserSessionService {const response = request.res;if (!isDefined(response)) {- return;+ throw new Error('Cannot issue a user session without an HTTP response');}// Cannot live in the CSRF middleware, which cannot know a request is about@@ -90,7 +88,10 @@ export class UserSessionService {`Refused to issue a session cookie to origin ${request.headers.origin}`,);- return;+ throw new AuthException(+ 'Request origin is not allowed to receive a session cookie',+ AuthExceptionCode.FORBIDDEN_EXCEPTION,+ );}try {@@ -101,53 +102,38 @@ export class UserSessionService {);if (!isDefined(sessionInput)) {- return;+ throw new AuthException(+ 'Cannot issue a session from an invalid token pair',+ AuthExceptionCode.UNAUTHENTICATED,+ );}const presentedSessionToken =this.userSessionCookieService.extractSessionTokenFromRequest(request);- if (isDefined(presentedSessionToken)) {- if (origin === 'renewal_bridge') {- try {- const { payload: presentedPayload } = await this.resolveSession(- presentedSessionToken,- );-- if (- this.isSessionScopeMatchingRenewal(presentedPayload, sessionInput)- ) {- return;- }-- await this.revokeSessionByToken(- presentedSessionToken,- UserSessionRevokedReason.Superseded,- );- } catch (error) {- if (- !(error instanceof AuthException) ||- error.code !== AuthExceptionCode.UNAUTHENTICATED- ) {- throw error;- }- }- } else if (sessionInput.isImpersonating === true) {- // The one sign-in that must not revoke what it replaces: parking the- // impersonator's session lets stopImpersonation hand back the credential- // they already held.- this.userSessionCookieService.attachImpersonatorSessionTokenToResponse(- response,- presentedSessionToken,- );- } else {- await this.revokeSessionByToken(+ if (isDefined(presentedSessionToken) && origin === 'renewal_bridge') {+ try {+ const { payload: presentedPayload } = await this.resolveSession(presentedSessionToken,- UserSessionRevokedReason.Superseded,);++ if (+ this.isSessionScopeMatchingRenewal(presentedPayload, sessionInput)+ ) {+ return;+ }+ } catch (error) {+ if (+ !(error instanceof AuthException) ||+ error.code !== AuthExceptionCode.UNAUTHENTICATED+ ) {+ throw error;+ }}}+ // Create the replacement before touching the presented session. If the+ // insert fails, the browser keeps its last working credential.const { sessionToken, session } = await this.createSession(sessionInput);this.userSessionCookieService.attachSessionTokenToResponse(@@ -155,21 +141,45 @@ export class UserSessionService {sessionToken,session.expiresAt,);- } catch (error) {- // Sign-in only: the presented cookie may be the previous account's. On- // renewal it is this user's own live session, which a transient failure- // must not kill.- if (origin === 'sign_in') {- try {- this.userSessionCookieService.clearSessionCookie(response);- } catch {}++ if (!isDefined(presentedSessionToken)) {+ return;+ }++ if (sessionInput.isImpersonating === true) {+ // The one sign-in that must not revoke what it replaces: parking the+ // impersonator's session lets stopImpersonation hand back the credential+ // they already held.+ this.userSessionCookieService.attachImpersonatorSessionTokenToResponse(+ response,+ presentedSessionToken,+ );++ return;}+ try {+ await this.revokeSessionByToken(+ presentedSessionToken,+ UserSessionRevokedReason.Superseded,+ );+ } catch (error) {+ // The replacement session and cookie are already valid. A cleanup+ // failure must not turn that successful handoff into another logout.+ this.logger.error(+ `Failed to revoke the superseded session: ${+ error instanceof Error ? error.message : String(error)+ }`,+ );+ }+ } catch (error) {this.logger.error(- `Failed to issue a session alongside the token pair: ${+ `Failed to issue a required session: ${error instanceof Error ? error.message : String(error)}`,);++ throw error;}}diff --git a/packages/twenty-server/test/integration/graphql/suites/auth.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/auth.integration-spec.tsindex 331637aeca7..917fa5d9fdc 100644--- a/packages/twenty-server/test/integration/graphql/suites/auth.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/auth.integration-spec.ts@@ -35,7 +35,8 @@ describe('AuthResolve (integration)', () => {return client.post('/metadata')- .set('Origin', ORIGIN.toString())+ .set('Host', ORIGIN.host)+ .set('Origin', ORIGIN.origin).send(queryData).expect(200).expect((res) => {@@ -69,7 +70,8 @@ describe('AuthResolve (integration)', () => {return client.post('/metadata')- .set('Origin', ORIGIN.toString())+ .set('Host', ORIGIN.host)+ .set('Origin', ORIGIN.origin).send(queryData).expect(200).expect((res) => {diff --git a/packages/twenty-server/test/integration/graphql/suites/auth/user-sessions/failing-session-creation.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/auth/user-sessions/failing-session-creation.integration-spec.tsindex 2722a27a56b..2d284e6aa82 100644--- a/packages/twenty-server/test/integration/graphql/suites/auth/user-sessions/failing-session-creation.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/auth/user-sessions/failing-session-creation.integration-spec.ts@@ -1,14 +1,21 @@+import * as jwt from 'jsonwebtoken';import { buildAppleWorkspaceOrigin } from 'test/integration/graphql/utils/build-apple-workspace-origin.util';+import { forgeLegacyHs256Token } from 'test/integration/graphql/utils/forge-legacy-hs256-token.util';+import { getAuthTokensFromLoginTokenQueryFactory } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.query-factory.util';import { getLoginTokenFromCredentialsQueryFactory } from 'test/integration/graphql/utils/get-login-token-from-credentials.query-factory.util';import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';import {extractSessionCookie,+ hasClearingCookie,+ postMetadataOperationWithHeaders,signInWithCookieCapture,} from 'test/integration/graphql/suites/auth/user-sessions/utils/sign-in-with-cookie-capture.util';+import { type LoginTokenJwtPayload } from 'src/engine/core-modules/auth/types/login-token-jwt-payload.type';import { UserSessionEntity } from 'src/engine/core-modules/user-session/user-session.entity';+import { hashUserSessionToken } from 'src/engine/core-modules/user-session/utils/hash-user-session-token.util';import {ALLOWED_ORIGIN,@@ -16,7 +23,7 @@ import {} from 'test/integration/graphql/suites/auth/user-sessions/constants/session-origins.constants';describe('failing user session creation on auth exchanges (integration)', () => {- it('should refuse the cookie but still return tokens on a sign-in from a disallowed origin (login-CSRF)', async () => {+ it('should fail the exchange when a disallowed origin cannot receive its required session cookie', async () => {const userSessionRepository =getCoreRepository<UserSessionEntity>(UserSessionEntity);const sessionCountBefore = await userSessionRepository.count();@@ -25,9 +32,8 @@ describe('failing user session creation on auth exchanges (integration)', () =>originHeader: DISALLOWED_ORIGIN,});- expect(- response.body.data.getAuthTokensFromLoginToken.tokens.refreshToken.token,- ).toBeDefined();+ expect(response.body.errors).toBeDefined();+ expect(response.body.data?.getAuthTokensFromLoginToken).toBeFalsy();expect(extractSessionCookie(response)).toBeUndefined();const sessionCountAfter = await userSessionRepository.count();@@ -35,6 +41,68 @@ describe('failing user session creation on auth exchanges (integration)', () =>expect(sessionCountAfter).toBe(sessionCountBefore);});+ it('should preserve the presented session when replacement session creation fails', async () => {+ const existingSessionResponse = await signInWithCookieCapture({+ originHeader: ALLOWED_ORIGIN,+ });+ const existingSessionCookie = extractSessionCookie(existingSessionResponse);++ if (!existingSessionCookie) {+ throw new Error('Expected an existing session cookie');+ }++ const workspaceOrigin = buildAppleWorkspaceOrigin();+ const loginTokenResponse = await postMetadataOperationWithHeaders(+ getLoginTokenFromCredentialsQueryFactory({+ email: '[email protected]',+ password: '[email protected]',+ origin: workspaceOrigin,+ }),+ {+ originHeader: ALLOWED_ORIGIN,+ cookieHeader: existingSessionCookie.cookieHeader,+ },+ );+ const validLoginToken =+ loginTokenResponse.body.data.getLoginTokenFromCredentials.loginToken+ .token;+ const validPayload = jwt.decode(validLoginToken) as LoginTokenJwtPayload;+ const loginTokenWithoutProvider = forgeLegacyHs256Token(+ {+ sub: validPayload.sub,+ type: validPayload.type,+ workspaceId: validPayload.workspaceId,+ },+ validPayload.workspaceId,+ );++ const failedExchangeResponse = await postMetadataOperationWithHeaders(+ getAuthTokensFromLoginTokenQueryFactory({+ loginToken: loginTokenWithoutProvider,+ origin: workspaceOrigin,+ }),+ {+ originHeader: ALLOWED_ORIGIN,+ cookieHeader: existingSessionCookie.cookieHeader,+ },+ );++ expect(failedExchangeResponse.body.errors).toBeDefined();+ expect(+ failedExchangeResponse.body.data?.getAuthTokensFromLoginToken,+ ).toBeFalsy();+ expect(extractSessionCookie(failedExchangeResponse)).toBeUndefined();+ expect(hasClearingCookie(failedExchangeResponse)).toBe(false);++ const existingSession = await getCoreRepository<UserSessionEntity>(+ UserSessionEntity,+ ).findOneBy({+ tokenHash: hashUserSessionToken(existingSessionCookie.sessionToken),+ });++ expect(existingSession?.revokedAt).toBeNull();+ });+it('should mint nothing when the credentials exchange itself fails', async () => {const userSessionRepository =getCoreRepository<UserSessionEntity>(UserSessionEntity);