Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
7.0 KB
Raw Blame
// Node-only signing/verification for connect-link tokens (compact JWS,
// EdDSA/Ed25519 via node:crypto — no external JWT dependency). den-api signs
// with this module; the Electron main process ships its own dependency-free
// mirror of `verifyConnectLinkToken` (apps/desktop/electron/connect-link.mjs)
// and this implementation is the reference the tests hold it to.

import { Buffer } from "node:buffer"
import { createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto"
import {
  CONNECT_LINK_ALGORITHM,
  CONNECT_LINK_AUDIENCE,
  CONNECT_LINK_VERSION,
  type ConnectLinkClaims,
  type ConnectLinkVerifyResult,
} from "@omnirush/types/connect-link"
import { connectLinkClaimsSchema, findInsecureConnectLinkUrl, findRefusedConnectLinkUrl } from "./index"

const DEFAULT_CLOCK_SKEW_SECONDS = 60

export type ConnectLinkKeyPair = {
  publicKeyPem: string
  privateKeyPem: string
}

export function generateConnectLinkKeyPair(): ConnectLinkKeyPair {
  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
    publicKeyEncoding: { type: "spki", format: "pem" },
    privateKeyEncoding: { type: "pkcs8", format: "pem" },
  })
  return { publicKeyPem: publicKey, privateKeyPem: privateKey }
}

function base64UrlEncode(value: string): string {
  return Buffer.from(value, "utf8").toString("base64url")
}

function base64UrlDecode(value: string): string | null {
  if (!/^[A-Za-z0-9_-]+$/.test(value)) return null
  try {
    return Buffer.from(value, "base64url").toString("utf8")
  } catch {
    return null
  }
}

export type SignConnectLinkTokenInput = {
  claims: ConnectLinkClaims
  privateKeyPem: string
  kid: string
  /** Permit non-https den/logo URLs (local development and evals only). */
  allowInsecureUrls?: boolean
}

export function signConnectLinkToken(input: SignConnectLinkTokenInput): string {
  const claims = connectLinkClaimsSchema.parse(input.claims)
  if (!input.allowInsecureUrls) {
    const insecure = findInsecureConnectLinkUrl(claims)
    if (insecure) {
      throw new Error(`connect-link claims contain a non-https URL: ${insecure}`)
    }
  }
  const header = { alg: CONNECT_LINK_ALGORITHM, typ: "JWT", kid: input.kid }
  const signingInput = `${base64UrlEncode(JSON.stringify(header))}.${base64UrlEncode(JSON.stringify(claims))}`
  // new Uint8Array(...) keeps the calls assignable across the @types/node
  // versions in this workspace (Buffer's backing store is typed as
  // ArrayBufferLike on older lib combinations).
  const signature = sign(null, new Uint8Array(Buffer.from(signingInput, "utf8")), createPrivateKey(input.privateKeyPem))
  return `${signingInput}.${signature.toString("base64url")}`
}

export type VerifyConnectLinkTokenInput = {
  token: string
  /** kid → SPKI PEM public key. Only keys in this map are trusted. */
  publicKeys: Record<string, string>
  nowEpochSeconds?: number
  clockSkewSeconds?: number
  /** Accept http URLs when every insecure target is loopback (dev only). */
  allowInsecureLoopback?: boolean
}

export function verifyConnectLinkToken(input: VerifyConnectLinkTokenInput): ConnectLinkVerifyResult {
  const now = input.nowEpochSeconds ?? Math.floor(Date.now() / 1000)
  const skew = input.clockSkewSeconds ?? DEFAULT_CLOCK_SKEW_SECONDS

  const parts = input.token.split(".")
  if (parts.length !== 3 || parts.some((part) => part.length === 0)) {
    return { ok: false, code: "invalid_token", message: "Token is not a three-part compact JWS." }
  }
  const [headerPart, payloadPart, signaturePart] = parts

  const headerJson = base64UrlDecode(headerPart)
  if (headerJson === null) {
    return { ok: false, code: "invalid_token", message: "Token header is not valid base64url." }
  }
  let header: unknown
  try {
    header = JSON.parse(headerJson)
  } catch {
    return { ok: false, code: "invalid_token", message: "Token header is not valid JSON." }
  }
  if (typeof header !== "object" || header === null) {
    return { ok: false, code: "invalid_token", message: "Token header is not an object." }
  }
  const headerRecord = header as Record<string, unknown>
  if (headerRecord.alg !== CONNECT_LINK_ALGORITHM) {
    return { ok: false, code: "invalid_token", message: `Token alg must be ${CONNECT_LINK_ALGORITHM}.` }
  }
  if ("crit" in headerRecord) {
    return { ok: false, code: "invalid_token", message: "Token crit header is not supported." }
  }
  if (headerRecord.typ !== undefined && headerRecord.typ !== "JWT") {
    return { ok: false, code: "invalid_token", message: "Token typ must be JWT when present." }
  }
  const kid = headerRecord.kid
  if (typeof kid !== "string" || kid.length === 0) {
    return { ok: false, code: "invalid_token", message: "Token kid header is required." }
  }

  const publicKeyPem = input.publicKeys[kid]
  if (!publicKeyPem) {
    return { ok: false, code: "unknown_kid", message: `No trusted key for kid ${kid}.` }
  }

  if (!/^[A-Za-z0-9_-]+$/.test(signaturePart)) {
    return { ok: false, code: "invalid_token", message: "Token signature is not valid base64url." }
  }
  const signingInput = new Uint8Array(Buffer.from(`${headerPart}.${payloadPart}`, "utf8"))
  const signature = new Uint8Array(Buffer.from(signaturePart, "base64url"))
  let signatureValid = false
  try {
    signatureValid = verify(null, signingInput, createPublicKey(publicKeyPem), signature)
  } catch {
    signatureValid = false
  }
  if (!signatureValid) {
    return { ok: false, code: "bad_signature", message: "Token signature does not verify." }
  }

  const payloadJson = base64UrlDecode(payloadPart)
  if (payloadJson === null) {
    return { ok: false, code: "invalid_token", message: "Token payload is not valid base64url." }
  }
  let payload: unknown
  try {
    payload = JSON.parse(payloadJson)
  } catch {
    return { ok: false, code: "invalid_token", message: "Token payload is not valid JSON." }
  }
  if (typeof payload !== "object" || payload === null) {
    return { ok: false, code: "invalid_token", message: "Token payload is not an object." }
  }
  const payloadRecord = payload as Record<string, unknown>
  if (payloadRecord.aud !== CONNECT_LINK_AUDIENCE) {
    return { ok: false, code: "wrong_audience", message: "Token audience is not the desktop connect audience." }
  }
  if (payloadRecord.v !== CONNECT_LINK_VERSION) {
    return { ok: false, code: "wrong_version", message: "Token payload version is not supported." }
  }

  const parsed = connectLinkClaimsSchema.safeParse(payload)
  if (!parsed.success) {
    return { ok: false, code: "malformed_claims", message: "Token claims failed validation." }
  }
  const claims = parsed.data

  if (claims.iat > now + skew) {
    return { ok: false, code: "not_yet_valid", message: "Token is not valid yet." }
  }
  if (claims.exp <= now - skew) {
    return { ok: false, code: "expired", message: "Token has expired." }
  }

  const refusedUrl = findRefusedConnectLinkUrl(claims, input.allowInsecureLoopback === true)
  if (refusedUrl) {
    return { ok: false, code: "insecure_url", message: `Token target is not https: ${refusedUrl}` }
  }

  return { ok: true, claims, transport: "signed", kid }
}