📈 Open source, privacy-first web analytics — a cookie-less Google Analytics alternative with built-in error tracking and performance monitoring. Self-host it or use our cloud. Get started for free!
TypeScript chartsclickhousedockergdprgoogle-analyticsmetricsmonitoringmysqlnestjsprivacyredisself-hostedselfhostedstatisticstailwindcssweb-analyticswebanalyticswebsite
import { createHash } from 'crypto'
import { ConfigService } from '@nestjs/config'
import { JwtService } from '@nestjs/jwt'
import { exportJWK, generateKeyPair, SignJWT } from 'jose'
jest.mock('../common/constants', () => ({
REDIS_OIDC_SESSION_KEY: 'oidc:session',
redis: { get: jest.fn(), set: jest.fn(), exists: jest.fn(), del: jest.fn() },
}))
jest.mock('../common/utils', () => ({}))
jest.mock('../user/user.service', () => ({ UserService: class {} }))
jest.mock('../mailer/mailer.service', () => ({ MailerService: class {} }))
import { redis } from '../common/constants'
import { AuthService } from './auth.service'
const issuer = 'https://identity.example.com/auth/v1'
const redirectUrl = 'https://analytics.example.com/socialised'
const discovery = {
issuer,
authorization_endpoint: `${issuer}/authorize`,
token_endpoint: `${issuer}/token`,
jwks_uri: `${issuer}/certs`,
code_challenge_methods_supported: ['S256'],
}
const config: Record<string, string> = {
OIDC_CLIENT_ID: 'swetrix',
OIDC_CLIENT_SECRET: 'test-secret',
}
function setup() {
const sessions = new Map<string, string>()
jest
.mocked(redis.get)
.mockImplementation(async (key) => sessions.get(String(key)) ?? null)
jest.mocked(redis.set).mockImplementation(async (key, value) => {
sessions.set(String(key), String(value))
return 'OK'
})
jest
.mocked(redis.exists)
.mockImplementation(async (key) => Number(sessions.has(String(key))))
jest
.mocked(redis.del)
.mockImplementation(async (key) => Number(sessions.delete(String(key))))
const users = {
findOne: jest.fn().mockResolvedValue({ id: 'user-id' }),
count: jest.fn().mockResolvedValue(0),
create: jest.fn().mockResolvedValue({ id: 'user-id' }),
}
const service = new AuthService(
{ get: (key: string) => config[key] } as ConfigService,
{} as JwtService,
users as any,
{} as any,
)
jest.spyOn(service, 'getOidcDiscovery').mockResolvedValue(discovery)
return { service, sessions, users }
}
beforeEach(() => {
jest.clearAllMocks()
jest.spyOn(console, 'error').mockImplementation(() => {})
})
afterEach(() => jest.restoreAllMocks())
describe('OIDC ID tokens', () => {
let service: AuthService
let signToken: (claims?: Record<string, unknown>) => Promise<string>
beforeEach(async () => {
service = setup().service
const { privateKey, publicKey } = await generateKeyPair('EdDSA')
const jwk = {
...(await exportJWK(publicKey)),
kid: 'ed25519',
alg: 'EdDSA',
use: 'sig',
}
jest
.spyOn(globalThis, 'fetch')
.mockResolvedValue(Response.json({ keys: [jwk] }))
signToken = (claims = {}) =>
new SignJWT({
iss: issuer,
sub: 'rauthy-user',
aud: config.OIDC_CLIENT_ID,
iat: Math.floor(Date.now() / 1000),
exp: Math.floor(Date.now() / 1000) + 300,
email: '[email protected]',
...claims,
})
.setProtectedHeader({ alg: 'EdDSA', kid: 'ed25519' })
.sign(privateKey)
})
it('accepts a signed EdDSA ID token', async () => {
await expect(
service.getIdToken({ id_token: await signToken() }, discovery),
).resolves.toMatchObject({ sub: 'rauthy-user', email: '[email protected]' })
})
it.each(['RS256', 'RS512'])(
'continues to accept %s ID tokens',
async (alg) => {
const { privateKey, publicKey } = await generateKeyPair(alg)
jest.mocked(fetch).mockResolvedValue(
Response.json({
keys: [
{ ...(await exportJWK(publicKey)), kid: 'rsa', alg, use: 'sig' },
],
}),
)
const token = await new SignJWT({ email: '[email protected]' })
.setProtectedHeader({ alg, kid: 'rsa' })
.setIssuer(issuer)
.setSubject('rauthy-user')
.setAudience(config.OIDC_CLIENT_ID)
.setIssuedAt()
.setExpirationTime('5m')
.sign(privateKey)
await expect(
service.getIdToken({ id_token: token }, discovery),
).resolves.toMatchObject({ sub: 'rauthy-user' })
},
)
it.each([
{ iss: 'https://wrong-issuer.example.com' },
{ aud: 'another-client' },
{ exp: 1 },
{ exp: undefined },
{ iat: undefined },
{ iat: Math.floor(Date.now() / 1000) + 600 },
{ sub: undefined },
])('rejects invalid claims: %j', async (claims) => {
await expect(
service.getIdToken({ id_token: await signToken(claims) }, discovery),
).rejects.toThrow()
})
it('rejects a token signed by a different key', async () => {
const { publicKey } = await generateKeyPair('EdDSA')
jest.mocked(fetch).mockResolvedValue(
Response.json({
keys: [
{
...(await exportJWK(publicKey)),
kid: 'ed25519',
alg: 'EdDSA',
use: 'sig',
},
],
}),
)
await expect(
service.getIdToken({ id_token: await signToken() }, discovery),
).rejects.toThrow('Invalid ID token')
})
})
describe('OIDC callback', () => {
it('completes a PKCE login with an EdDSA ID token and an RS512 access token', async () => {
const { service, sessions, users } = setup()
users.findOne.mockResolvedValue(null)
jest.spyOn(service, 'hashPassword').mockResolvedValue('hashed-password')
jest.spyOn(service, 'assignUnassignedProjectsToUser').mockResolvedValue()
const { privateKey, publicKey } = await generateKeyPair('EdDSA')
const rsa = await generateKeyPair('RS512')
const idToken = await new SignJWT({ email: '[email protected]' })
.setProtectedHeader({ alg: 'EdDSA', kid: 'id-key' })
.setIssuer(issuer)
.setSubject('rauthy-user')
.setAudience(config.OIDC_CLIENT_ID)
.setIssuedAt()
.setExpirationTime('5m')
.sign(privateKey)
const accessToken = await new SignJWT({})
.setProtectedHeader({ alg: 'RS512', kid: 'access-key' })
.sign(rsa.privateKey)
const jwk = {
...(await exportJWK(publicKey)),
alg: 'EdDSA',
kid: 'id-key',
use: 'sig',
}
const { uuid, auth_url } = await service.generateOidcAuthUrl(redirectUrl)
jest.spyOn(globalThis, 'fetch').mockImplementation(async (url, options) => {
if (String(url) === discovery.jwks_uri) {
return Response.json({ keys: [jwk] })
}
expect(String(url)).toBe(discovery.token_endpoint)
const verifier = new URLSearchParams(options.body as string).get(
'code_verifier',
)
expect(createHash('sha256').update(verifier).digest('base64url')).toBe(
new URL(auth_url).searchParams.get('code_challenge'),
)
return Response.json({ id_token: idToken, access_token: accessToken })
})
await service.processOidcToken('auth-code', uuid, redirectUrl)
expect(users.create).toHaveBeenCalledWith({
email: '[email protected]',
password: 'hashed-password',
})
expect(JSON.parse(sessions.get(`oidc:session:${uuid}`))).toEqual({
id: 'user-id',
})
})
it('keeps a rejected token exchange pending', async () => {
const { service } = setup()
const { uuid } = await service.generateOidcAuthUrl(redirectUrl)
jest
.spyOn(globalThis, 'fetch')
.mockResolvedValue(
Response.json({ message: 'Bad request' }, { status: 400 }),
)
const validateToken = jest.spyOn(service, 'getIdToken')
await expect(
service.processOidcToken('code', uuid, redirectUrl),
).rejects.toThrow()
expect(validateToken).not.toHaveBeenCalled()
expect(await service.isOidcSessionReady(uuid)).toBe(false)
})
})
describe('OIDC PKCE sessions', () => {
it('binds S256 to the session and sends its verifier during code exchange', async () => {
const { service, sessions, users } = setup()
const fetchMock = jest
.spyOn(globalThis, 'fetch')
.mockResolvedValue(Response.json({ id_token: 'token' }))
jest
.spyOn(service, 'getIdToken')
.mockResolvedValue({ email: '[email protected]' })
const { auth_url, uuid } = await service.generateOidcAuthUrl(redirectUrl)
const params = new URL(auth_url).searchParams
const session = JSON.parse(sessions.get(`oidc:session:${uuid}`))
expect(session.codeVerifier).toMatch(/^[A-Za-z0-9_-]{43}$/)
expect(params.get('code_challenge_method')).toBe('S256')
expect(params.get('code_challenge')).toBe(
createHash('sha256').update(session.codeVerifier).digest('base64url'),
)
expect(params.has('code_verifier')).toBe(false)
expect(await service.isOidcSessionReady(uuid)).toBe(false)
await expect(service.processHash(uuid)).rejects.toThrow('no data found')
expect(sessions.has(`oidc:session:${uuid}`)).toBe(true)
await service.processOidcToken('auth-code', uuid, redirectUrl)
const body = new URLSearchParams(fetchMock.mock.calls[0][1].body as string)
expect(body.get('code_verifier')).toBe(session.codeVerifier)
expect(body.get('redirect_uri')).toBe(redirectUrl)
expect(body.get('client_secret')).toBe('test-secret')
expect(users.findOne).toHaveBeenCalledWith({ email: '[email protected]' })
expect(await service.isOidcSessionReady(uuid)).toBe(true)
await service.processOidcToken('auth-code', uuid, redirectUrl)
expect(fetchMock).toHaveBeenCalledTimes(1)
await expect(service.processHash(uuid)).resolves.toEqual({ id: 'user-id' })
expect(sessions.has(`oidc:session:${uuid}`)).toBe(false)
})
it('rejects a changed redirect URL before exchanging the code', async () => {
const { service } = setup()
const fetchMock = jest.spyOn(globalThis, 'fetch')
const { uuid } = await service.generateOidcAuthUrl(redirectUrl)
await expect(
service.processOidcToken('code', uuid, 'https://other.example.com'),
).rejects.toThrow('Invalid redirect URL')
expect(fetchMock).not.toHaveBeenCalled()
expect(await service.isOidcSessionReady(uuid)).toBe(false)
})
it('rejects an unknown session before exchanging the code', async () => {
const { service } = setup()
const fetchMock = jest.spyOn(globalThis, 'fetch')
await expect(
service.processOidcToken('code', 'missing', redirectUrl),
).rejects.toThrow('No authentication session')
expect(fetchMock).not.toHaveBeenCalled()
})
it('supports providers without S256 support and legacy pending sessions', async () => {
const { service, sessions } = setup()
jest.mocked(service.getOidcDiscovery).mockResolvedValue({
...discovery,
code_challenge_methods_supported: undefined,
})
const fetchMock = jest
.spyOn(globalThis, 'fetch')
.mockImplementation(async () => Response.json({ id_token: 'token' }))
jest
.spyOn(service, 'getIdToken')
.mockResolvedValue({ email: '[email protected]' })
const { auth_url, uuid } = await service.generateOidcAuthUrl(redirectUrl)
expect(new URL(auth_url).searchParams.has('code_challenge')).toBe(false)
await service.processOidcToken('code', uuid, redirectUrl)
expect(
new URLSearchParams(fetchMock.mock.calls[0][1].body as string).has(
'code_verifier',
),
).toBe(false)
sessions.set('oidc:session:legacy', '')
await service.processOidcToken('code', 'legacy', redirectUrl)
expect(await service.isOidcSessionReady('legacy')).toBe(true)
})
})