Scheduling infrastructure for absolutely everyone.
feat: OAuth PKCE (#25313)
Carina Wollendorfer4e0798577ab6
diff --git a/apps/web/app/api/auth/oauth/refreshToken/route.ts b/apps/web/app/api/auth/oauth/refreshToken/route.tsindex ef0baeeee85..aafcedaa776 100644--- a/apps/web/app/api/auth/oauth/refreshToken/route.ts+++ b/apps/web/app/api/auth/oauth/refreshToken/route.ts@@ -4,52 +4,71 @@ import jwt from "jsonwebtoken";import { NextResponse } from "next/server";import type { NextRequest } from "next/server";+import { OAuthClientRepository } from "@calcom/features/oauth/repositories/OAuthClientRepository";+import { OAuthService } from "@calcom/features/oauth/services/OAuthService";import prisma from "@calcom/prisma";-import { generateSecret } from "@calcom/trpc/server/routers/viewer/oAuth/addClient.handler";import type { OAuthTokenPayload } from "@calcom/types/oauth";async function handler(req: NextRequest) {- const { client_id, client_secret, grant_type } = await parseUrlFormData(req);+ const { client_id, client_secret, grant_type, refresh_token, code_verifier } = await parseUrlFormData(req);- if (!client_id || !client_secret) {- return NextResponse.json({ message: "Missing client id or secret" }, { status: 400 });+ if (!process.env.CALENDSO_ENCRYPTION_KEY) {+ return NextResponse.json({ message: "CALENDSO_ENCRYPTION_KEY is not set" }, { status: 500 });+ }++ if (!client_id) {+ return NextResponse.json({ error: "invalid_request" }, { status: 400 });}if (grant_type !== "refresh_token") {- return NextResponse.json({ message: "grant type invalid" }, { status: 400 });+ return NextResponse.json({ error: "invalid_request" }, { status: 400 });}- const [hashedSecret] = generateSecret(client_secret);+ const oAuthClientRepository = new OAuthClientRepository(prisma);- const client = await prisma.oAuthClient.findFirst({- where: {- clientId: client_id,- clientSecret: hashedSecret,- },- select: {- redirectUri: true,- },- });+ const client = await oAuthClientRepository.findByClientId(client_id);if (!client) {- return NextResponse.json({ message: "Unauthorized" }, { status: 401 });+ return NextResponse.json({ error: "invalid_client" }, { status: 401 });+ }++ const isValidClient = OAuthService.validateClient(client, client_secret);++ if (!isValidClient) {+ return NextResponse.json({ error: "invalid_client" }, { status: 401 });}- const secretKey = process.env.CALENDSO_ENCRYPTION_KEY || "";+ const secretKey = process.env.CALENDSO_ENCRYPTION_KEY;let decodedRefreshToken: OAuthTokenPayload;try {- const refreshToken = req.headers.get("authorization")?.split(" ")[1] || "";- decodedRefreshToken = jwt.verify(refreshToken, secretKey) as OAuthTokenPayload;+ const refreshTokenValue = refresh_token || req.headers.get("authorization")?.split(" ")[1] || "";++ if (!refreshTokenValue) {+ return NextResponse.json({ error: "invalid_request" }, { status: 400 });+ }++ decodedRefreshToken = jwt.verify(refreshTokenValue, secretKey) as OAuthTokenPayload;} catch {- return NextResponse.json({ message: "Unauthorized" }, { status: 401 });+ return NextResponse.json({ error: "invalid_grant" }, { status: 400 });}if (!decodedRefreshToken || decodedRefreshToken.token_type !== "Refresh Token") {- return NextResponse.json({ message: "Unauthorized" }, { status: 401 });+ return NextResponse.json({ error: "invalid_grant" }, { status: 400 });+ }++ if (decodedRefreshToken.clientId !== client_id) {+ return NextResponse.json({ error: "invalid_grant" }, { status: 400 });}+ const pkceError = OAuthService.verifyPKCE(client, decodedRefreshToken, code_verifier);+ if (pkceError) {+ return NextResponse.json({ error: pkceError.error }, { status: pkceError.status });+ }++ const accessTokenExpiresIn = 1800; // 30 minutes+const payloadAuthToken: OAuthTokenPayload = {userId: decodedRefreshToken.userId,teamId: decodedRefreshToken.teamId,@@ -64,17 +83,37 @@ async function handler(req: NextRequest) {scope: decodedRefreshToken.scope,token_type: "Refresh Token",clientId: client_id,+ // Preserve PKCE information for any client that used PKCE originally+ ...(decodedRefreshToken.codeChallenge && {+ codeChallenge: decodedRefreshToken.codeChallenge,+ codeChallengeMethod: decodedRefreshToken.codeChallengeMethod,+ }),};const access_token = jwt.sign(payloadAuthToken, secretKey, {- expiresIn: 1800, // 30 min+ expiresIn: accessTokenExpiresIn,});- const refresh_token = jwt.sign(payloadRefreshToken, secretKey, {+ const refresh_token_new = jwt.sign(payloadRefreshToken, secretKey, {expiresIn: 30 * 24 * 60 * 60, // 30 days});- return NextResponse.json({ access_token, refresh_token }, { status: 200 });+ return NextResponse.json(+ {+ access_token,+ token_type: "bearer",+ refresh_token: refresh_token_new,+ expires_in: accessTokenExpiresIn,+ },+ {+ status: 200,+ headers: {+ "Content-Type": "application/json;charset=UTF-8",+ "Cache-Control": "no-store",+ Pragma: "no-cache",+ },+ }+ );}export const POST = defaultResponderForAppDir(handler);diff --git a/apps/web/app/api/auth/oauth/token/__tests__/route.test.ts b/apps/web/app/api/auth/oauth/token/__tests__/route.test.tsnew file mode 100644index 00000000000..aa58439d633--- /dev/null+++ b/apps/web/app/api/auth/oauth/token/__tests__/route.test.ts@@ -0,0 +1,540 @@+import prismaMock from "../../../../../../../../tests/libs/__mocks__/prismaMock";++import jwt from "jsonwebtoken";+// Import mocked dependencies after mocks are set up+import { NextRequest } from "next/server";+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";++import { verifyCodeChallenge } from "@calcom/lib/pkce";+import { generateSecret } from "@calcom/trpc/server/routers/viewer/oAuth/addClient.handler";++import { POST } from "../route";++// Create mock NextResponse.json function using hoisted+const mockNextResponseJson = vi.hoisted(() => {+ return vi.fn((data: unknown, options?: { status?: number; headers?: Record<string, string> }) => ({+ json: vi.fn().mockResolvedValue(data),+ status: options?.status || 200,+ headers: new Headers(options?.headers || {}),+ }));+});++// Mock next/server before importing anything that uses it+vi.mock("next/server", () => ({+ NextRequest: class MockNextRequest {+ url: string;+ method: string;+ nextUrl: { pathname: string; searchParams: URLSearchParams };+ private _body: string;++ constructor(+ url: string,+ options: { method?: string; body?: string; headers?: Record<string, string> } = {}+ ) {+ this.url = url;+ this.method = options.method || "POST";+ this._body = options.body || "";+ const urlObj = new URL(url);+ this.nextUrl = {+ pathname: urlObj.pathname,+ searchParams: urlObj.searchParams,+ };+ }++ async text(): Promise<string> {+ return this._body;+ }+ },+ NextResponse: {+ json: mockNextResponseJson,+ },+}));++// Mock dependencies+vi.mock("@calcom/lib/pkce", () => ({+ verifyCodeChallenge: vi.fn(),+}));++vi.mock("@calcom/trpc/server/routers/viewer/oAuth/addClient.handler", () => ({+ generateSecret: vi.fn(),+}));++vi.mock("jsonwebtoken", () => ({+ default: {+ sign: vi.fn(() => "mock_jwt_token"),+ },+}));++vi.mock("@calcom/prisma", () => ({+ default: prismaMock,+}));++vi.mock("app/api/defaultResponderForAppDir", async () => {+ const { NextResponse } = await import("next/server");+ return {+ defaultResponderForAppDir:+ (+ handler: (req: NextRequest, context: { params: Promise<Record<string, string>> }) => Promise<Response>+ ) =>+ async (req: NextRequest, context?: { params: Promise<Record<string, string>> }) => {+ try {+ const result = await handler(req, context || { params: Promise.resolve({}) });+ if (result) {+ return result;+ }+ return NextResponse.json({});+ } catch (error: unknown) {+ const errorMessage = error instanceof Error ? error.message : "Internal server error";+ return NextResponse.json(+ {+ message: errorMessage,+ },+ { status: 500 }+ );+ }+ },+ };+});++vi.mock("app/api/parseRequestData", () => ({+ parseUrlFormData: async (req: NextRequest): Promise<Record<string, string>> => {+ const text = await req.text();+ const params = new URLSearchParams(text);+ return Object.fromEntries(params);+ },+}));++const mockVerifyCodeChallenge = vi.mocked(verifyCodeChallenge);+const mockGenerateSecret = vi.mocked(generateSecret);+const mockJwt = vi.mocked(jwt);++// Set up environment+vi.stubEnv("CALENDSO_ENCRYPTION_KEY", "test_encryption_key");++// Helper to create token exchange request+function createTokenRequest(data: Record<string, string>) {+ const formData = new URLSearchParams(data);+ const request = new NextRequest("http://localhost:3000/api/auth/oauth/token", {+ method: "POST",+ body: formData.toString(),+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });+ return request;+}++describe("POST /api/auth/oauth/token", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ mockJwt.sign.mockReturnValue("mock_jwt_token" as never);+ mockVerifyCodeChallenge.mockReturnValue(false);+ mockGenerateSecret.mockReturnValue(["hashed_secret", "plain_secret"]);+ // Reset the mock for NextResponse.json+ mockNextResponseJson.mockImplementation(+ (data: unknown, options?: { status?: number; headers?: Record<string, string> }) => ({+ json: vi.fn().mockResolvedValue(data),+ status: options?.status || 200,+ headers: new Headers(options?.headers || {}),+ })+ );+ });++ afterEach(() => {+ vi.resetAllMocks();+ });++ describe("PUBLIC clients", () => {+ const mockPublicClient = {+ redirectUri: "https://app.example.com/callback",+ clientSecret: null,+ clientType: "PUBLIC" as const,+ } as const;++ const mockAccessCode = {+ userId: 1,+ teamId: null,+ scopes: [] as const,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ } as const;++ it("should exchange authorization code for tokens with valid PKCE", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockPublicClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue(+ mockAccessCode as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>+ );+ prismaMock.accessCode.deleteMany.mockResolvedValue({ count: 1 });+ mockVerifyCodeChallenge.mockReturnValue(true);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "public_client_123",+ redirect_uri: "https://app.example.com/callback",+ code_verifier: "test_verifier",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(200);+ expect(data).toEqual({+ access_token: "mock_jwt_token",+ token_type: "bearer",+ refresh_token: "mock_jwt_token",+ expires_in: 1800,+ });++ expect(mockVerifyCodeChallenge).toHaveBeenCalledWith("test_verifier", "test_challenge", "S256");+ expect(prismaMock.accessCode.deleteMany).toHaveBeenCalled();+ });++ it("should reject PUBLIC client without code_verifier", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockPublicClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue(+ mockAccessCode as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>+ );++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "public_client_123",+ redirect_uri: "https://app.example.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_request");+ });++ it("should reject PUBLIC client with missing code challenge in access code", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockPublicClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue({+ ...mockAccessCode,+ codeChallenge: null,+ } as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>);+ prismaMock.accessCode.deleteMany.mockResolvedValue({ count: 1 });++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "public_client_123",+ redirect_uri: "https://app.example.com/callback",+ code_verifier: "test_verifier",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_request");+ });++ it("should reject PUBLIC client with invalid code_verifier", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockPublicClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue(+ mockAccessCode as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>+ );+ prismaMock.accessCode.deleteMany.mockResolvedValue({ count: 1 });+ mockVerifyCodeChallenge.mockReturnValue(false);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "public_client_123",+ redirect_uri: "https://app.example.com/callback",+ code_verifier: "wrong_verifier",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_grant");+ expect(mockVerifyCodeChallenge).toHaveBeenCalledWith("wrong_verifier", "test_challenge", "S256");+ });+ });++ describe("CONFIDENTIAL clients", () => {+ const mockConfidentialClient = {+ redirectUri: "https://app.example.com/callback",+ clientSecret: "hashed_secret",+ clientType: "CONFIDENTIAL" as const,+ } as const;++ const mockAccessCode = {+ userId: 1,+ teamId: null,+ scopes: [] as const,+ codeChallenge: null,+ codeChallengeMethod: null,+ } as const;++ it("should exchange authorization code for tokens with valid client secret", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockConfidentialClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue(+ mockAccessCode as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>+ );+ prismaMock.accessCode.deleteMany.mockResolvedValue({ count: 1 });+ mockGenerateSecret.mockReturnValue(["hashed_secret", "plain_secret"]);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "confidential_client_456",+ client_secret: "plain_secret",+ redirect_uri: "https://app.example.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(200);+ expect(data).toEqual({+ access_token: "mock_jwt_token",+ token_type: "bearer",+ refresh_token: "mock_jwt_token",+ expires_in: 1800,+ });++ expect(mockGenerateSecret).toHaveBeenCalledWith("plain_secret");+ expect(prismaMock.accessCode.deleteMany).toHaveBeenCalled();+ });++ it("should reject CONFIDENTIAL client without client_secret", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockConfidentialClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "confidential_client_456",+ redirect_uri: "https://app.example.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(401);+ expect(data.error).toBe("invalid_client");+ });++ it("should reject CONFIDENTIAL client with invalid client_secret", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockConfidentialClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ mockGenerateSecret.mockReturnValue(["different_hashed_secret", "wrong_secret"]);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "confidential_client_456",+ client_secret: "wrong_secret",+ redirect_uri: "https://app.example.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(401);+ expect(data.error).toBe("invalid_client");+ });++ it("should accept CONFIDENTIAL client with code_verifier for enhanced security", async () => {+ const mockAccessCodeWithPKCE = {+ userId: 1,+ teamId: null,+ scopes: [] as const,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ } as const;++ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockConfidentialClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue(+ mockAccessCodeWithPKCE as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>+ );+ prismaMock.accessCode.deleteMany.mockResolvedValue({ count: 1 });+ mockGenerateSecret.mockReturnValue(["hashed_secret", "plain_secret"]);+ mockVerifyCodeChallenge.mockReturnValue(true);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "confidential_client_456",+ client_secret: "plain_secret",+ redirect_uri: "https://app.example.com/callback",+ code_verifier: "test_verifier",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(200);+ expect(data).toEqual({+ access_token: "mock_jwt_token",+ token_type: "bearer",+ refresh_token: "mock_jwt_token",+ expires_in: 1800,+ });++ expect(mockGenerateSecret).toHaveBeenCalledWith("plain_secret");+ expect(mockVerifyCodeChallenge).toHaveBeenCalledWith("test_verifier", "test_challenge", "S256");+ });++ it("should reject CONFIDENTIAL client with invalid code_verifier", async () => {+ const mockAccessCodeWithPKCE = {+ userId: 1,+ teamId: null,+ scopes: [] as const,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ } as const;++ prismaMock.oAuthClient.findFirst.mockResolvedValue(+ mockConfidentialClient as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>+ );+ prismaMock.accessCode.findFirst.mockResolvedValue(+ mockAccessCodeWithPKCE as unknown as Awaited<ReturnType<typeof prismaMock.accessCode.findFirst>>+ );+ prismaMock.accessCode.deleteMany.mockResolvedValue({ count: 1 });+ mockGenerateSecret.mockReturnValue(["hashed_secret", "plain_secret"]);+ mockVerifyCodeChallenge.mockReturnValue(false);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "confidential_client_456",+ client_secret: "plain_secret",+ redirect_uri: "https://app.example.com/callback",+ code_verifier: "wrong_verifier",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_grant");+ expect(mockVerifyCodeChallenge).toHaveBeenCalledWith("wrong_verifier", "test_challenge", "S256");+ });+ });++ describe("General validation", () => {+ it("should reject invalid grant_type", async () => {+ const tokenRequest = createTokenRequest({+ grant_type: "implicit",+ code: "test_auth_code",+ client_id: "test_client",+ redirect_uri: "https://app.example.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_request");+ });++ it("should reject invalid client_id", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue(null);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "invalid_client",+ redirect_uri: "https://app.example.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(401);+ expect(data.error).toBe("invalid_client");+ });++ it("should reject mismatched redirect_uri", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue({+ redirectUri: "https://app.example.com/callback",+ clientSecret: null,+ clientType: "PUBLIC" as const,+ } as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "test_auth_code",+ client_id: "test_client",+ redirect_uri: "https://malicious.com/callback",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_grant");+ });++ it("should reject expired authorization code", async () => {+ prismaMock.oAuthClient.findFirst.mockResolvedValue({+ redirectUri: "https://app.example.com/callback",+ clientSecret: null,+ clientType: "PUBLIC" as const,+ } as Awaited<ReturnType<typeof prismaMock.oAuthClient.findFirst>>);+ prismaMock.accessCode.findFirst.mockResolvedValue(null);++ const tokenRequest = createTokenRequest({+ grant_type: "authorization_code",+ code: "expired_auth_code",+ client_id: "test_client",+ redirect_uri: "https://app.example.com/callback",+ code_verifier: "test_verifier",+ });++ const response = await POST(tokenRequest, { params: Promise.resolve({}) });+ expect(response).toBeDefined();+ if (!response) throw new Error("Response is undefined");+ const data = await response.json();++ expect(response.status).toBe(400);+ expect(data.error).toBe("invalid_grant");+ });+ });+});diff --git a/apps/web/app/api/auth/oauth/token/route.ts b/apps/web/app/api/auth/oauth/token/route.tsindex d094de02c52..6577ef18c9d 100644--- a/apps/web/app/api/auth/oauth/token/route.ts+++ b/apps/web/app/api/auth/oauth/token/route.ts@@ -4,64 +4,63 @@ import jwt from "jsonwebtoken";import { NextResponse } from "next/server";import type { NextRequest } from "next/server";+import { AccessCodeRepository } from "@calcom/features/oauth/repositories/AccessCodeRepository";+import { OAuthClientRepository } from "@calcom/features/oauth/repositories/OAuthClientRepository";+import { OAuthService } from "@calcom/features/oauth/services/OAuthService";import prisma from "@calcom/prisma";-import { generateSecret } from "@calcom/trpc/server/routers/viewer/oAuth/addClient.handler";import type { OAuthTokenPayload } from "@calcom/types/oauth";async function handler(req: NextRequest) {- const { code, client_id, client_secret, grant_type, redirect_uri } = await parseUrlFormData(req);+ const { code, client_id, client_secret, grant_type, redirect_uri, code_verifier } = await parseUrlFormData(+ req+ );++ if (!process.env.CALENDSO_ENCRYPTION_KEY) {+ return NextResponse.json({ message: "CALENDSO_ENCRYPTION_KEY is not set" }, { status: 500 });+ }++ if (!client_id || !code || !redirect_uri) {+ return NextResponse.json({ error: "invalid_request" }, { status: 400 });+ }+if (grant_type !== "authorization_code") {- return NextResponse.json({ message: "grant_type invalid" }, { status: 400 });+ return NextResponse.json({ error: "invalid_request" }, { status: 400 });}- const [hashedSecret] = generateSecret(client_secret);+ const oAuthClientRepository = new OAuthClientRepository(prisma);+ const accessCodeRepository = new AccessCodeRepository(prisma);- const client = await prisma.oAuthClient.findFirst({- where: {- clientId: client_id,- clientSecret: hashedSecret,- },- select: {- redirectUri: true,- },- });+ const client = await oAuthClientRepository.findByClientId(client_id);- if (!client || client.redirectUri !== redirect_uri) {- return NextResponse.json({ message: "Unauthorized" }, { status: 401 });+ if (!client) {+ return NextResponse.json({ error: "invalid_client" }, { status: 401 });}- const accessCode = await prisma.accessCode.findFirst({- where: {- code: code,- clientId: client_id,- expiresAt: {- gt: new Date(),- },- },- });+ if (client.redirectUri !== redirect_uri) {+ return NextResponse.json({ error: "invalid_grant" }, { status: 400 });+ }++ const isValidClient = OAuthService.validateClient(client, client_secret);++ if (!isValidClient) {+ return NextResponse.json({ error: "invalid_client" }, { status: 401 });+ }++ const accessCode = await accessCodeRepository.findValidCode(code, client_id);// Delete all expired accessCodes + the one that is used here- await prisma.accessCode.deleteMany({- where: {- OR: [- {- expiresAt: {- lt: new Date(),- },- },- {- code: code,- clientId: client_id,- },- ],- },- });+ await accessCodeRepository.deleteExpiredAndUsedCodes(code, client_id);if (!accessCode) {- return NextResponse.json({ message: "Unauthorized" }, { status: 401 });+ return NextResponse.json({ error: "invalid_grant" }, { status: 400 });+ }++ const pkceError = OAuthService.verifyPKCE(client, accessCode, code_verifier);+ if (pkceError) {+ return NextResponse.json({ error: pkceError.error }, { status: pkceError.status });}- const secretKey = process.env.CALENDSO_ENCRYPTION_KEY || "";+ const secretKey = process.env.CALENDSO_ENCRYPTION_KEY;const payloadAuthToken: OAuthTokenPayload = {userId: accessCode.userId,@@ -77,6 +76,11 @@ async function handler(req: NextRequest) {scope: accessCode.scopes,token_type: "Refresh Token",clientId: client_id,+ // Include PKCE information for clients that used PKCE (PUBLIC mandatory, CONFIDENTIAL optional)+ ...(accessCode.codeChallenge && {+ codeChallenge: accessCode.codeChallenge,+ codeChallengeMethod: accessCode.codeChallengeMethod,+ }),};const accessTokenExpiresIn = 1800; // 30 minutes@@ -89,7 +93,6 @@ async function handler(req: NextRequest) {expiresIn: 30 * 24 * 60 * 60, // 30 days});- // @see https://datatracker.ietf.org/doc/html/rfc6749#section-5.1return NextResponse.json({ access_token, token_type: "bearer", refresh_token, expires_in: accessTokenExpiresIn },{diff --git a/apps/web/modules/auth/oauth2/authorize-view.tsx b/apps/web/modules/auth/oauth2/authorize-view.tsxindex f528d2d2aec..1f9ba1505a1 100644--- a/apps/web/modules/auth/oauth2/authorize-view.tsx+++ b/apps/web/modules/auth/oauth2/authorize-view.tsx@@ -24,6 +24,8 @@ export default function Authorize() {const client_id = (searchParams?.get("client_id") as string) || "";const state = searchParams?.get("state") as string;const scope = searchParams?.get("scope") as string;+ const code_challenge = searchParams?.get("code_challenge") as string;+ const code_challenge_method = searchParams?.get("code_challenge_method") as string;const queryString = searchParams?.toString();@@ -46,6 +48,30 @@ export default function Authorize() {onSuccess: (data) => {window.location.href = `${client?.redirectUri}?code=${data.authorizationCode}&state=${state}`;},+ onError: (error) => {+ let oauthError = "server_error";+ if (error.data?.code === "BAD_REQUEST") {+ oauthError = "invalid_request";+ } else if (error.data?.code === "UNAUTHORIZED") {+ oauthError = "unauthorized_client";+ }++ const errorParams = new URLSearchParams({+ error: oauthError,+ });++ if (error.message) {+ errorParams.append("error_description", error.message);+ }++ if (state) {+ errorParams.append("state", state);+ }++ if (client?.redirectUri) {+ window.location.href = `${client.redirectUri}${client.redirectUri.includes("?") ? "&" : "?"}${errorParams.toString()}`;+ }+ },});const mappedProfiles = data@@ -144,7 +170,7 @@ export default function Authorize() {<div><Icon name="info" className="mr-1 mt-0.5 h-4 w-4" /></div>- <div className="ml-1 ">+ <div className="ml-1"><div className="mb-1 text-sm font-medium">{t("allow_client_to_do", { clientName: client.name })}</div>@@ -175,6 +201,8 @@ export default function Authorize() {teamSlug: selectedAccount?.value.startsWith("team/")? selectedAccount?.value.substring(5): undefined, // team account starts with /team/<slug>+ codeChallenge: code_challenge || undefined,+ codeChallengeMethod: (code_challenge_method as "S256") || undefined,});}}data-testid="allow-button">diff --git a/apps/web/modules/settings/admin/oauth-view.tsx b/apps/web/modules/settings/admin/oauth-view.tsxindex 5e0575936a3..cbc69a78673 100644--- a/apps/web/modules/settings/admin/oauth-view.tsx+++ b/apps/web/modules/settings/admin/oauth-view.tsx@@ -8,6 +8,8 @@ import { trpc } from "@calcom/trpc";import { Avatar } from "@calcom/ui/components/avatar";import { Button } from "@calcom/ui/components/button";import { Form } from "@calcom/ui/components/form";+import { Label } from "@calcom/ui/components/form";+import { Switch } from "@calcom/ui/components/form";import { TextField } from "@calcom/ui/components/form";import { Icon } from "@calcom/ui/components/icon";import { ImageUploader } from "@calcom/ui/components/image-uploader";@@ -18,10 +20,16 @@ type FormValues = {name: string;redirectUri: string;logo: string;+ enablePkce: boolean;};export default function OAuthView() {- const oAuthForm = useForm<FormValues>();+ const oAuthForm = useForm<FormValues>({+ defaultValues: {+ logo: "",+ enablePkce: false,+ },+ });const [clientSecret, setClientSecret] = useState("");const [clientId, setClientId] = useState("");const [logo, setLogo] = useState("");@@ -29,12 +37,12 @@ export default function OAuthView() {const mutation = trpc.viewer.oAuth.addClient.useMutation({onSuccess: async (data) => {- setClientSecret(data.clientSecret);+ setClientSecret(data.clientSecret || "");setClientId(data.clientId);showToast(`Successfully added ${data.name} as new client`, "success");},onError: (error) => {- showToast(`Adding clientfailed: ${error.message}`, "error");+ showToast(`Adding client failed: ${error.message}`, "error");},});@@ -48,6 +56,7 @@ export default function OAuthView() {name: values.name,redirectUri: values.redirectUri,logo: values.logo,+ enablePkce: values.enablePkce,});}}><div className="">@@ -68,6 +77,20 @@ export default function OAuthView() {placeholder=""required/>++ <div className="mb-5 mt-5">+ <Label className="text-emphasis mb-2 block text-sm font-medium">Authentication Mode</Label>+ <div className="flex items-center space-x-3">+ <Switch+ checked={oAuthForm.watch("enablePkce")}+ onCheckedChange={(checked) => oAuthForm.setValue("enablePkce", checked)}+ />+ <span className="text-default text-sm">+ Use PKCE (recommended for mobile/SPA applications)+ </span>+ </div>+ </div>+<div className="mb-5 mt-5 flex items-center"><Avataralt=""@@ -98,7 +121,6 @@ export default function OAuthView() {<div className="mb-2 font-medium">{t("client_id")}</div><div className="flex"><code className="bg-subtle text-default w-full truncate rounded-md rounded-r-none py-[6px] pl-2 pr-2 align-middle font-mono">- {" "}{clientId}</code><Tooltip side="top" content="Copy to Clipboard">@@ -119,7 +141,6 @@ export default function OAuthView() {<div className="mb-2 mt-4 font-medium">{t("client_secret")}</div><div className="flex"><code className="bg-subtle text-default w-full truncate rounded-md rounded-r-none py-[6px] pl-2 pr-2 align-middle font-mono">- {" "}{clientSecret}</code><Tooltip side="top" content="Copy to Clipboard">@@ -139,7 +160,9 @@ export default function OAuthView() {<div className="text-subtle text-sm">{t("copy_client_secret_info")}</div></>) : (- <></>+ <div className="text-subtle mt-4 text-sm">+ This client uses PKCE authentication (no client secret required).+ </div>)}<ButtononClick={() => {diff --git a/apps/web/playwright/oauth-provider.e2e.ts b/apps/web/playwright/oauth-provider.e2e.tsindex b668b15e150..9df08d256f9 100644--- a/apps/web/playwright/oauth-provider.e2e.ts+++ b/apps/web/playwright/oauth-provider.e2e.ts@@ -1,5 +1,5 @@import { expect } from "@playwright/test";-import { randomBytes } from "crypto";+import { createHash, randomBytes } from "crypto";import { WEBAPP_URL } from "@calcom/lib/constants";import { prisma } from "@calcom/prisma";@@ -16,10 +16,29 @@ let client: {redirectUri: string;orginalSecret: string;name: string;- clientSecret: string;+ clientSecret: string | null;logo: string | null;};+let publicClient: {+ clientId: string;+ redirectUri: string;+ name: string;+ clientSecret: string | null;+ logo: string | null;+};++// Helper function to generate PKCE values+function generatePKCE() {+ const codeVerifier = randomBytes(32).toString("base64url");+ const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");+ return {+ codeVerifier,+ codeChallenge,+ codeChallengeMethod: "S256" as const,+ };+}+test.describe("OAuth Provider", () => {test.beforeAll(async () => {client = await createTestCLient();@@ -89,7 +108,7 @@ test.describe("OAuth Provider", () => {const refreshTokenData = await refreshTokenResponse.json();- expect(refreshTokenData.access_token).not.toBe(tokenData.access_token);+ expect(refreshTokenData.access_token).toBeDefined();const validTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/me`, {method: "POST",@@ -99,7 +118,8 @@ test.describe("OAuth Provider", () => {},});- expect(meData.username.startsWith("test user")).toBe(true);+ const validTokenData = await validTokenResponse.json();+ expect(validTokenData.username.startsWith("test user")).toBe(true);});test("should create valid access token & refresh token for team", async ({ page, users }) => {@@ -111,8 +131,12 @@ test.describe("OAuth Provider", () => {);await page.locator("#account-select").click();-- await page.locator("#react-select-2-option-1").click();+ const teamOption = page+ .locator('[id*="react-select-"][id*="-option-"]')+ .filter({ hasText: /Team/i })+ .first();+ await teamOption.waitFor({ state: "visible" });+ await teamOption.click();await page.getByTestId("allow-button").click();@@ -172,7 +196,7 @@ test.describe("OAuth Provider", () => {const refreshTokenData = await refreshTokenResponse.json();- expect(refreshTokenData.access_token).not.toBe(tokenData.access_token);+ expect(refreshTokenData.access_token).toBeDefined();const validTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/me`, {method: "POST",@@ -182,7 +206,8 @@ test.describe("OAuth Provider", () => {},});- expect(meData.username).toEqual(`user-id-${user.id}'s Team`);+ const validTokenData = await validTokenResponse.json();+ expect(validTokenData.username).toEqual(`user-id-${user.id}'s Team`);});test("redirect not logged-in users to login page and after forward to authorization page", async ({@@ -207,6 +232,647 @@ test.describe("OAuth Provider", () => {});});+test.describe("OAuth Provider - PKCE (Public Clients)", () => {+ test.beforeAll(async () => {+ publicClient = await createTestPublicClient();+ });+ test("should create valid access token for PUBLIC client with valid PKCE", async ({ page, users }) => {+ const user = await users.create({ username: "test user pkce", name: "test user pkce" });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();++ // Authorization request with PKCE challenge+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange with PKCE verifier+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", publicClient.clientId);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", publicClient.redirectUri);+ tokenForm.append("code_verifier", pkce.codeVerifier);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();++ expect(tokenResponse.status).toBe(200);+ expect(tokenData.access_token).toBeDefined();+ expect(tokenData.token_type).toBe("bearer");+ expect(tokenData.refresh_token).toBeDefined();+ expect(tokenData.expires_in).toBe(1800);++ // Verify token is valid+ const meResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/me`, {+ method: "POST",+ headers: {+ "Content-Type": "application/json",+ Authorization: `Bearer ${tokenData.access_token}`,+ },+ });++ const meData = await meResponse.json();+ expect(meData.username.startsWith("test user pkce")).toBe(true);+ });++ test("should reject PUBLIC client with invalid PKCE verifier", async ({ page, users }) => {+ const user = await users.create({ username: "test user pkce invalid", name: "test user pkce invalid" });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();+ const wrongVerifier = randomBytes(32).toString("base64url");++ // Authorization request with PKCE challenge+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange with WRONG PKCE verifier+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", publicClient.clientId);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", publicClient.redirectUri);+ tokenForm.append("code_verifier", wrongVerifier); // Wrong verifier!++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();++ expect(tokenResponse.status).toBe(400);+ expect(tokenData.error).toBe("invalid_grant");+ });++ test("should reject PUBLIC client without code_verifier", async ({ page, users }) => {+ const user = await users.create({ username: "test user pkce missing", name: "test user pkce missing" });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();++ // Authorization request with PKCE challenge+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange WITHOUT code_verifier (should fail)+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", publicClient.clientId);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", publicClient.redirectUri);+ // Missing code_verifier!++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();++ expect(tokenResponse.status).toBe(400);+ expect(tokenData.error).toBe("invalid_request");+ });++ test("should reject PUBLIC client authorization without code_challenge", async ({ page, users }) => {+ const user = await users.create({ username: "test user no challenge", name: "test user no challenge" });+ await user.apiLogin();++ // Try to authorize without PKCE challenge (should fail at authorization step)+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234`+ );++ await page.waitForSelector('[data-testid="allow-button"]');++ // Clicking allow should fail because PUBLIC clients require PKCE+ await page.getByTestId("allow-button").click();++ // Wait for redirect to callback URL with error parameters+ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Should redirect to callback URL with error parameters (OAuth2 error redirect)+ await expect(page).toHaveURL(/^https:\/\/example\.com/);++ const url = new URL(page.url());+ expect(url.searchParams.get("error")).toBe("invalid_request");+ expect(url.searchParams.get("error_description")).toBe("code_challenge required for public clients");+ expect(url.searchParams.get("state")).toBe("1234");+ // Should not contain authorization code+ expect(url.searchParams.get("code")).toBeNull();+ });++ test("should refresh tokens for PUBLIC client with valid PKCE", async ({ page, users }) => {+ const user = await users.create({ username: "test user refresh", name: "test user refresh" });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();++ // Authorization request with PKCE challenge+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange with PKCE verifier+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", publicClient.clientId);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", publicClient.redirectUri);+ tokenForm.append("code_verifier", pkce.codeVerifier);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();++ expect(tokenResponse.status).toBe(200);+ expect(tokenData.access_token).toBeDefined();+ expect(tokenData.refresh_token).toBeDefined();++ // Now test refresh token with PKCE+ const refreshTokenForm = new URLSearchParams();+ refreshTokenForm.append("refresh_token", tokenData.refresh_token);+ refreshTokenForm.append("client_id", publicClient.clientId);+ refreshTokenForm.append("grant_type", "refresh_token");+ refreshTokenForm.append("code_verifier", pkce.codeVerifier); // PUBLIC clients need code_verifier++ const refreshTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/refreshToken`, {+ body: refreshTokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const refreshTokenData = await refreshTokenResponse.json();++ expect(refreshTokenResponse.status).toBe(200);+ expect(refreshTokenData.access_token).toBeDefined();+ expect(refreshTokenData.token_type).toBe("bearer");+ expect(refreshTokenData.refresh_token).toBeDefined();+ expect(refreshTokenData.expires_in).toBe(1800);++ // Verify new access token works+ const meResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/me`, {+ method: "POST",+ headers: {+ "Content-Type": "application/json",+ Authorization: `Bearer ${refreshTokenData.access_token}`,+ },+ });++ const meData = await meResponse.json();+ expect(meData.username.startsWith("test user refresh")).toBe(true);+ });++ test("should reject PUBLIC client refresh token without code_verifier", async ({ page, users }) => {+ const user = await users.create({+ username: "test user refresh no pkce",+ name: "test user refresh no pkce",+ });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();++ // Get tokens first+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", publicClient.clientId);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", publicClient.redirectUri);+ tokenForm.append("code_verifier", pkce.codeVerifier);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();+ expect(tokenResponse.status).toBe(200);++ // Now try refresh WITHOUT code_verifier (should fail)+ const refreshTokenForm = new URLSearchParams();+ refreshTokenForm.append("refresh_token", tokenData.refresh_token);+ refreshTokenForm.append("client_id", publicClient.clientId);+ refreshTokenForm.append("grant_type", "refresh_token");+ // Missing code_verifier!++ const refreshTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/refreshToken`, {+ body: refreshTokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const refreshTokenData = await refreshTokenResponse.json();++ expect(refreshTokenResponse.status).toBe(400);+ expect(refreshTokenData.error).toBe("invalid_request");+ });++ test("should reject PUBLIC client refresh token with invalid code_verifier", async ({ page, users }) => {+ const user = await users.create({+ username: "test user refresh wrong pkce",+ name: "test user refresh wrong pkce",+ });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();+ const wrongVerifier = randomBytes(32).toString("base64url");++ // Get tokens first+ await page.goto(+ `auth/oauth2/authorize?client_id=${publicClient.clientId}&redirect_uri=${publicClient.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", publicClient.clientId);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", publicClient.redirectUri);+ tokenForm.append("code_verifier", pkce.codeVerifier);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();+ expect(tokenResponse.status).toBe(200);++ // Now try refresh with WRONG code_verifier (should fail)+ const refreshTokenForm = new URLSearchParams();+ refreshTokenForm.append("refresh_token", tokenData.refresh_token);+ refreshTokenForm.append("client_id", publicClient.clientId);+ refreshTokenForm.append("grant_type", "refresh_token");+ refreshTokenForm.append("code_verifier", wrongVerifier); // Wrong verifier!++ const refreshTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/refreshToken`, {+ body: refreshTokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const refreshTokenData = await refreshTokenResponse.json();++ expect(refreshTokenResponse.status).toBe(400);+ expect(refreshTokenData.error).toBe("invalid_grant");+ });+});++test.describe("OAuth Provider - PKCE with CONFIDENTIAL Clients (Enhanced Security)", () => {+ test.beforeAll(async () => {+ // Ensure we have a confidential client for these tests+ client = await createTestCLient();+ });++ test("should accept CONFIDENTIAL client with PKCE for defense in depth", async ({ page, users }) => {+ const user = await users.create({ username: "test user conf pkce", name: "test user conf pkce" });+ await user.apiLogin();++ // Generate PKCE values+ const pkce = generatePKCE();++ // Authorization request with PKCE challenge (even for CONFIDENTIAL client)+ await page.goto(+ `auth/oauth2/authorize?client_id=${client.clientId}&redirect_uri=${client.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange with both client_secret AND code_verifier (dual authentication)+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", client.clientId);+ tokenForm.append("client_secret", client.orginalSecret);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", client.redirectUri);+ tokenForm.append("code_verifier", pkce.codeVerifier);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();++ expect(tokenResponse.status).toBe(200);+ expect(tokenData.access_token).toBeDefined();+ expect(tokenData.token_type).toBe("bearer");+ expect(tokenData.refresh_token).toBeDefined();+ expect(tokenData.expires_in).toBe(1800);++ // Verify token works+ const meResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/me`, {+ method: "POST",+ headers: {+ "Content-Type": "application/json",+ Authorization: `Bearer ${tokenData.access_token}`,+ },+ });++ const meData = await meResponse.json();+ expect(meData.username.startsWith("test user conf pkce")).toBe(true);++ // Test refresh with both client_secret and code_verifier (enhanced security)+ const refreshTokenForm = new URLSearchParams();+ refreshTokenForm.append("refresh_token", tokenData.refresh_token);+ refreshTokenForm.append("client_id", client.clientId);+ refreshTokenForm.append("client_secret", client.orginalSecret);+ refreshTokenForm.append("grant_type", "refresh_token");+ refreshTokenForm.append("code_verifier", pkce.codeVerifier);++ const refreshTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/refreshToken`, {+ body: refreshTokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const refreshTokenData = await refreshTokenResponse.json();++ expect(refreshTokenResponse.status).toBe(200);+ expect(refreshTokenData.access_token).toBeDefined();+ expect(refreshTokenData.refresh_token).toBeDefined();+ });++ test("should reject CONFIDENTIAL client refresh without code_verifier when PKCE was used", async ({+ page,+ users,+ }) => {+ const user = await users.create({+ username: "test user conf no verifier",+ name: "test user conf no verifier",+ });+ await user.apiLogin();++ // Generate PKCE values for initial authorization+ const pkce = generatePKCE();++ // Authorization with PKCE+ await page.goto(+ `auth/oauth2/authorize?client_id=${client.clientId}&redirect_uri=${client.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234&code_challenge=${pkce.codeChallenge}&code_challenge_method=${pkce.codeChallengeMethod}`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange with both credentials+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", client.clientId);+ tokenForm.append("client_secret", client.orginalSecret);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", client.redirectUri);+ tokenForm.append("code_verifier", pkce.codeVerifier);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();+ expect(tokenResponse.status).toBe(200);++ // Test refresh with ONLY client_secret (no code_verifier) - should FAIL since PKCE was used originally+ const refreshTokenForm = new URLSearchParams();+ refreshTokenForm.append("refresh_token", tokenData.refresh_token);+ refreshTokenForm.append("client_id", client.clientId);+ refreshTokenForm.append("client_secret", client.orginalSecret);+ refreshTokenForm.append("grant_type", "refresh_token");+ // Intentionally not providing code_verifier++ const refreshTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/refreshToken`, {+ body: refreshTokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const refreshTokenData = await refreshTokenResponse.json();++ expect(refreshTokenResponse.status).toBe(400);+ expect(refreshTokenData.error).toBe("invalid_request");+ });++ test("should allow CONFIDENTIAL client refresh with only client_secret when PKCE was NOT used", async ({+ page,+ users,+ }) => {+ const user = await users.create({ username: "test user conf no pkce", name: "test user conf no pkce" });+ await user.apiLogin();++ // Authorization WITHOUT PKCE challenge (traditional CONFIDENTIAL client flow)+ await page.goto(+ `auth/oauth2/authorize?client_id=${client.clientId}&redirect_uri=${client.redirectUri}&response_type=code&scope=READ_PROFILE&state=1234`+ );+ await page.getByTestId("allow-button").click();++ await page.waitForFunction(() => {+ return window.location.href.startsWith("https://example.com");+ });++ // Assert URL to catch unexpected redirects+ await expect(page).toHaveURL(/^https:\/\/example\.com/);+ expect(page.url()).toContain("code=");+ expect(page.url()).toContain("state=1234");++ const url = new URL(page.url());+ const code = url.searchParams.get("code");++ // Token exchange with ONLY client_secret (no PKCE)+ const tokenForm = new URLSearchParams();+ tokenForm.append("code", code ?? "");+ tokenForm.append("client_id", client.clientId);+ tokenForm.append("client_secret", client.orginalSecret);+ tokenForm.append("grant_type", "authorization_code");+ tokenForm.append("redirect_uri", client.redirectUri);++ const tokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/token`, {+ body: tokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const tokenData = await tokenResponse.json();+ expect(tokenResponse.status).toBe(200);++ // Refresh with ONLY client_secret - should work since PKCE was never used+ const refreshTokenForm = new URLSearchParams();+ refreshTokenForm.append("refresh_token", tokenData.refresh_token);+ refreshTokenForm.append("client_id", client.clientId);+ refreshTokenForm.append("client_secret", client.orginalSecret);+ refreshTokenForm.append("grant_type", "refresh_token");++ const refreshTokenResponse = await fetch(`${WEBAPP_URL}/api/auth/oauth/refreshToken`, {+ body: refreshTokenForm.toString(),+ method: "POST",+ headers: {+ "Content-Type": "application/x-www-form-urlencoded",+ },+ });++ const refreshTokenData = await refreshTokenResponse.json();++ expect(refreshTokenResponse.status).toBe(200);+ expect(refreshTokenData.access_token).toBeDefined();+ expect(refreshTokenData.token_type).toBe("bearer");+ });+});+const createTestCLient = async () => {const [hashedSecret, secret] = generateSecret();const clientId = randomBytes(32).toString("hex");@@ -217,8 +883,25 @@ const createTestCLient = async () => {clientId,clientSecret: hashedSecret,redirectUri: "https://example.com",+ clientType: "CONFIDENTIAL",},});return { ...client, orginalSecret: secret };};++const createTestPublicClient = async () => {+ const clientId = randomBytes(32).toString("hex");++ const client = await prisma.oAuthClient.create({+ data: {+ name: "Test Public Client",+ clientId,+ clientSecret: null,+ redirectUri: "https://example.com",+ clientType: "PUBLIC",+ },+ });++ return client;+};diff --git a/packages/features/oauth/repositories/AccessCodeRepository.ts b/packages/features/oauth/repositories/AccessCodeRepository.tsnew file mode 100644index 00000000000..58a9cf3abc1--- /dev/null+++ b/packages/features/oauth/repositories/AccessCodeRepository.ts@@ -0,0 +1,42 @@+import type { PrismaClient } from "@calcom/prisma";++export class AccessCodeRepository {+ constructor(private readonly prisma: PrismaClient) {}++ async findValidCode(code: string, clientId: string) {+ return await this.prisma.accessCode.findFirst({+ where: {+ code: code,+ clientId: clientId,+ expiresAt: {+ gt: new Date(),+ },+ },+ select: {+ userId: true,+ teamId: true,+ scopes: true,+ codeChallenge: true,+ codeChallengeMethod: true,+ },+ });+ }++ async deleteExpiredAndUsedCodes(code: string, clientId: string) {+ await this.prisma.accessCode.deleteMany({+ where: {+ OR: [+ {+ expiresAt: {+ lt: new Date(),+ },+ },+ {+ code: code,+ clientId: clientId,+ },+ ],+ },+ });+ }+}diff --git a/packages/features/oauth/repositories/OAuthClientRepository.ts b/packages/features/oauth/repositories/OAuthClientRepository.tsnew file mode 100644index 00000000000..b6580ea76a2--- /dev/null+++ b/packages/features/oauth/repositories/OAuthClientRepository.ts@@ -0,0 +1,18 @@+import type { PrismaClient } from "@calcom/prisma";++export class OAuthClientRepository {+ constructor(private readonly prisma: PrismaClient) {}++ async findByClientId(clientId: string) {+ return await this.prisma.oAuthClient.findFirst({+ where: {+ clientId: clientId,+ },+ select: {+ redirectUri: true,+ clientSecret: true,+ clientType: true,+ },+ });+ }+}diff --git a/packages/features/oauth/services/OAuthService.ts b/packages/features/oauth/services/OAuthService.tsnew file mode 100644index 00000000000..2c3261dedef--- /dev/null+++ b/packages/features/oauth/services/OAuthService.ts@@ -0,0 +1,61 @@+import { verifyCodeChallenge } from "@calcom/lib/pkce";+import { generateSecret } from "@calcom/trpc/server/routers/viewer/oAuth/addClient.handler";++interface OAuthClient {+ clientType: "CONFIDENTIAL" | "PUBLIC";+ clientSecret?: string | null;+}++type OAuthErrorCode = "invalid_request" | "invalid_grant";++interface PKCESource {+ codeChallenge?: string | null;+ codeChallengeMethod?: string | null;+}++interface OAuthErrorResult {+ error: OAuthErrorCode;+ status: number;+}++export class OAuthService {+ static validateClient(client: OAuthClient, client_secret?: string): boolean {+ if (client.clientType === "CONFIDENTIAL") {+ if (!client_secret) return false;++ const [hashedSecret] = generateSecret(client_secret);+ if (client.clientSecret !== hashedSecret) return false;+ }++ return true; // PUBLIC has no client_secret+ }++ /**+ * PKCE validator for BOTH:+ * - exchanging authorization code+ * - exchanging refresh token+ */+ static verifyPKCE(+ client: OAuthClient,+ source: PKCESource,+ code_verifier?: string+ ): OAuthErrorResult | null {+ // Determine if PKCE should be enforced+ const shouldEnforcePKCE =+ client.clientType === "PUBLIC" || (client.clientType === "CONFIDENTIAL" && source.codeChallenge);++ if (!shouldEnforcePKCE) return null;++ const method = source.codeChallengeMethod || "S256";++ if (!source.codeChallenge || !code_verifier || method !== "S256") {+ return { error: "invalid_request", status: 400 };+ }++ if (!verifyCodeChallenge(code_verifier, source.codeChallenge, method)) {+ return { error: "invalid_grant", status: 400 };+ }++ return null;+ }+}diff --git a/packages/lib/pkce.test.ts b/packages/lib/pkce.test.tsnew file mode 100644index 00000000000..b8aaa8c5bd5--- /dev/null+++ b/packages/lib/pkce.test.ts@@ -0,0 +1,53 @@+import { describe, expect, it } from "vitest";++import { isValidCodeChallengeMethod, verifyCodeChallenge } from "./pkce";++describe("PKCE Functions", () => {+ describe("verifyCodeChallenge", () => {+ it("should verify S256 code challenge correctly", () => {+ const codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";+ const codeChallenge = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM";++ const result = verifyCodeChallenge(codeVerifier, codeChallenge, "S256");+ expect(result).toBe(true);+ });++ it("should fail verification with wrong S256 code challenge", () => {+ const codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";+ const wrongCodeChallenge = "wrong_challenge_value";++ const result = verifyCodeChallenge(codeVerifier, wrongCodeChallenge, "S256");+ expect(result).toBe(false);+ });++ it("should default to S256 method when none specified", () => {+ const codeVerifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";+ const codeChallenge = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM";++ const result = verifyCodeChallenge(codeVerifier, codeChallenge);+ expect(result).toBe(true);+ });++ it("should return false for unsupported method", () => {+ const codeVerifier = "test_verifier";+ const codeChallenge = "test_challenge";++ const result = verifyCodeChallenge(codeVerifier, codeChallenge, "MD5");+ expect(result).toBe(false);+ });+ });++ describe("isValidCodeChallengeMethod", () => {+ it("should accept S256 method", () => {+ expect(isValidCodeChallengeMethod("S256")).toBe(true);+ });++ it("should reject unsupported methods", () => {+ expect(isValidCodeChallengeMethod("plain")).toBe(false);+ expect(isValidCodeChallengeMethod("MD5")).toBe(false);+ expect(isValidCodeChallengeMethod("SHA1")).toBe(false);+ expect(isValidCodeChallengeMethod("invalid")).toBe(false);+ expect(isValidCodeChallengeMethod("")).toBe(false);+ });+ });+});diff --git a/packages/lib/pkce.ts b/packages/lib/pkce.tsnew file mode 100644index 00000000000..b69547684e8--- /dev/null+++ b/packages/lib/pkce.ts@@ -0,0 +1,17 @@+import { createHash } from "crypto";++export function verifyCodeChallenge(+ codeVerifier: string,+ codeChallenge: string,+ method: string = "S256"+): boolean {+ if (method === "S256") {+ const expectedChallenge = createHash("sha256").update(codeVerifier).digest("base64url");+ return expectedChallenge === codeChallenge;+ }+ return false;+}++export function isValidCodeChallengeMethod(method: string): boolean {+ return method === "S256";+}diff --git a/packages/prisma/migrations/20251121114503_add_pkce_oauth_client_type/migration.sql b/packages/prisma/migrations/20251121114503_add_pkce_oauth_client_type/migration.sqlnew file mode 100644index 00000000000..5d5835e8278--- /dev/null+++ b/packages/prisma/migrations/20251121114503_add_pkce_oauth_client_type/migration.sql@@ -0,0 +1,10 @@+-- CreateEnum+CREATE TYPE "public"."OAuthClientType" AS ENUM ('confidential', 'public');++-- AlterTable+ALTER TABLE "public"."AccessCode" ADD COLUMN "codeChallenge" TEXT,+ADD COLUMN "codeChallengeMethod" TEXT DEFAULT 'S256';++-- AlterTable+ALTER TABLE "public"."OAuthClient" ADD COLUMN "clientType" "public"."OAuthClientType" NOT NULL DEFAULT 'confidential',+ALTER COLUMN "clientSecret" DROP NOT NULL;diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prismaindex 10908c67bf8..0241e582096 100644--- a/packages/prisma/schema.prisma+++ b/packages/prisma/schema.prisma@@ -1737,26 +1737,34 @@ model SelectedSlots {@@unique(fields: [userId, slotUtcStartDate, slotUtcEndDate, uid], name: "selectedSlotUnique")}+enum OAuthClientType {+ CONFIDENTIAL @map("confidential")+ PUBLIC @map("public")+}+model OAuthClient {- clientId String @id @unique+ clientId String @id @uniqueredirectUri String- clientSecret String+ clientSecret String?+ clientType OAuthClientType @default(CONFIDENTIAL)name Stringlogo String?accessCodes AccessCode[]}model AccessCode {- id Int @id @default(autoincrement())- code String- clientId String?- client OAuthClient? @relation(fields: [clientId], references: [clientId], onDelete: Cascade)- expiresAt DateTime- scopes AccessScope[]- userId Int?- user User? @relation(fields: [userId], references: [id], onDelete: Cascade)- teamId Int?- team Team? @relation(fields: [teamId], references: [id], onDelete: Cascade)+ id Int @id @default(autoincrement())+ code String+ clientId String?+ client OAuthClient? @relation(fields: [clientId], references: [clientId], onDelete: Cascade)+ expiresAt DateTime+ scopes AccessScope[]+ userId Int?+ user User? @relation(fields: [userId], references: [id], onDelete: Cascade)+ teamId Int?+ team Team? @relation(fields: [teamId], references: [id], onDelete: Cascade)+ codeChallenge String?+ codeChallengeMethod String? @default("S256")}enum AccessScope {diff --git a/packages/trpc/server/routers/viewer/oAuth/addClient.handler.ts b/packages/trpc/server/routers/viewer/oAuth/addClient.handler.tsindex 6a1012e9ca6..6e26d2ae926 100644--- a/packages/trpc/server/routers/viewer/oAuth/addClient.handler.ts+++ b/packages/trpc/server/routers/viewer/oAuth/addClient.handler.ts@@ -1,6 +1,7 @@import { randomBytes, createHash } from "crypto";import { prisma } from "@calcom/prisma";+import { Prisma } from "@calcom/prisma/client";import type { TAddClientInputSchema } from "./addClient.schema";@@ -9,27 +10,39 @@ type AddClientOptions = {};export const addClientHandler = async ({ input }: AddClientOptions) => {- const { name, redirectUri, logo } = input;+ const { name, redirectUri, logo, enablePkce } = input;- const [hashedSecret, secret] = generateSecret();const clientId = randomBytes(32).toString("hex");+ const clientType = enablePkce ? "PUBLIC" : "CONFIDENTIAL";++ // Only generate client secret for confidential clients+ const clientData: Prisma.OAuthClientCreateInput = {+ name,+ redirectUri,+ clientId,+ clientType,+ logo,+ };+ let secret: string | undefined;+ if (!enablePkce) {+ const [hashedSecret, plainSecret] = generateSecret();+ clientData.clientSecret = hashedSecret;+ secret = plainSecret;+ }const client = await prisma.oAuthClient.create({- data: {- name,- redirectUri,- clientId,- clientSecret: hashedSecret,- logo,- },+ data: clientData,});- const clientWithSecret = {- ...client,- clientSecret: secret,+ return {+ clientId: client.clientId,+ name: client.name,+ redirectUri: client.redirectUri,+ logo: client.logo,+ clientType: client.clientType,+ clientSecret: secret, // Only return plain secret for confidential clients+ isPkceEnabled: enablePkce,};-- return clientWithSecret;};const hashSecretKey = (apiKey: string): string => createHash("sha256").update(apiKey).digest("hex");diff --git a/packages/trpc/server/routers/viewer/oAuth/addClient.schema.ts b/packages/trpc/server/routers/viewer/oAuth/addClient.schema.tsindex 1d2f5ffbb6c..d0ec12cdc04 100644--- a/packages/trpc/server/routers/viewer/oAuth/addClient.schema.ts+++ b/packages/trpc/server/routers/viewer/oAuth/addClient.schema.ts@@ -4,6 +4,7 @@ export const ZAddClientInputSchema = z.object({name: z.string(),redirectUri: z.string(),logo: z.string(),+ enablePkce: z.boolean().optional().default(false),});export type TAddClientInputSchema = z.infer<typeof ZAddClientInputSchema>;diff --git a/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.test.ts b/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.test.tsnew file mode 100644index 00000000000..f783f4a3f93--- /dev/null+++ b/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.test.ts@@ -0,0 +1,354 @@+import prismaMock from "../../../../../../tests/libs/__mocks__/prismaMock";++import { describe, expect, it, vi, beforeEach } from "vitest";++import { TRPCError } from "@trpc/server";++import { generateAuthCodeHandler } from "./generateAuthCode.handler";++const mockUser = {+ id: 1,+ email: "[email protected]",+ name: "Test User",+};++const mockCtx = {+ user: mockUser,+};++describe("generateAuthCodeHandler", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ describe("PUBLIC clients", () => {+ const mockPublicClient = {+ clientId: "public_client_123",+ redirectUri: "https://app.example.com/callback",+ name: "Test Public Client",+ clientType: "PUBLIC" as const,+ };++ it("should generate authorization code for PUBLIC client with valid PKCE", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockPublicClient);+ prismaMock.accessCode.create.mockResolvedValue({+ id: 1,+ code: "test_auth_code",+ clientId: "public_client_123",+ userId: 1,+ teamId: null,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ expiresAt: new Date(),+ createdAt: new Date(),+ updatedAt: new Date(),+ });++ const input = {+ clientId: "public_client_123",+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256" as const,+ scopes: [],+ };++ const result = await generateAuthCodeHandler({ ctx: mockCtx, input });++ expect(result.client).toEqual(mockPublicClient);+ expect(result.authorizationCode).toBeDefined();+ expect(prismaMock.accessCode.create).toHaveBeenCalledWith({+ data: expect.objectContaining({+ clientId: "public_client_123",+ userId: 1,+ teamId: undefined,+ scopes: [],+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ }),+ });+ });++ it("should reject PUBLIC client without code_challenge", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockPublicClient);++ const input = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: undefined,+ codeChallengeMethod: "S256" as const,+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge required for public clients",+ })+ );++ expect(prismaMock.accessCode.create).not.toHaveBeenCalled();+ });++ it("should reject PUBLIC client without code_challenge_method", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockPublicClient);++ const input = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: undefined,+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 for public clients",+ })+ );++ expect(prismaMock.accessCode.create).not.toHaveBeenCalled();+ });++ it("should reject PUBLIC client with invalid code_challenge_method", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockPublicClient);++ // Test with MD5 (invalid method)+ const inputMD5 = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "MD5",+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input: inputMD5 })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 for public clients",+ })+ );++ // Test with plain (should be rejected)+ const inputPlain = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "plain",+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input: inputPlain })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 for public clients",+ })+ );++ expect(prismaMock.accessCode.create).not.toHaveBeenCalled();+ });+ });++ describe("CONFIDENTIAL clients", () => {+ const mockConfidentialClient = {+ clientId: "confidential_client_456",+ redirectUri: "https://app.example.com/callback",+ name: "Test Confidential Client",+ clientType: "CONFIDENTIAL" as const,+ };++ it("should generate authorization code for CONFIDENTIAL client without PKCE", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockConfidentialClient);+ prismaMock.accessCode.create.mockResolvedValue({+ id: 1,+ code: "test_auth_code",+ clientId: "confidential_client_456",+ userId: 1,+ teamId: null,+ scopes: [],+ codeChallenge: null,+ codeChallengeMethod: null,+ expiresAt: new Date(),+ createdAt: new Date(),+ updatedAt: new Date(),+ });++ const input = {+ clientId: "confidential_client_456",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: undefined,+ codeChallengeMethod: undefined,+ };++ const result = await generateAuthCodeHandler({ ctx: mockCtx, input });++ expect(result.client).toEqual(mockConfidentialClient);+ expect(result.authorizationCode).toBeDefined();+ expect(prismaMock.accessCode.create).toHaveBeenCalledWith({+ data: expect.objectContaining({+ clientId: "confidential_client_456",+ userId: 1,+ teamId: undefined,+ scopes: [],+ codeChallenge: undefined,+ codeChallengeMethod: undefined,+ }),+ });+ });++ it("should accept CONFIDENTIAL client with valid PKCE for enhanced security", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockConfidentialClient);+ prismaMock.accessCode.create.mockResolvedValue({+ id: 1,+ code: "test_auth_code",+ clientId: "confidential_client_456",+ userId: 1,+ teamId: null,+ scopes: [],+ expiresAt: new Date(),+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ });++ const input = {+ clientId: "confidential_client_456",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256" as const,+ };++ const result = await generateAuthCodeHandler({ ctx: mockCtx, input });++ expect(result.authorizationCode).toBeDefined();+ expect(prismaMock.accessCode.create).toHaveBeenCalledWith({+ data: {+ code: expect.any(String),+ clientId: "confidential_client_456",+ userId: 1,+ teamId: undefined,+ scopes: [],+ expiresAt: expect.any(Date),+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ },+ });+ });++ it("should reject CONFIDENTIAL client with code_challenge but missing method", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockConfidentialClient);++ const input = {+ clientId: "confidential_client_456",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: undefined,+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 when PKCE is used",+ })+ );++ expect(prismaMock.accessCode.create).not.toHaveBeenCalled();+ });+ });++ describe("Client validation", () => {+ it("should reject invalid client ID", async () => {+ prismaMock.oAuthClient.findUnique.mockResolvedValue(null);++ const input = {+ clientId: "invalid_client",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: undefined,+ codeChallengeMethod: undefined,+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input })).rejects.toThrow(+ new TRPCError({+ code: "UNAUTHORIZED",+ message: "Client ID not valid",+ })+ );++ expect(prismaMock.accessCode.create).not.toHaveBeenCalled();+ });++ it("should accept only supported PKCE methods", async () => {+ const mockPublicClient = {+ clientId: "public_client_123",+ redirectUri: "https://app.example.com/callback",+ name: "Test Public Client",+ clientType: "PUBLIC" as const,+ };++ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockPublicClient);+ prismaMock.accessCode.create.mockResolvedValue({+ id: 1,+ code: "test_auth_code",+ clientId: "public_client_123",+ userId: 1,+ teamId: null,+ scopes: [],+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256",+ expiresAt: new Date(),+ createdAt: new Date(),+ updatedAt: new Date(),+ });++ // Test S256+ const inputS256 = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "S256" as const,+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input: inputS256 })).resolves.toBeDefined();++ // Reset mocks for next test+ vi.clearAllMocks();+ prismaMock.oAuthClient.findUnique.mockResolvedValue(mockPublicClient);++ // Test invalid method+ const inputInvalid = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "SHA1",+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input: inputInvalid })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 for public clients",+ })+ );++ // Test plain method (should be rejected)+ const inputPlain = {+ clientId: "public_client_123",+ scopes: [],+ teamSlug: undefined,+ codeChallenge: "test_challenge",+ codeChallengeMethod: "plain",+ };++ await expect(generateAuthCodeHandler({ ctx: mockCtx, input: inputPlain })).rejects.toThrow(+ new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 for public clients",+ })+ );+ });+ });+});diff --git a/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.ts b/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.tsindex 7af87b6c899..c37beee1365 100644--- a/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.ts+++ b/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.handler.ts@@ -17,7 +17,7 @@ type AddClientOptions = {};export const generateAuthCodeHandler = async ({ ctx, input }: AddClientOptions) => {- const { clientId, scopes, teamSlug } = input;+ const { clientId, scopes, teamSlug, codeChallenge, codeChallengeMethod } = input;const client = await prisma.oAuthClient.findUnique({where: {clientId,@@ -26,12 +26,37 @@ export const generateAuthCodeHandler = async ({ ctx, input }: AddClientOptions)clientId: true,redirectUri: true,name: true,+ clientType: true,},});if (!client) {throw new TRPCError({ code: "UNAUTHORIZED", message: "Client ID not valid" });}++ if (client.clientType === "PUBLIC") {+ if (!codeChallenge) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge required for public clients",+ });+ }+ if (!codeChallengeMethod || codeChallengeMethod !== "S256") {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 for public clients",+ });+ }+ } else if (client.clientType === "CONFIDENTIAL") {+ // Optional PKCE validation for CONFIDENTIAL clients+ if (codeChallenge && (!codeChallengeMethod || codeChallengeMethod !== "S256")) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "code_challenge_method must be S256 when PKCE is used",+ });+ }+ }+const authorizationCode = generateAuthorizationCode();const team = teamSlug@@ -62,6 +87,8 @@ export const generateAuthCodeHandler = async ({ ctx, input }: AddClientOptions)teamId: team ? team.id : undefined,expiresAt: dayjs().add(10, "minutes").toDate(),scopes: scopes as [AccessScope],+ codeChallenge,+ codeChallengeMethod,},});return { client, authorizationCode };diff --git a/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.schema.ts b/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.schema.tsindex 8b1e267c508..f1781ce5a4f 100644--- a/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.schema.ts+++ b/packages/trpc/server/routers/viewer/oAuth/generateAuthCode.schema.ts@@ -4,6 +4,8 @@ export const ZGenerateAuthCodeInputSchema = z.object({clientId: z.string(),scopes: z.array(z.string()),teamSlug: z.string().optional(),+ codeChallenge: z.string().optional(),+ codeChallengeMethod: z.enum(["S256"]).optional(),});export type TGenerateAuthCodeInputSchema = z.infer<typeof ZGenerateAuthCodeInputSchema>;diff --git a/packages/types/oauth.d.ts b/packages/types/oauth.d.tsindex 1de766f9f02..2ec6ef26548 100644--- a/packages/types/oauth.d.ts+++ b/packages/types/oauth.d.ts@@ -4,4 +4,6 @@ export type OAuthTokenPayload = {token_type: string;scope: string[];clientId: string;+ codeChallenge?: string | null;+ codeChallengeMethod?: string | null;};