@toa.io/extensions.exposition 1.0.0-alpha.28 → 1.0.0-alpha.283

package/components/identity.tokens/source/authenticate.ts

@@ -1,10 +1,12 @@
-import { type Maybe, type Operation } from '@toa.io/types'
-import type { AuthenticateInput, AuthenticateOutput, Context } from './types'
+import type { Maybe } from '@toa.io/core'
+import type { Operation } from '@toa.io/bridges.node'
+import { form } from './lib/index.js'
+import type { AuthenticateInput, AuthenticateOutput, Context } from './lib/index.js'
 
 export class Computation implements Operation {
   private refresh: number = 0
-  private decrypt: Context['local']['decrypt'] = undefined as unknown as Context['local']['decrypt']
-  private observe: Context['local']['observe'] = undefined as unknown as Context['local']['observe']
+  private decrypt!: Context['local']['decrypt']
+  private observe!: Context['local']['observe']
 
   public mount (context: Context): void {
     this.refresh = context.configuration.refresh * 1000
@@ -13,27 +15,33 @@ export class Computation implements Operation {
   }
 
   public async execute (input: AuthenticateInput): Promise<Maybe<AuthenticateOutput>> {
-    const claim = await this.decrypt({ input: input.credentials })
+    // `Bearer` is presented by an OpenID id_token too, and the gateway asks each provider
+    // in turn: a credential this component did not issue is declined, not rejected
+    if (form(input.credentials) === null)
+      return ERR_UNRECOGNIZED
 
-    if (claim instanceof Error)
-      return claim
+    const claims = await this.decrypt({ input: input.credentials })
 
-    if (claim.authority !== input.authority)
+    if (claims instanceof Error)
+      return claims
+
+    if (claims.iss !== input.authority)
       return ERR_AUTHORITY
 
-    const identity = claim.identity
-    const iat = new Date(claim.iat).getTime()
-    const transient = claim.exp !== undefined
-    const stale = transient && (iat + this.refresh < Date.now())
+    const identity = claims.identity
+    const iat = new Date(claims.iat).getTime()
+    const transient = claims.exp !== undefined
+    const aged = transient && (iat + this.refresh < Date.now())
 
-    if (stale) {
+    if (aged) {
       const revocation = await this.observe({ query: { id: identity.id } })
 
       if (revocation?.revokedAt !== undefined && iat < revocation.revokedAt)
         return ERR_TOKEN_REVOKED
     }
 
-    const refresh = stale || claim.refresh
+    // a custom token is invalidated by deleting its key, not replaced
+    const refresh = (aged && !claims.custom) || claims.refresh
 
     return {
       identity,
@@ -42,5 +50,14 @@ export class Computation implements Operation {
   }
 }
 
-const ERR_AUTHORITY = new Error('AUTHORITY_MISMATCH')
-const ERR_TOKEN_REVOKED = new Error('TOKEN_REVOKED')
+const ERR_UNRECOGNIZED = new (class UnrecognizedError extends Error {
+  public readonly code = 'UNRECOGNIZED'
+})()
+
+const ERR_AUTHORITY = new (class AuthorityMismatchError extends Error {
+  public readonly code = 'AUTHORITY_MISMATCH'
+})()
+
+const ERR_TOKEN_REVOKED = new (class TokenRevokedError extends Error {
+  public readonly code = 'TOKEN_REVOKED'
+})()

package/components/identity.tokens/source/decrypt.test.ts

@@ -1,61 +1,183 @@
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
 import { generate } from 'randomstring'
-import { Effect as Encrypt } from './encrypt'
-import { computation as decrypt } from './decrypt'
-import { type Configuration, type Context, type Identity } from './types'
+import { EncryptFactory, ImportKeyFactory } from 'paseto/v3/local'
+import { Effect as Encrypt } from './encrypt.js'
+import { Computation as Decrypt } from './decrypt.js'
+import { type Configuration, type Context, type Identity } from './lib/index.js'
+import type { Secret } from '@toa.io/extensions.configuration'
 
 let configuration: Configuration
 let context: Context
 let encrypt: Encrypt
+let decrypt: Decrypt
 
+const remote = { identity: { keys: { observe: mock.fn(async () => null) } } }
 const authority = generate()
 
 beforeEach(() => {
   configuration = {
-    key0: 'k3.local.m28p8SrbS467t-2IUjQuSOqmjvi24TbXhyjAW_dOrog',
-    key1: 'k3.local.-498jfWenrZH-Dqw3-zQJih_hKzDgBgUMfe37OCqSOA',
+    keys: [
+      { id: 'key0', key: secret('sTxL6qVOadKkUJwh3FveU53XgTEo3Sdfg7k2FfiIKfs') },
+      // keys are secrets, and a secret is an object
+      { id: 'key1', key: secret('5I0iSKw3yfBkQ4AXfA8eR-tWR0Q1dpn4x3bPrPzHkP0') },
+      { id: 'legacy0', key: secret('k3.local.m28p8SrbS467t-2IUjQuSOqmjvi24TbXhyjAW_dOrog'), format: 'paseto' },
+      { id: 'legacy1', key: secret('k3.local.-498jfWenrZH-Dqw3-zQJih_hKzDgBgUMfe37OCqSOA'), format: 'paseto' }
+    ],
     lifetime: 1000,
-    refresh: 500
+    refresh: 500,
+    cache: {
+      max: 1024,
+      ttl: 600
+    }
   }
 
-  context = { configuration } as unknown as Context
+  context = { configuration, remote, logs: { debug: () => undefined } } as unknown as Context
 
   encrypt = new Encrypt()
   encrypt.mount(context)
+
+  decrypt = new Decrypt()
+  decrypt.mount(context)
 })
 
 it('should decrypt', async () => {
-  const identity: Identity = { id: generate() }
+  const identity: Identity = { id: generate(), roles: [] }
   const lifetime = 100
 
   const reply = await encrypt.execute({ authority, identity, lifetime })
 
-  if (reply === undefined)
-    throw new Error('?')
+  if (reply instanceof Error)
+    throw reply
 
-  const decrypted = await decrypt(reply, context)
+  const decrypted = await decrypt.execute(reply)
 
-  expect(decrypted).toMatchObject({ authority, identity, refresh: false })
+  assert.partialDeepStrictEqual(decrypted, { iss: authority, identity, refresh: false, custom: false })
+})
+
+it('should mark a token encrypted with a custom key', async () => {
+  const identity: Identity = { id: generate(), roles: [] }
+  const key = { id: generate(), key: '5I0iSKw3yfBkQ4AXfA8eR-tWR0Q1dpn4x3bPrPzHkP0', label: 'custom' }
+
+  remote.identity.keys.observe = mock.fn(async ({ query }: { query: { id: string } }) =>
+    query.id === key.id ? { ...key, identity: identity.id } : null) as any
+
+  const encrypted = await encrypt.execute({ authority, identity, lifetime: 100, key })
+
+  if (encrypted instanceof Error)
+    throw encrypted
+
+  const decrypted = await decrypt.execute(encrypted)
+
+  assert.partialDeepStrictEqual(decrypted, { identity, refresh: false, custom: true })
 })
 
 it('should decrypt with key1', async () => {
   const k1context = {
     configuration: {
-      key0: configuration.key1
+      keys: [configuration.keys[1]]
     }
   } as unknown as Context
 
   encrypt = new Encrypt()
   encrypt.mount(k1context)
 
-  const identity: Identity = { id: generate() }
+  const identity: Identity = { id: generate(), roles: [] }
   const lifetime = 100
 
   const encrypted = await encrypt.execute({ authority, identity, lifetime })
 
-  if (encrypted === undefined)
-    throw new Error('?')
+  if (encrypted instanceof Error)
+    throw encrypted
 
-  const decrypted = await decrypt(encrypted, context)
+  const decrypted = await decrypt.execute(encrypted)
 
-  expect(decrypted).toMatchObject({ identity, refresh: true })
+  assert.partialDeepStrictEqual(decrypted, { identity, refresh: true })
 })
+
+it('should decrypt legacy PASETO and require refresh', async () => {
+  const identity: Identity = { id: generate(), roles: [] }
+
+  const token = await paseto(configuration.keys[2].key.unwrap(), { iss: authority, identity }, 'legacy0')
+
+  await assert.partialDeepStrictEqual(await decrypt.execute(token), {
+    iss: authority,
+    identity,
+    refresh: true
+  })
+})
+
+it('should separate JWE and PASETO keys with the same id by format', async () => {
+  configuration.keys[2].id = 'key0'
+
+  decrypt = new Decrypt()
+  decrypt.mount(context)
+
+  const identity: Identity = { id: generate(), roles: [] }
+
+  const token = await paseto(configuration.keys[2].key.unwrap(), { iss: authority, identity }, 'key0')
+
+  await assert.partialDeepStrictEqual(await decrypt.execute(token), { identity, refresh: true })
+})
+
+it('should reject a token under a revoked key', async () => {
+  const identity: Identity = { id: generate(), roles: [] }
+  const key = { id: generate(), key: '5I0iSKw3yfBkQ4AXfA8eR-tWR0Q1dpn4x3bPrPzHkP0', label: 'revoked' }
+
+  remote.identity.keys.observe = mock.fn(async ({ query }: { query: { id: string } }) =>
+    query.id === key.id ? { ...key, identity: identity.id, revokedAt: Date.now() } : null) as any
+
+  const encrypted = await encrypt.execute({ authority, identity, lifetime: 0, key })
+
+  if (encrypted instanceof Error)
+    throw encrypted
+
+  const thrown: any = await decrypt.execute(encrypted)
+
+  assert.deepStrictEqual(thrown.code, 'REVOKED_KEY')
+})
+
+it('should reject a tampered JWE', async () => {
+  const token = await encrypt.execute({
+    authority,
+    identity: { id: generate(), roles: [] }
+  })
+
+  if (token instanceof Error)
+    throw token
+
+  const parts = token.split('.')
+
+  parts[3] = (parts[3].startsWith('A') ? 'B' : 'A') + parts[3].slice(1)
+
+  const tampered = parts.join('.')
+
+  const thrown: any = await decrypt.execute(tampered)
+        assert.deepStrictEqual(thrown.code, 'INVALID_TOKEN')
+})
+
+it('should reject JWE with an unknown key', async () => {
+  const token = await encrypt.execute({
+    authority,
+    identity: { id: generate(), roles: [] },
+    key: { id: 'missing', key: configuration.keys[0].key.unwrap(), label: 'missing' }
+  })
+
+  if (token instanceof Error)
+    throw token
+
+  const thrown: any = await decrypt.execute(token)
+        assert.deepStrictEqual(thrown.code, 'INVALID_KEY')
+})
+
+function secret (value: string): Secret {
+  return { unwrap: () => value }
+}
+
+async function paseto (key: string, claims: object, kid: string): Promise<string> {
+  const imported = await ImportKeyFactory().run(key as `k3.local.${string}`)
+
+  return await EncryptFactory().run(imported, claims,
+    { footer: new TextEncoder().encode(JSON.stringify({ kid })) })
+}

package/components/identity.tokens/source/decrypt.ts

@@ -1,34 +1,190 @@
-import { V3 } from 'paseto'
-import { type Maybe } from '@toa.io/types'
-import { type Context, type Claim, type DecryptOutput } from './types'
+import { DecryptFactory, ImportKeyFactory } from 'paseto/v3/local'
+import { LRUCache } from 'lru-cache'
+import { form, jweKey } from './lib/index.js'
+import { load } from './lib/jose.js'
+import type { Maybe } from '@toa.io/core'
+import type { Operation } from '@toa.io/bridges.node'
+import type { Context, Claims, DecryptOutput, JWEClaims } from './lib/index.js'
 
-export async function computation (token: string, context: Context): Promise<Maybe<DecryptOutput>> {
-  let refresh = false
-  let claim = await decrypt(token, context.configuration.key0)
+export class Computation implements Operation {
+  private readonly keys: Record<string, Key> = {}
+  private readonly legacy: Record<string, Key> = {}
+  private cache!: LRUCache<string, KeyEntry>
+  private latest!: string
+  private remote!: Context['remote']['identity']['keys']
+  private logs!: Context['logs']
 
-  if (claim === null && context.configuration.key1 !== undefined) {
-    refresh = true
-    claim = await decrypt(token, context.configuration.key1)
+  public mount (context: Context): void {
+    const latest = context.configuration.keys.find(({ format }) => format !== 'paseto')
+
+    if (latest === undefined)
+      throw new TypeError('At least one JWE key must be configured')
+
+    this.latest = latest.id
+    this.remote = context.remote.identity.keys
+    this.cache = new LRUCache<string, KeyEntry>(context.configuration.cache)
+    this.logs = context.logs
+
+    for (const { id, key, format } of context.configuration.keys) {
+      const branch = format === 'paseto' ? this.legacy : this.keys
+
+      branch[id] = { key: key.unwrap() }
+    }
   }
 
-  if (claim === null)
-    return ERR_INVALID_TOKEN
-  else
+  public async execute (token: string): Promise<Maybe<DecryptOutput>> {
+    const legacy = form(token) === 'paseto'
+    const kid = legacy ? this.pasetoKid(token) : await this.jweKid(token)
+
+    if (kid instanceof Error)
+      return kid
+
+    const key = await this.key(kid, legacy)
+
+    if (key instanceof Error)
+      return key
+
+    const claims = legacy
+      ? await decryptPaseto(token, key.key)
+      : await decryptJWE(token, key.key)
+
+    if (claims instanceof Error)
+      return claims
+
+    this.logs.debug('Token claims', claims)
+
+    if (key.identity !== undefined && claims.identity.id !== key.identity)
+      return ERR_FORGED_KEY
+
+    if (key.revokedAt !== undefined)
+      return ERR_REVOKED_KEY
+
     return {
-      authority: claim.aud,
-      identity: claim.identity,
-      iat: claim.iat,
-      exp: claim.exp,
-      refresh
+      iss: claims.iss,
+      iat: claims.iat,
+      exp: claims.exp,
+      identity: claims.identity,
+      refresh: legacy || (kid !== this.latest && key.identity === undefined),
+      custom: key.identity !== undefined
+    }
+  }
+
+  private pasetoKid (token: string): Maybe<string> {
+    const [, , , footer] = token.split('.')
+
+    if (footer === undefined)
+      return ERR_INVALID_TOKEN
+
+    try {
+      const json = Buffer.from(footer, 'base64url').toString('utf-8')
+      const { kid } = JSON.parse(json)
+
+      if (typeof kid !== 'string')
+        return ERR_INVALID_TOKEN
+
+      return kid
+    } catch {
+      return ERR_INVALID_TOKEN
+    }
+  }
+
+  private async jweKid (token: string): Promise<Maybe<string>> {
+    try {
+      const { decodeProtectedHeader } = await load()
+      const header = decodeProtectedHeader(token)
+
+      if (header.alg !== 'dir' || header.enc !== 'A256GCM' || header.typ !== 'JWT' ||
+        typeof header.kid !== 'string')
+        return ERR_INVALID_TOKEN
+
+      return header.kid
+    } catch {
+      return ERR_INVALID_TOKEN
+    }
+  }
+
+  private async key (kid: string, legacy: boolean): Promise<Maybe<Key>> {
+    const configured = legacy ? this.legacy : this.keys
+
+    if (kid in configured)
+      return configured[kid]
+
+    if (!this.cache.has(kid)) {
+      const value = await this.remote.observe({ query: { id: kid } })
+
+      this.cache.set(kid, { value })
     }
+
+    const entry = this.cache.get(kid)
+
+    return entry?.value ?? ERR_INVALID_KEY
+  }
 }
 
-async function decrypt (token: string, key: string): Promise<Claim | null> {
+async function decryptPaseto (token: string, key: string): Promise<Maybe<Claims>> {
   try {
-    return await V3.decrypt<Claim>(token, key)
+    const secret = await importKey(key as `k3.local.${string}`)
+    // paseto 3 read a token that never expires; these are tokens already in the wild
+    const { claims } = await decryptLocal(secret, token, { allowNonExpiring: true })
+
+    return claims as unknown as Claims
   } catch {
-    return null
+    return ERR_INVALID_TOKEN
   }
 }
 
-const ERR_INVALID_TOKEN = new Error('INVALID_TOKEN')
+async function decryptJWE (token: string, key: string): Promise<Maybe<Claims>> {
+  try {
+    const { jwtDecrypt } = await load()
+
+    const { payload } = await jwtDecrypt<JWEClaims>(token, jweKey(key), {
+      keyManagementAlgorithms: ['dir'],
+      contentEncryptionAlgorithms: ['A256GCM']
+    })
+
+    if (typeof payload.iss !== 'string' || typeof payload.iat !== 'number' ||
+      typeof payload.identity !== 'object' || payload.identity === null)
+      return ERR_INVALID_TOKEN
+
+    if (payload.exp !== undefined && payload.exp * 1000 <= Date.now())
+      return ERR_INVALID_TOKEN
+
+    return {
+      iss: payload.iss,
+      iat: new Date(payload.iat * 1000).toISOString(),
+      ...(payload.exp === undefined ? {} : { exp: new Date(payload.exp * 1000).toISOString() }),
+      identity: payload.identity
+    }
+  } catch {
+    return ERR_INVALID_TOKEN
+  }
+}
+
+const importKey = ImportKeyFactory().run
+const decryptLocal = DecryptFactory().run
+
+interface Key {
+  key: string
+  identity?: string
+  revokedAt?: number
+}
+
+interface KeyEntry {
+  value: Key | null
+}
+
+const ERR_INVALID_TOKEN = new (class InvalidTokenError extends Error {
+  public readonly code = 'INVALID_TOKEN'
+})()
+
+const ERR_INVALID_KEY = new (class InvalidKeyError extends Error {
+  public readonly code = 'INVALID_KEY'
+})()
+
+const ERR_FORGED_KEY = new (class ForgedKeyError extends Error {
+  public readonly code = 'FORGED_KEY'
+})()
+
+const ERR_REVOKED_KEY = new (class RevokedKeyError extends Error {
+  public readonly code = 'REVOKED_KEY'
+})()

package/components/identity.tokens/source/encrypt.test.ts

@@ -1,28 +1,91 @@
-import assert from 'node:assert'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
 import { generate } from 'randomstring'
 import { timeout } from '@toa.io/generic'
-import { Effect as Encrypt } from './encrypt'
-import { computation as decrypt } from './decrypt'
-import { type Context, type Identity } from './types'
+import { Effect as Encrypt } from './encrypt.js'
+import { Computation as Decrypt } from './decrypt.js'
+import { type Context, type Identity } from './lib/index.js'
+import type { Secret } from '@toa.io/extensions.configuration'
 
 let encrypt: Encrypt
+let decrypt: Decrypt
+
+const context: Context = {
+  remote: { identity: { keys: null } },
+  logs: { debug: () => undefined }
+} as unknown as Context
 
-const context: Context = {} as unknown as Context
 const authority = generate()
 
 beforeEach(() => {
   context.configuration = {
-    key0: 'k3.local.m28p8SrbS467t-2IUjQuSOqmjvi24TbXhyjAW_dOrog',
-    lifetime: 1000,
-    refresh: 2
+    keys: [
+      { id: 'key0', key: secret('sTxL6qVOadKkUJwh3FveU53XgTEo3Sdfg7k2FfiIKfs') },
+      { id: 'legacy0', key: secret('k3.local.m28p8SrbS467t-2IUjQuSOqmjvi24TbXhyjAW_dOrog'), format: 'paseto' }
+    ],
+    lifetime: 1,
+    refresh: 2,
+    cache: {
+      max: 1024,
+      ttl: 3
+    }
   }
 
   encrypt = new Encrypt()
   encrypt.mount(context)
+
+  decrypt = new Decrypt()
+  decrypt.mount(context)
+})
+
+it('should use the first encryption key as active and expose its id as kid', async () => {
+  context.configuration.keys.unshift({
+    id: 'legacy-first',
+    key: secret('k3.local.m28p8SrbS467t-2IUjQuSOqmjvi24TbXhyjAW_dOrog'),
+    format: 'paseto'
+  })
+  context.configuration.keys.push({
+    id: 'key1',
+    key: secret('5I0iSKw3yfBkQ4AXfA8eR-tWR0Q1dpn4x3bPrPzHkP0')
+  })
+
+  encrypt.mount(context)
+
+  const encrypted = await encrypt.execute({
+    authority,
+    identity: { id: generate(), roles: [] }
+  })
+
+  if (encrypted instanceof Error)
+    throw encrypted
+
+  const header = JSON.parse(Buffer.from(encrypted.split('.')[0], 'base64url').toString())
+
+  assert.partialDeepStrictEqual(header, { kid: 'key0', alg: 'dir', enc: 'A256GCM' })
+})
+
+it('should encrypt with configured lifetime by default', async () => {
+  const identity: Identity = { id: generate(), roles: [] }
+
+  const encrypted = await encrypt.execute({
+    authority,
+    identity
+  })
+
+  if (encrypted instanceof Error)
+    throw encrypted
+
+  await assert.partialDeepStrictEqual(await decrypt.execute(encrypted), { iss: authority, identity })
+
+  await timeout(context.configuration.lifetime * 1000)
+
+  const thrown: any = await decrypt.execute(encrypted)
+        assert.deepStrictEqual(thrown.code, 'INVALID_TOKEN')
 })
 
 it('should encrypt with given lifetime', async () => {
-  const identity: Identity = { id: generate() }
+  const identity: Identity = { id: generate(), roles: [] }
   const lifetime = 0.1
 
   const encrypted = await encrypt.execute({
@@ -31,18 +94,19 @@ it('should encrypt with given lifetime', async () => {
     lifetime
   })
 
-  if (encrypted === undefined)
-    throw new Error('?')
+  if (encrypted instanceof Error)
+    throw encrypted
 
-  await expect(decrypt(encrypted, context)).resolves.toMatchObject({ authority, identity })
+  await assert.partialDeepStrictEqual(await decrypt.execute(encrypted), { iss: authority, identity })
 
   await timeout(lifetime * 1000)
 
-  await expect(decrypt(encrypted, context)).resolves.toMatchObject({ message: 'INVALID_TOKEN' })
+  const thrown: any = await decrypt.execute(encrypted)
+        assert.deepStrictEqual(thrown.code, 'INVALID_TOKEN')
 })
 
 it('should encrypt without lifetime INSECURE', async () => {
-  const identity: Identity = { id: generate() }
+  const identity: Identity = { id: generate(), roles: [] }
   const lifetime = 0
 
   const encrypted = await encrypt.execute({
@@ -51,9 +115,31 @@ it('should encrypt without lifetime INSECURE', async () => {
     lifetime
   })
 
-  const decrypted = await decrypt(encrypted, context)
+  if (encrypted instanceof Error)
+    throw encrypted
+
+  const decrypted = await decrypt.execute(encrypted)
 
   assert.ok(!(decrypted instanceof Error))
 
-  expect(decrypted.identity).toMatchObject(identity)
+  assert.partialDeepStrictEqual(decrypted.identity, identity)
 })
+
+it('should keep the identity permissions when none are given', async () => {
+  const permissions = { '/notes/': ['GET'] }
+  const identity: Identity = { id: generate(), roles: [], permissions }
+
+  const encrypted = await encrypt.execute({ authority, identity, lifetime: 100 })
+
+  if (encrypted instanceof Error)
+    throw encrypted
+
+  const decrypted = await decrypt.execute(encrypted)
+
+  assert.ok(!(decrypted instanceof Error))
+  assert.deepStrictEqual(decrypted.identity.permissions, permissions)
+})
+
+function secret (value: string): Secret {
+  return { unwrap: () => value }
+}