Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

10.8 KB
Raw Blame
import { Keyv } from 'keyv';

jest.mock(
  '@librechat/data-schemas',
  () => ({
    logger: {
      info: jest.fn(),
      warn: jest.fn(),
      error: jest.fn(),
    },
  }),
  { virtual: true },
);

import { stripCodeChallenge, storeAndStripChallenge, preserveAdminOAuthState } from './exchange';
import type { PkceStrippableRequest, PkceSupportMetadata } from './exchange';

function makeReq(overrides: Partial<PkceStrippableRequest> = {}): PkceStrippableRequest {
  return { query: {}, originalUrl: '', url: '', ...overrides };
}

describe('stripCodeChallenge', () => {
  const challenge = 'a'.repeat(64);
  const callbackUrl = 'https://admin.example.com/auth/openid/callback';
  const encodedCallbackUrl = 'https%3A%2F%2Fadmin.example.com%2Fauth%2Fopenid%2Fcallback';

  it('removes code_challenge from req.query and both URL strings (sole param)', () => {
    const req = makeReq({
      query: { code_challenge: challenge },
      originalUrl: `/api/admin/oauth/openid?code_challenge=${challenge}`,
      url: `/oauth/openid?code_challenge=${challenge}`,
    });

    stripCodeChallenge(req);

    expect(req.query.code_challenge).toBeUndefined();
    expect(req.originalUrl).toBe('/api/admin/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });

  it('removes admin-panel-only params before the request reaches Passport', () => {
    const originalUrl =
      `/api/admin/oauth/openid?code_challenge=${challenge}` +
      `&redirect_uri=${encodedCallbackUrl}&redirectTo=%2Fsettings&foo=bar`;
    const url =
      `/oauth/openid?code_challenge=${challenge}` +
      `&redirect_uri=${encodedCallbackUrl}&redirectTo=%2Fsettings&foo=bar`;
    const req = makeReq({
      query: {
        code_challenge: challenge,
        redirect_uri: callbackUrl,
        redirectTo: '/settings',
        foo: 'bar',
      },
      originalUrl,
      url,
    });

    stripCodeChallenge(req);

    expect(req.query.code_challenge).toBeUndefined();
    expect(req.query.redirect_uri).toBeUndefined();
    expect(req.query.redirectTo).toBeUndefined();
    expect(req.query.foo).toBe('bar');
    expect(req.originalUrl).toBe('/api/admin/oauth/openid?foo=bar');
    expect(req.url).toBe('/oauth/openid?foo=bar');
  });

  it('removes redirect_uri when it is the only admin-panel-only param', () => {
    const req = makeReq({
      query: { redirect_uri: callbackUrl },
      originalUrl: `/oauth/openid?redirect_uri=${encodedCallbackUrl}`,
      url: `/oauth/openid?redirect_uri=${encodedCallbackUrl}`,
    });

    stripCodeChallenge(req);

    expect(req.query.redirect_uri).toBeUndefined();
    expect(req.originalUrl).toBe('/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });

  it('preserves other params when code_challenge is last', () => {
    const req = makeReq({
      query: { foo: 'bar', code_challenge: challenge },
      originalUrl: `/oauth/openid?foo=bar&code_challenge=${challenge}`,
      url: `/oauth/openid?foo=bar&code_challenge=${challenge}`,
    });

    stripCodeChallenge(req);

    expect(req.query.code_challenge).toBeUndefined();
    expect(req.query.foo).toBe('bar');
    expect(req.originalUrl).toBe('/oauth/openid?foo=bar');
    expect(req.url).toBe('/oauth/openid?foo=bar');
  });

  it('preserves other params when code_challenge is first of multiple', () => {
    const req = makeReq({
      query: { code_challenge: challenge, foo: 'bar' },
      originalUrl: `/oauth/openid?code_challenge=${challenge}&foo=bar`,
      url: `/oauth/openid?code_challenge=${challenge}&foo=bar`,
    });

    stripCodeChallenge(req);

    expect(req.query.code_challenge).toBeUndefined();
    expect(req.originalUrl).toBe('/oauth/openid?foo=bar');
    expect(req.url).toBe('/oauth/openid?foo=bar');
  });

  it('preserves other params when code_challenge is in the middle', () => {
    const req = makeReq({
      query: { a: '1', code_challenge: challenge, b: '2' },
      originalUrl: `/oauth/openid?a=1&code_challenge=${challenge}&b=2`,
      url: `/oauth/openid?a=1&code_challenge=${challenge}&b=2`,
    });

    stripCodeChallenge(req);

    expect(req.query.code_challenge).toBeUndefined();
    expect(req.originalUrl).toBe('/oauth/openid?a=1&b=2');
    expect(req.url).toBe('/oauth/openid?a=1&b=2');
  });

  it('handles empty code_challenge= value', () => {
    const req = makeReq({
      query: { code_challenge: '' },
      originalUrl: '/oauth/openid?code_challenge=',
      url: '/oauth/openid?code_challenge=',
    });

    stripCodeChallenge(req);

    expect(req.query.code_challenge).toBeUndefined();
    expect(req.originalUrl).toBe('/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });

  it('is a no-op when no code_challenge is present', () => {
    const req = makeReq({
      query: { foo: 'bar' },
      originalUrl: '/oauth/openid?foo=bar',
      url: '/oauth/openid?foo=bar',
    });

    stripCodeChallenge(req);

    expect(req.query.foo).toBe('bar');
    expect(req.originalUrl).toBe('/oauth/openid?foo=bar');
    expect(req.url).toBe('/oauth/openid?foo=bar');
  });

  it('is a no-op on a bare path with no query string', () => {
    const req = makeReq({
      query: {},
      originalUrl: '/oauth/openid',
      url: '/oauth/openid',
    });

    stripCodeChallenge(req);

    expect(req.originalUrl).toBe('/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });
});

describe('storeAndStripChallenge', () => {
  const challenge = 'a'.repeat(64);
  const callbackUrl = 'https://admin.example.com/auth/openid/callback';
  const encodedCallbackUrl = 'https%3A%2F%2Fadmin.example.com%2Fauth%2Fopenid%2Fcallback';

  it('stores valid challenge in cache and strips from request', async () => {
    const cache = new Keyv();
    const setSpy = jest.spyOn(cache, 'set');
    const url = `/oauth/openid?code_challenge=${challenge}&redirect_uri=${encodedCallbackUrl}`;
    const req = makeReq({
      query: {
        code_challenge: challenge,
        redirect_uri: callbackUrl,
      },
      originalUrl: url,
      url,
    });

    const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');

    expect(result).toBe(true);
    expect(setSpy).toHaveBeenCalledWith(`pkce:test-state`, challenge, expect.any(Number));
    expect(req.query.code_challenge).toBeUndefined();
    expect(req.query.redirect_uri).toBeUndefined();
    expect(req.originalUrl).toBe('/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });

  it('strips and returns true when no code_challenge is present', async () => {
    const cache = new Keyv();
    const setSpy = jest.spyOn(cache, 'set');
    const req = makeReq({
      query: {},
      originalUrl: '/oauth/openid',
      url: '/oauth/openid',
    });

    const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');

    expect(result).toBe(true);
    expect(setSpy).not.toHaveBeenCalled();
    expect(req.originalUrl).toBe('/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });

  it('strips and returns true when code_challenge is invalid (not 64 hex)', async () => {
    const cache = new Keyv();
    const setSpy = jest.spyOn(cache, 'set');
    const url = `/oauth/openid?code_challenge=too-short&redirect_uri=${encodedCallbackUrl}`;
    const req = makeReq({
      query: {
        code_challenge: 'too-short',
        redirect_uri: callbackUrl,
      },
      originalUrl: url,
      url,
    });

    const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');

    expect(result).toBe(true);
    expect(setSpy).not.toHaveBeenCalled();
    expect(req.query.code_challenge).toBeUndefined();
    expect(req.query.redirect_uri).toBeUndefined();
    expect(req.originalUrl).toBe('/oauth/openid');
    expect(req.url).toBe('/oauth/openid');
  });

  it('returns false and does not strip on cache failure', async () => {
    const cache = new Keyv();
    jest.spyOn(cache, 'set').mockRejectedValueOnce(new Error('cache down'));
    const url = `/oauth/openid?code_challenge=${challenge}&redirect_uri=${encodedCallbackUrl}`;
    const req = makeReq({
      query: {
        code_challenge: challenge,
        redirect_uri: callbackUrl,
      },
      originalUrl: url,
      url,
    });

    const result = await storeAndStripChallenge(cache, req, 'test-state', 'openid');

    expect(result).toBe(false);
    expect(req.query.code_challenge).toBe(challenge);
    expect(req.query.redirect_uri).toBe(callbackUrl);
    expect(req.originalUrl).toBe(url);
    expect(req.url).toBe(url);
  });

  it('reads code_challenge before stripping (ordering guarantee)', async () => {
    const cache = new Keyv();
    const setSpy = jest.spyOn(cache, 'set');
    const req = makeReq({
      query: { code_challenge: challenge },
      originalUrl: `/oauth/openid?code_challenge=${challenge}`,
      url: `/oauth/openid?code_challenge=${challenge}`,
    });

    await storeAndStripChallenge(cache, req, 'test-state', 'openid');

    const storedValue = setSpy.mock.calls[0][1];
    expect(storedValue).toBe(challenge);
  });
});

describe('preserveAdminOAuthState', () => {
  const state = 'b'.repeat(64);

  /** Mirrors openid-client's `serverMetadata().supportsPKCE`, which defaults to S256. */
  const metadataWith = (methods?: string[]): PkceSupportMetadata => ({
    supportsPKCE: (method = 'S256') => methods?.includes(method) === true,
  });

  it('adds a nonce when the IdP does not advertise PKCE, so the admin state is kept', () => {
    const params = new URLSearchParams({ scope: 'openid', state });

    const result = preserveAdminOAuthState(params, metadataWith());

    expect(result).toBe(params);
    expect(params.get('state')).toBe(state);
    expect(params.get('nonce')).toMatch(/^[A-Za-z0-9_-]{43}$/);
  });

  it('adds a nonce when the IdP advertises only the plain method', () => {
    const params = new URLSearchParams({ state });

    preserveAdminOAuthState(params, metadataWith(['plain']));

    expect(params.has('nonce')).toBe(true);
  });

  it('generates a fresh nonce for each request', () => {
    const first = preserveAdminOAuthState(new URLSearchParams({ state }), metadataWith());
    const second = preserveAdminOAuthState(new URLSearchParams({ state }), metadataWith());

    expect(first.get('nonce')).not.toBe(second.get('nonce'));
  });

  it('leaves the request alone when the IdP advertises S256', () => {
    const params = new URLSearchParams({ scope: 'openid', state });

    preserveAdminOAuthState(params, metadataWith(['plain', 'S256']));

    expect(params.has('nonce')).toBe(false);
    expect(params.get('state')).toBe(state);
  });

  it('keeps a nonce the request already carries', () => {
    const params = new URLSearchParams({ state, nonce: 'configured-nonce' });

    preserveAdminOAuthState(params, metadataWith());

    expect(params.get('nonce')).toBe('configured-nonce');
  });

  it('adds nothing when the request has no state to keep', () => {
    const params = new URLSearchParams({ scope: 'openid' });

    preserveAdminOAuthState(params, metadataWith());

    expect(params.has('nonce')).toBe(false);
  });
});