The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Bind the application claim OAuth state to the browser that started it (#26214)
martmull563728133b03
diff --git a/packages/twenty-front/src/pages/settings/applications/utils/getClaimErrorContent.ts b/packages/twenty-front/src/pages/settings/applications/utils/getClaimErrorContent.tsindex 286ca021761..8b92a9882bd 100644--- a/packages/twenty-front/src/pages/settings/applications/utils/getClaimErrorContent.ts+++ b/packages/twenty-front/src/pages/settings/applications/utils/getClaimErrorContent.ts@@ -28,6 +28,11 @@ export const getClaimErrorContent = (code: string): ClaimErrorContent => {message: msg`Your GitHub account does not own the organization that publishes this package. If you are an owner, grant this app access to the organization on GitHub's authorization screen (Organization access section).`,docPath: CI_PUBLISHING_PATH,};+ case 'CLAIM_STATE_MISMATCH':+ return {+ message: msg`This claim was started in another browser, or the claim link was opened from somewhere else. Start the claim again from this browser.`,+ docPath: CI_PUBLISHING_PATH,+ };case 'GITHUB_AUTH_FAILED':return {message: msg`GitHub authorization failed or was denied. Please connect your GitHub account again.`,diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.controller.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.controller.tsindex 6523e2c82e8..06bd47a6910 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.controller.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.controller.ts@@ -1,10 +1,13 @@-import { Controller, Get, Query, Res, UseGuards } from '@nestjs/common';+import { Controller, Get, Query, Req, Res, UseGuards } from '@nestjs/common';-import { Response } from 'express';+import { isNonEmptyString } from '@sniptt/guards';+import { Request, Response } from 'express';import { ApiPath, SettingsPath } from 'twenty-shared/types';import { getSettingsPath } from 'twenty-shared/utils';import { ApplicationRegistrationClaimService } from 'src/engine/core-modules/application/application-registration/application-registration-claim.service';+import { ApplicationRegistrationClaimStateCookieService } from 'src/engine/core-modules/application/application-registration/services/application-registration-claim-state-cookie.service';+import { claimStateNonceMatches } from 'src/engine/core-modules/application/application-registration/utils/claim-state-nonce-matches.util';import {ApplicationRegistrationException,ApplicationRegistrationExceptionCode,@@ -24,6 +27,7 @@ import { PublicEndpointGuard } from 'src/engine/guards/public-endpoint.guard';export class ApplicationRegistrationClaimController {constructor(private readonly applicationRegistrationClaimService: ApplicationRegistrationClaimService,+ private readonly claimStateCookieService: ApplicationRegistrationClaimStateCookieService,private readonly workspaceDomainsService: WorkspaceDomainsService,private readonly guardRedirectService: GuardRedirectService,private readonly twentyConfigService: TwentyConfigService,@@ -35,6 +39,7 @@ export class ApplicationRegistrationClaimController {@Query('code') code: string | undefined,@Query('state') state: string | undefined,@Query('error') oauthError: string | undefined,+ @Req() req: Request,@Res() res: Response,) {let workspace: WorkspaceEntity | null = null;@@ -50,6 +55,25 @@ export class ApplicationRegistrationClaimController {statePayload.workspaceId,);+ const stateNonce = this.claimStateCookieService.extractNonceFromRequest(+ req,+ statePayload.applicationRegistrationId,+ );++ if (+ isNonEmptyString(stateNonce) &&+ isNonEmptyString(statePayload.nonceHash) &&+ claimStateNonceMatches({+ nonce: stateNonce,+ expectedNonceHash: statePayload.nonceHash,+ })+ ) {+ this.claimStateCookieService.clearNonceCookie(+ res,+ statePayload.applicationRegistrationId,+ );+ }+if (oauthError !== undefined || code === undefined) {throw new ApplicationRegistrationException('GitHub authorization was denied',@@ -60,6 +84,7 @@ export class ApplicationRegistrationClaimController {await this.applicationRegistrationClaimService.completeGithubClaim({statePayload,code,+ stateNonce,});if (workspace === null) {diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.service.tsindex ce6f6add07e..f734d1aafec 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.service.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration-claim.service.ts@@ -1,8 +1,11 @@import { Injectable, Logger } from '@nestjs/common';import { InjectRepository } from '@nestjs/typeorm';+import crypto from 'crypto';+import { isNonEmptyString } from '@sniptt/guards';import axios from 'axios';+import { type Response } from 'express';import { isDefined } from 'twenty-shared/utils';import { type Repository } from 'typeorm';import { z } from 'zod';@@ -13,6 +16,9 @@ import {ApplicationRegistrationExceptionCode,} from 'src/engine/core-modules/application/application-registration/application-registration.exception';import { ApplicationRegistrationService } from 'src/engine/core-modules/application/application-registration/application-registration.service';+import { ApplicationRegistrationClaimStateCookieService } from 'src/engine/core-modules/application/application-registration/services/application-registration-claim-state-cookie.service';+import { claimStateNonceMatches } from 'src/engine/core-modules/application/application-registration/utils/claim-state-nonce-matches.util';+import { hashClaimStateNonce } from 'src/engine/core-modules/application/application-registration/utils/hash-claim-state-nonce.util';import { type AdminApplicationRegistrationClaimDTO } from 'src/engine/core-modules/application/application-registration/dtos/admin-application-registration-claim.dto';import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';import { isValidNpmVersionSpec } from 'src/engine/core-modules/application/application-package/utils/is-valid-npm-version-spec.util';@@ -23,6 +29,7 @@ import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twentimport { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';const GITHUB_CLAIM_STATE_EXPIRES_IN = '15m';+const GITHUB_CLAIM_STATE_TTL_MS = 15 * 60 * 1000;const attestationsResponseSchema = z.object({attestations: z.array(@@ -73,12 +80,14 @@ export class ApplicationRegistrationClaimService {private readonly applicationRegistrationService: ApplicationRegistrationService,private readonly jwtWrapperService: JwtWrapperService,private readonly twentyConfigService: TwentyConfigService,+ private readonly claimStateCookieService: ApplicationRegistrationClaimStateCookieService,) {}async buildGithubAuthorizationUrl(params: {applicationRegistrationId: string;workspaceId: string;userId: string | null;+ response: Response;}): Promise<string> {const registration =await this.applicationRegistrationService.findOneByIdGlobal(@@ -96,18 +105,28 @@ export class ApplicationRegistrationClaimService {);}+ const nonce = crypto.randomBytes(32).toString('hex');+const statePayload: ApplicationRegistrationGithubClaimStateJwtPayload = {sub: registration.id,type: JwtTokenTypeEnum.APPLICATION_REGISTRATION_GITHUB_CLAIM_STATE,applicationRegistrationId: registration.id,workspaceId: params.workspaceId,userId: params.userId,+ nonceHash: hashClaimStateNonce({ nonce }),};const state = await this.jwtWrapperService.signAsyncOrThrow(statePayload, {expiresIn: GITHUB_CLAIM_STATE_EXPIRES_IN,});+ this.claimStateCookieService.attachNonceToResponse({+ response: params.response,+ applicationRegistrationId: registration.id,+ nonce,+ maxAgeMs: GITHUB_CLAIM_STATE_TTL_MS,+ });+const authorizationUrl = new URL('https://github.com/login/oauth/authorize',);@@ -149,7 +168,10 @@ export class ApplicationRegistrationClaimService {async completeGithubClaim(params: {statePayload: ApplicationRegistrationGithubClaimStateJwtPayload;code: string;+ stateNonce: string | undefined;}): Promise<ApplicationRegistrationEntity> {+ this.assertStateNonceMatches(params.statePayload, params.stateNonce);+const registration =await this.applicationRegistrationService.findOneByIdGlobal(params.statePayload.applicationRegistrationId,@@ -202,6 +224,25 @@ export class ApplicationRegistrationClaimService {];}+ private assertStateNonceMatches(+ statePayload: ApplicationRegistrationGithubClaimStateJwtPayload,+ stateNonce: string | undefined,+ ): void {+ if (+ !isNonEmptyString(stateNonce) ||+ !isNonEmptyString(statePayload.nonceHash) ||+ !claimStateNonceMatches({+ nonce: stateNonce,+ expectedNonceHash: statePayload.nonceHash,+ })+ ) {+ throw new ApplicationRegistrationException(+ 'Claim state does not match the browser that started the claim',+ ApplicationRegistrationExceptionCode.CLAIM_STATE_MISMATCH,+ );+ }+ }+private assertClaimable(registration: ApplicationRegistrationEntity): string {if (isDefined(registration.ownerWorkspaceId)) {throw new ApplicationRegistrationException(diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.exception.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.exception.tsindex bee52464586..85333416827 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.exception.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.exception.ts@@ -23,6 +23,7 @@ export enum ApplicationRegistrationExceptionCode {PROVENANCE_CHECK_UNAVAILABLE = 'PROVENANCE_CHECK_UNAVAILABLE',GITHUB_AUTH_FAILED = 'GITHUB_AUTH_FAILED',GITHUB_ORG_OWNERSHIP_REQUIRED = 'GITHUB_ORG_OWNERSHIP_REQUIRED',+ CLAIM_STATE_MISMATCH = 'CLAIM_STATE_MISMATCH',}const getExceptionUserFriendlyMessage = (@@ -65,6 +66,8 @@ const getExceptionUserFriendlyMessage = (return msg`GitHub authentication failed. Try connecting your GitHub account again.`;case ApplicationRegistrationExceptionCode.GITHUB_ORG_OWNERSHIP_REQUIRED:return msg`Your GitHub account does not own the organization that publishes this package. If you are an owner, make sure you granted this app access to the organization on GitHub's authorization screen (Organization access section).`;+ case ApplicationRegistrationExceptionCode.CLAIM_STATE_MISMATCH:+ return msg`This claim was started in another browser or has already been used. Start the claim again from this browser.`;default:assertUnreachable(code);}diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.module.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.module.tsindex 1adbdec8e65..c4db50e8c76 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.module.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.module.ts@@ -6,6 +6,7 @@ import { ApplicationRegistrationAssetUrlService } from 'src/engine/core-modules/import { ApplicationRegistrationAssetService } from 'src/engine/core-modules/application/application-registration/application-registration-asset.service';import { ApplicationRegistrationClaimController } from 'src/engine/core-modules/application/application-registration/application-registration-claim.controller';import { ApplicationRegistrationClaimService } from 'src/engine/core-modules/application/application-registration/application-registration-claim.service';+import { ApplicationRegistrationClaimStateCookieService } from 'src/engine/core-modules/application/application-registration/services/application-registration-claim-state-cookie.service';import { ApplicationRegistrationEntity } from 'src/engine/core-modules/application/application-registration/application-registration.entity';import { ApplicationRegistrationResolver } from 'src/engine/core-modules/application/application-registration/application-registration.resolver';import { ApplicationRegistrationService } from 'src/engine/core-modules/application/application-registration/application-registration.service';@@ -55,6 +56,7 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/providers: [ApplicationRegistrationService,ApplicationRegistrationClaimService,+ ApplicationRegistrationClaimStateCookieService,ApplicationRegistrationResolver,ApplicationRegistrationSummaryResolver,ApplicationTarballService,diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.tsindex 3a5591f3911..8a77c9e0857 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts@@ -8,6 +8,7 @@ import {ResolveField,} from '@nestjs/graphql';+import { type Request } from 'express';import GraphQLUpload from 'graphql-upload/GraphQLUpload.mjs';import { PermissionFlagType } from 'twenty-shared/constants';import { FileFolder } from 'twenty-shared/types';@@ -364,12 +365,21 @@ export class ApplicationRegistrationResolver {@Args() { applicationRegistrationId }: ApplicationRegistrationClaimInput,@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,@AuthUser({ allowUndefined: true }) user: UserEntity | undefined,+ @Context() context: { req: Request },): Promise<string> {+ if (!isDefined(context.req.res)) {+ throw new ApplicationRegistrationException(+ 'Cannot start a GitHub claim without a response to bind it to',+ ApplicationRegistrationExceptionCode.CLAIM_STATE_MISMATCH,+ );+ }+return this.applicationRegistrationClaimService.buildGithubAuthorizationUrl({applicationRegistrationId,workspaceId,userId: user?.id ?? null,+ response: context.req.res,},);}diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/constants/application-registration-claim-state-cookie-name.constant.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/constants/application-registration-claim-state-cookie-name.constant.tsnew file mode 100644index 00000000000..35fcb80f026--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/constants/application-registration-claim-state-cookie-name.constant.ts@@ -0,0 +1,9 @@+const CLAIM_STATE_COOKIE_PREFIX = 'twenty-app-claim-state';++export const getApplicationRegistrationClaimStateCookieName = (+ applicationRegistrationId: string,+): string => `${CLAIM_STATE_COOKIE_PREFIX}-${applicationRegistrationId}`;++export const getApplicationRegistrationClaimStateSecureCookieName = (+ applicationRegistrationId: string,+): string => `__Host-${CLAIM_STATE_COOKIE_PREFIX}-${applicationRegistrationId}`;diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/services/application-registration-claim-state-cookie.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/services/application-registration-claim-state-cookie.service.tsnew file mode 100644index 00000000000..d5207dd7d4b--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/services/application-registration-claim-state-cookie.service.ts@@ -0,0 +1,110 @@+import { Injectable } from '@nestjs/common';++import { isNonEmptyString } from '@sniptt/guards';+import { type CookieOptions, type Request, type Response } from 'express';++import {+ getApplicationRegistrationClaimStateCookieName,+ getApplicationRegistrationClaimStateSecureCookieName,+} from 'src/engine/core-modules/application/application-registration/constants/application-registration-claim-state-cookie-name.constant';+import { isSecureCookieDeployment } from 'src/engine/core-modules/application/application-registration/utils/is-secure-cookie-deployment.util';+import { readRequestCookie } from 'src/engine/core-modules/application/application-registration/utils/read-request-cookie.util';+import { resolveClaimStateCookieSameSite } from 'src/engine/core-modules/application/application-registration/utils/resolve-claim-state-cookie-same-site.util';+import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';++@Injectable()+export class ApplicationRegistrationClaimStateCookieService {+ constructor(private readonly twentyConfigService: TwentyConfigService) {}++ attachNonceToResponse({+ response,+ applicationRegistrationId,+ nonce,+ maxAgeMs,+ }: {+ response: Response;+ applicationRegistrationId: string;+ nonce: string;+ maxAgeMs: number;+ }): void {+ response.cookie(this.resolveCookieName(applicationRegistrationId), nonce, {+ ...this.resolveCookieOptions(),+ maxAge: maxAgeMs,+ });+ }++ extractNonceFromRequest(+ request: Request,+ applicationRegistrationId: string,+ ): string | undefined {+ const secureNonce = readRequestCookie(+ request,+ getApplicationRegistrationClaimStateSecureCookieName(+ applicationRegistrationId,+ ),+ );++ if (isNonEmptyString(secureNonce)) {+ return secureNonce;+ }++ if (this.isSecureDeployment()) {+ return undefined;+ }++ return readRequestCookie(+ request,+ getApplicationRegistrationClaimStateCookieName(applicationRegistrationId),+ );+ }++ clearNonceCookie(+ response: Response,+ applicationRegistrationId: string,+ ): void {+ const options = this.resolveCookieOptions();++ response.clearCookie(+ getApplicationRegistrationClaimStateSecureCookieName(+ applicationRegistrationId,+ ),+ options,+ );+ response.clearCookie(+ getApplicationRegistrationClaimStateCookieName(applicationRegistrationId),+ options,+ );+ }++ private resolveCookieName(applicationRegistrationId: string): string {+ return this.isSecureDeployment()+ ? getApplicationRegistrationClaimStateSecureCookieName(+ applicationRegistrationId,+ )+ : getApplicationRegistrationClaimStateCookieName(+ applicationRegistrationId,+ );+ }++ private resolveCookieOptions(): CookieOptions {+ return {+ httpOnly: true,+ secure: this.isSecureDeployment(),+ sameSite: this.resolveSameSite(),+ path: '/',+ };+ }++ private resolveSameSite(): 'lax' | 'none' {+ return resolveClaimStateCookieSameSite({+ sameSite: this.twentyConfigService.get('AUTH_COOKIE_SAME_SITE'),+ });+ }++ private isSecureDeployment(): boolean {+ return isSecureCookieDeployment({+ serverUrl: this.twentyConfigService.get('SERVER_URL'),+ sameSite: this.twentyConfigService.get('AUTH_COOKIE_SAME_SITE'),+ });+ }+}diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/claim-state-nonce-matches.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/claim-state-nonce-matches.util.tsnew file mode 100644index 00000000000..650d5ed8cca--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/claim-state-nonce-matches.util.ts@@ -0,0 +1,20 @@+import { timingSafeEqual } from 'crypto';++import { hashClaimStateNonce } from 'src/engine/core-modules/application/application-registration/utils/hash-claim-state-nonce.util';++export const claimStateNonceMatches = ({+ nonce,+ expectedNonceHash,+}: {+ nonce: string;+ expectedNonceHash: string;+}): boolean => {+ const actual = Buffer.from(hashClaimStateNonce({ nonce }), 'hex');+ const expected = Buffer.from(expectedNonceHash, 'hex');++ if (actual.length !== expected.length) {+ return false;+ }++ return timingSafeEqual(actual, expected);+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/hash-claim-state-nonce.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/hash-claim-state-nonce.util.tsnew file mode 100644index 00000000000..4ad0878871c--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/hash-claim-state-nonce.util.ts@@ -0,0 +1,4 @@+import { createHash } from 'crypto';++export const hashClaimStateNonce = ({ nonce }: { nonce: string }): string =>+ createHash('sha256').update(nonce).digest('hex');diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-https-url.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-https-url.util.tsnew file mode 100644index 00000000000..b0ca14ff452--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-https-url.util.ts@@ -0,0 +1,13 @@+import { isNonEmptyString } from '@sniptt/guards';++export const isHttpsUrl = (url: string | undefined): boolean => {+ if (!isNonEmptyString(url)) {+ return false;+ }++ try {+ return new URL(url).protocol === 'https:';+ } catch {+ return false;+ }+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-secure-cookie-deployment.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-secure-cookie-deployment.util.tsnew file mode 100644index 00000000000..07cca72db9d--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-secure-cookie-deployment.util.ts@@ -0,0 +1,9 @@+import { isHttpsUrl } from 'src/engine/core-modules/application/application-registration/utils/is-https-url.util';++export const isSecureCookieDeployment = ({+ serverUrl,+ sameSite,+}: {+ serverUrl: string | undefined;+ sameSite: 'lax' | 'strict' | 'none';+}): boolean => isHttpsUrl(serverUrl) || sameSite === 'none';diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/read-request-cookie.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/read-request-cookie.util.tsnew file mode 100644index 00000000000..d281fcbabe4--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/read-request-cookie.util.ts@@ -0,0 +1,33 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type Request } from 'express';++export const readRequestCookie = (+ request: Request,+ cookieName: string,+): string | undefined => {+ const cookieHeader = request.headers.cookie;++ if (!isNonEmptyString(cookieHeader)) {+ return undefined;+ }++ for (const cookiePart of cookieHeader.split(';')) {+ const separatorIndex = cookiePart.indexOf('=');++ if (separatorIndex === -1) {+ continue;+ }++ if (cookiePart.slice(0, separatorIndex).trim() !== cookieName) {+ continue;+ }++ const value = cookiePart.slice(separatorIndex + 1).trim();++ if (isNonEmptyString(value)) {+ return value;+ }+ }++ return undefined;+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/resolve-claim-state-cookie-same-site.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/resolve-claim-state-cookie-same-site.util.tsnew file mode 100644index 00000000000..2d6f9845d05--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/resolve-claim-state-cookie-same-site.util.ts@@ -0,0 +1,5 @@+export const resolveClaimStateCookieSameSite = ({+ sameSite,+}: {+ sameSite: 'lax' | 'strict' | 'none';+}): 'lax' | 'none' => (sameSite === 'none' ? 'none' : 'lax');diff --git a/packages/twenty-server/src/engine/core-modules/auth/types/application-registration-github-claim-state-jwt-payload.type.ts b/packages/twenty-server/src/engine/core-modules/auth/types/application-registration-github-claim-state-jwt-payload.type.tsindex 68f719f3d6c..84c4c44e904 100644--- a/packages/twenty-server/src/engine/core-modules/auth/types/application-registration-github-claim-state-jwt-payload.type.ts+++ b/packages/twenty-server/src/engine/core-modules/auth/types/application-registration-github-claim-state-jwt-payload.type.ts@@ -7,4 +7,5 @@ export type ApplicationRegistrationGithubClaimStateJwtPayload =applicationRegistrationId: string;workspaceId: string;userId: string | null;+ nonceHash: string;};diff --git a/packages/twenty-server/test/integration/application-registration/suites/application-registration-claim-state-binding.integration-spec.ts b/packages/twenty-server/test/integration/application-registration/suites/application-registration-claim-state-binding.integration-spec.tsnew file mode 100644index 00000000000..9f6dac331c7--- /dev/null+++ b/packages/twenty-server/test/integration/application-registration/suites/application-registration-claim-state-binding.integration-spec.ts@@ -0,0 +1,293 @@+import crypto from 'crypto';++import gql from 'graphql-tag';+import { http, HttpResponse } from 'msw';+import request from 'supertest';+import { type DataSource } from 'typeorm';++import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';++import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';+import { setupHttpMock } from 'test/integration/utils/http-mock.util';++const CALLBACK_PATH = '/application-registration-claim/github/callback';+const PUBLISHER_ORG = 'publisher-org';+const PACKAGE_VERSION = '1.0.0';++const provenanceAttestations = (repository: string) => ({+ attestations: [+ {+ predicateType: 'https://slsa.dev/provenance/v1',+ bundle: {+ dsseEnvelope: {+ payload: Buffer.from(+ JSON.stringify({+ predicate: {+ buildDefinition: {+ externalParameters: { workflow: { repository } },+ },+ },+ }),+ ).toString('base64'),+ },+ },+ },+ ],+});++const insertClaimableRegistration = async (+ dataSource: DataSource,+ sourcePackage: string,+): Promise<string> => {+ const id = crypto.randomUUID();++ await dataSource.query(+ `INSERT INTO core."applicationRegistration"+ (id, "universalIdentifier", name, "oAuthClientId", "oAuthRedirectUris", "oAuthScopes",+ "sourceType", "sourcePackage", "latestAvailableVersion", "workspaceId")+ VALUES ($1, $2, $3, $4, '{}', '{}', 'npm', $5, $6, NULL)`,+ [+ id,+ crypto.randomUUID(),+ `claim-target-${id.slice(0, 8)}`,+ crypto.randomUUID(),+ sourcePackage,+ PACKAGE_VERSION,+ ],+ );++ return id;+};++const readOwnerWorkspaceId = async (+ dataSource: DataSource,+ registrationId: string,+): Promise<string | null> => {+ const [row] = await dataSource.query(+ 'SELECT "workspaceId" FROM core."applicationRegistration" WHERE id = $1',+ [registrationId],+ );++ return row?.workspaceId ?? null;+};++describe('Application registration claim state binding (integration)', () => {+ const httpMock = setupHttpMock();++ const baseUrl = `http://localhost:${APP_PORT}`;+ let dataSource: DataSource;++ beforeAll(async () => {+ dataSource = global.testDataSource;++ await updateConfigVariable({+ input: { key: 'APP_CLAIM_GITHUB_CLIENT_ID', value: 'test-client-id' },+ });+ await updateConfigVariable({+ input: {+ key: 'APP_CLAIM_GITHUB_CLIENT_SECRET',+ value: 'test-client-secret',+ },+ });+ });++ const stubPublisherIsOrgAdmin = (sourcePackage: string) => {+ const encodedName = sourcePackage.replace(/\//g, '%2F');++ httpMock.use(+ http.get(+ `https://registry.npmjs.org/-/npm/v1/attestations/${encodedName}@${PACKAGE_VERSION}`,+ () =>+ HttpResponse.json(+ provenanceAttestations(`https://github.com/${PUBLISHER_ORG}/app`),+ ),+ ),+ http.post('https://github.com/login/oauth/access_token', () =>+ HttpResponse.json({ access_token: 'github-token' }),+ ),+ http.get('https://api.github.com/user', () =>+ HttpResponse.json({ login: 'publisher-maintainer' }),+ ),+ http.get(+ `https://api.github.com/user/memberships/orgs/${PUBLISHER_ORG}`,+ () => HttpResponse.json({ state: 'active', role: 'admin' }),+ ),+ );+ };++ // Mints an authorization url the way the settings page does, and returns the+ // state GitHub will echo back plus the nonce cookie the browser receives.+ const startClaim = async (registrationId: string) => {+ const response = await makeMetadataAPIRequest({+ query: gql`+ query GithubClaimAuthorizationUrl($applicationRegistrationId: String!) {+ githubClaimAuthorizationUrl(+ applicationRegistrationId: $applicationRegistrationId+ )+ }+ `,+ variables: { applicationRegistrationId: registrationId },+ });++ expect(response.body.errors).toBeUndefined();++ const authorizationUrl = new URL(+ response.body.data.githubClaimAuthorizationUrl,+ );+ const setCookie = response.headers['set-cookie'];++ expect(setCookie).toBeDefined();++ return {+ state: authorizationUrl.searchParams.get('state') as string,+ cookie: (setCookie as unknown as string[])[0].split(';')[0],+ };+ };++ const callback = (params: { state: string; cookie?: string }) => {+ const pending = request(baseUrl)+ .get(CALLBACK_PATH)+ .query({ code: 'github-code', state: params.state });++ if (params.cookie !== undefined) {+ pending.set('Cookie', params.cookie);+ }++ return pending;+ };++ // A strict cookie is withheld on GitHub's cross-site redirect back to the+ // callback, which would fail every claim on instances configured that way.+ it.each(['strict', 'lax', 'none'] as const)(+ 'never issues the nonce cookie as SameSite=strict when AUTH_COOKIE_SAME_SITE is %s',+ async (sameSite) => {+ const registrationId = await insertClaimableRegistration(+ dataSource,+ `@${PUBLISHER_ORG}/same-site-${sameSite}`,+ );++ await updateConfigVariable({+ input: { key: 'AUTH_COOKIE_SAME_SITE', value: sameSite },+ });++ try {+ const response = await makeMetadataAPIRequest({+ query: gql`+ query GithubClaimAuthorizationUrl(+ $applicationRegistrationId: String!+ ) {+ githubClaimAuthorizationUrl(+ applicationRegistrationId: $applicationRegistrationId+ )+ }+ `,+ variables: { applicationRegistrationId: registrationId },+ });++ const [claimCookie] = response.headers[+ 'set-cookie'+ ] as unknown as string[];++ expect(claimCookie.toLowerCase()).not.toContain('samesite=strict');+ expect(claimCookie.toLowerCase()).toContain(+ sameSite === 'none' ? 'samesite=none' : 'samesite=lax',+ );+ } finally {+ await updateConfigVariable({+ input: { key: 'AUTH_COOKIE_SAME_SITE', value: 'lax' },+ });+ }+ },+ );++ it('claims the registration for the browser that started the claim', async () => {+ const sourcePackage = `@${PUBLISHER_ORG}/happy-path`;+ const registrationId = await insertClaimableRegistration(+ dataSource,+ sourcePackage,+ );++ stubPublisherIsOrgAdmin(sourcePackage);++ const { state, cookie } = await startClaim(registrationId);+ const response = await callback({ state, cookie });++ expect(response.status).toBe(302);+ expect(response.headers.location).not.toContain('claimErrorCode');+ await expect(+ readOwnerWorkspaceId(dataSource, registrationId),+ ).resolves.toBe(SEED_APPLE_WORKSPACE_ID);+ });++ it('rejects a forwarded authorization url opened in another browser', async () => {+ const sourcePackage = `@${PUBLISHER_ORG}/forwarded`;+ const registrationId = await insertClaimableRegistration(+ dataSource,+ sourcePackage,+ );++ stubPublisherIsOrgAdmin(sourcePackage);++ // The url is forwarded to the publisher, whose browser never received the+ // nonce cookie, so the claim must not land in the sender's workspace.+ const { state } = await startClaim(registrationId);+ const response = await callback({ state });++ expect(response.status).toBe(302);+ expect(response.headers.location).toContain(+ 'claimErrorCode=CLAIM_STATE_MISMATCH',+ );+ await expect(+ readOwnerWorkspaceId(dataSource, registrationId),+ ).resolves.toBeNull();+ });++ it('rejects a nonce minted for another claim', async () => {+ const sourcePackage = `@${PUBLISHER_ORG}/other-claim`;+ const registrationId = await insertClaimableRegistration(+ dataSource,+ sourcePackage,+ );+ const otherRegistrationId = await insertClaimableRegistration(+ dataSource,+ `@${PUBLISHER_ORG}/other-claim-source`,+ );++ stubPublisherIsOrgAdmin(sourcePackage);++ const { state } = await startClaim(registrationId);+ const { cookie: otherCookie } = await startClaim(otherRegistrationId);++ const response = await callback({ state, cookie: otherCookie });++ expect(response.headers.location).toContain(+ 'claimErrorCode=CLAIM_STATE_MISMATCH',+ );+ await expect(+ readOwnerWorkspaceId(dataSource, registrationId),+ ).resolves.toBeNull();+ });++ it('leaves a pending claim alone when the callback is hit with unrelated state', async () => {+ const sourcePackage = `@${PUBLISHER_ORG}/not-cleared`;+ const registrationId = await insertClaimableRegistration(+ dataSource,+ sourcePackage,+ );++ stubPublisherIsOrgAdmin(sourcePackage);++ const { state, cookie } = await startClaim(registrationId);++ // An unrelated page navigates the browser to the public callback first.+ await callback({ state: 'not-a-signed-state', cookie });++ const response = await callback({ state, cookie });++ expect(response.headers.location).not.toContain('claimErrorCode');+ await expect(+ readOwnerWorkspaceId(dataSource, registrationId),+ ).resolves.toBe(SEED_APPLE_WORKSPACE_ID);+ });+});diff --git a/packages/twenty-server/test/integration/secure-deployment/suites/secure-claim-state-cookie.integration-spec.ts b/packages/twenty-server/test/integration/secure-deployment/suites/secure-claim-state-cookie.integration-spec.tsnew file mode 100644index 00000000000..e396b2c5d0c--- /dev/null+++ b/packages/twenty-server/test/integration/secure-deployment/suites/secure-claim-state-cookie.integration-spec.ts@@ -0,0 +1,124 @@+import crypto from 'crypto';++import gql from 'graphql-tag';+import request from 'supertest';+import { type DataSource } from 'typeorm';++import {+ getApplicationRegistrationClaimStateCookieName,+ getApplicationRegistrationClaimStateSecureCookieName,+} from 'src/engine/core-modules/application/application-registration/constants/application-registration-claim-state-cookie-name.constant';++import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';++import { IS_SECURE_DEPLOYMENT } from 'test/integration/graphql/suites/auth/user-sessions/constants/is-secure-deployment.constant';++// The secure/insecure cookie branch is decided by configuration, never by the+// transport: isSecureCookieDeployment() reads SERVER_URL, which is env-only.+// Run through `nx run twenty-server:test:integration:secure`.+describe('claim state cookie on a production-like secure deployment (integration)', () => {+ let registrationId: string;++ beforeAll(async () => {+ if (!IS_SECURE_DEPLOYMENT) {+ throw new Error(+ 'This suite requires an https SERVER_URL; run it via nx run twenty-server:test:integration:secure',+ );+ }++ const dataSource: DataSource = global.testDataSource;++ registrationId = crypto.randomUUID();++ await dataSource.query(+ `INSERT INTO core."applicationRegistration"+ (id, "universalIdentifier", name, "oAuthClientId", "oAuthRedirectUris", "oAuthScopes",+ "sourceType", "sourcePackage", "latestAvailableVersion", "workspaceId")+ VALUES ($1, $2, 'secure-claim-target', $3, '{}', '{}', 'npm', $4, '1.0.0', NULL)`,+ [+ registrationId,+ crypto.randomUUID(),+ crypto.randomUUID(),+ `@publisher-org/secure-${registrationId.slice(0, 8)}`,+ ],+ );++ await updateConfigVariable({+ input: { key: 'APP_CLAIM_GITHUB_CLIENT_ID', value: 'test-client-id' },+ });+ await updateConfigVariable({+ input: {+ key: 'APP_CLAIM_GITHUB_CLIENT_SECRET',+ value: 'test-client-secret',+ },+ });+ });++ const startClaim = async () => {+ const response = await makeMetadataAPIRequest({+ query: gql`+ query GithubClaimAuthorizationUrl($applicationRegistrationId: String!) {+ githubClaimAuthorizationUrl(+ applicationRegistrationId: $applicationRegistrationId+ )+ }+ `,+ variables: { applicationRegistrationId: registrationId },+ });++ expect(response.body.errors).toBeUndefined();++ const [claimCookie] = response.headers['set-cookie'] as unknown as string[];++ return {+ claimCookie,+ nonce: claimCookie.split(';')[0].split('=')[1],+ state: new URL(+ response.body.data.githubClaimAuthorizationUrl,+ ).searchParams.get('state') as string,+ };+ };++ it('should deliver the production cookie: __Host- name, Secure, SameSite=Lax', async () => {+ const response = await makeMetadataAPIRequest({+ query: gql`+ query GithubClaimAuthorizationUrl($applicationRegistrationId: String!) {+ githubClaimAuthorizationUrl(+ applicationRegistrationId: $applicationRegistrationId+ )+ }+ `,+ variables: { applicationRegistrationId: registrationId },+ });++ expect(response.body.errors).toBeUndefined();++ const [claimCookie] = response.headers['set-cookie'] as unknown as string[];++ expect(claimCookie).toContain(+ `${getApplicationRegistrationClaimStateSecureCookieName(registrationId)}=`,+ );+ expect(claimCookie).toContain('Secure');+ expect(claimCookie).toContain('HttpOnly');+ expect(claimCookie.toLowerCase()).toContain('samesite=lax');+ });++ // A sibling subdomain can set a cookie under the plain name but never under+ // __Host-, so the plain name must not be honoured on an https deployment.+ it('should ignore a nonce planted under the plain cookie name', async () => {+ const { state, nonce } = await startClaim();++ const response = await request(`http://localhost:${APP_PORT}`)+ .get('/application-registration-claim/github/callback')+ .query({ code: 'github-code', state })+ .set(+ 'Cookie',+ `${getApplicationRegistrationClaimStateCookieName(registrationId)}=${nonce}`,+ );++ expect(response.headers.location).toContain(+ 'claimErrorCode=CLAIM_STATE_MISMATCH',+ );+ });+});