+239 -3

src/app.ts

reviewed

··· 1 1 + import crypto from "node:crypto"; 2 2 + import { Secp256k1Keypair } from "@atproto/crypto"; 3 3 + import { Repo } from "@atproto/repo"; 4 4 + import { Hono } from "hono"; 1 5 import type Database from "better-sqlite3"; 2 2 - import { Hono } from "hono"; 6 6 + import { 7 7 + createAuthMiddleware, 8 8 + type AccountRow, 9 9 + type AuthEnv, 10 10 + isValidHandle, 11 11 + validateAccessToken, 12 12 + validateDpopProof, 13 13 + } from "./auth.js"; 3 14 import type { Config } from "./config.js"; 15 15 + import { createDidPlc } from "./identity.js"; 16 16 + import { SqliteRepoStorage } from "./storage.js"; 4 17 5 5 - export function createApp(db: Database.Database, _config: Config) { 6 6 - const app = new Hono(); 18 18 + export function createApp(config: Config, db: Database.Database): Hono<AuthEnv> { 19 19 + const app = new Hono<AuthEnv>(); 20 20 + const authMiddleware = createAuthMiddleware(db, config); 21 21 + const serviceOrigin = `https://${config.hostname}`; 7 22 8 23 app.get("/", (c) => c.json({ status: "ok" })); 9 24 ··· 46 61 return c.text(row.did); 47 62 }); 48 63 64 64 + app.get("/.well-known/welcome.md", (c) => { 65 65 + return c.text(generateWelcomeMd(config), 200, { 66 66 + "Content-Type": "text/markdown; charset=utf-8", 67 67 + }); 68 68 + }); 69 69 + 70 70 + app.get("/tos", (c) => { 71 71 + return c.text(config.tosText, 200, { "Content-Type": "text/plain; charset=utf-8" }); 72 72 + }); 73 73 + 74 74 + app.post("/api/signup", async (c) => { 75 75 + const dpopHeader = c.req.header("DPoP"); 76 76 + if (!dpopHeader) { 77 77 + return c.json({ error: "missing DPoP header" }, 400); 78 78 + } 79 79 + 80 80 + let dpop; 81 81 + try { 82 82 + dpop = validateDpopProof(dpopHeader, "POST", c.req.url, null); 83 83 + } catch (error) { 84 84 + return c.json({ error: (error as Error).message }, 400); 85 85 + } 86 86 + 87 87 + let body: Record<string, unknown>; 88 88 + try { 89 89 + body = await c.req.json(); 90 90 + } catch { 91 91 + return c.json({ error: "invalid JSON body" }, 400); 92 92 + } 93 93 + 94 94 + const { handle, tos_signature, access_token } = body as { 95 95 + handle?: string; 96 96 + tos_signature?: string; 97 97 + access_token?: string; 98 98 + }; 99 99 + 100 100 + if (!handle || typeof handle !== "string") { 101 101 + return c.json({ error: "missing handle field" }, 400); 102 102 + } 103 103 + if (!isValidHandle(handle)) { 104 104 + return c.json( 105 105 + { 106 106 + error: 107 107 + "invalid handle — must be lowercase alphanumeric with dots/hyphens, no leading/trailing separators", 108 108 + }, 109 109 + 400, 110 110 + ); 111 111 + } 112 112 + if (!tos_signature || typeof tos_signature !== "string") { 113 113 + return c.json({ error: "missing tos_signature field" }, 400); 114 114 + } 115 115 + if (!access_token || typeof access_token !== "string") { 116 116 + return c.json({ error: "missing access_token field" }, 400); 117 117 + } 118 118 + 119 119 + try { 120 120 + const sigBytes = Buffer.from(tos_signature, "base64url"); 121 121 + const valid = crypto.verify("SHA256", Buffer.from(config.tosText), dpop.key, sigBytes); 122 122 + if (!valid) { 123 123 + return c.json({ error: "ToS signature verification failed" }, 400); 124 124 + } 125 125 + } catch { 126 126 + return c.json({ error: "ToS signature verification failed" }, 400); 127 127 + } 128 128 + 129 129 + try { 130 130 + validateAccessToken(access_token, dpop.key, serviceOrigin, dpop.thumbprint, config.tosText); 131 131 + } catch (error) { 132 132 + return c.json({ error: (error as Error).message }, 400); 133 133 + } 134 134 + 135 135 + const fullHandle = `${handle}.${config.handleDomain}`; 136 136 + 137 137 + if (db.prepare("SELECT 1 FROM accounts WHERE handle = ?").get(fullHandle)) { 138 138 + return c.json({ error: "handle already taken" }, 409); 139 139 + } 140 140 + if (db.prepare("SELECT 1 FROM accounts WHERE jwk_thumbprint = ?").get(dpop.thumbprint)) { 141 141 + return c.json({ error: "key already registered" }, 409); 142 142 + } 143 143 + 144 144 + const signingKey = await Secp256k1Keypair.create({ exportable: true }); 145 145 + const rotationKey = await Secp256k1Keypair.create({ exportable: true }); 146 146 + const did = await createDidPlc({ 147 147 + signingKey, 148 148 + rotationKey, 149 149 + handle: fullHandle, 150 150 + pdsEndpoint: serviceOrigin, 151 151 + plcUrl: config.plcUrl, 152 152 + }); 153 153 + 154 154 + const signingKeyHex = Buffer.from(await signingKey.export()).toString("hex"); 155 155 + const rotationKeyHex = Buffer.from(await rotationKey.export()).toString("hex"); 156 156 + 157 157 + let accountId: number; 158 158 + try { 159 159 + const info = db 160 160 + .prepare( 161 161 + `INSERT INTO accounts ( 162 162 + did, 163 163 + handle, 164 164 + jwk_thumbprint, 165 165 + signing_key_hex, 166 166 + signing_key_pub, 167 167 + rotation_key_hex, 168 168 + rotation_key_pub 169 169 + ) VALUES (?, ?, ?, ?, ?, ?, ?)`, 170 170 + ) 171 171 + .run( 172 172 + did, 173 173 + fullHandle, 174 174 + dpop.thumbprint, 175 175 + signingKeyHex, 176 176 + signingKey.did(), 177 177 + rotationKeyHex, 178 178 + rotationKey.did(), 179 179 + ); 180 180 + accountId = Number(info.lastInsertRowid); 181 181 + } catch (error) { 182 182 + const message = error instanceof Error ? error.message : ""; 183 183 + if (message.includes("UNIQUE constraint failed: accounts.handle")) { 184 184 + return c.json({ error: "handle already taken" }, 409); 185 185 + } 186 186 + if (message.includes("UNIQUE constraint failed: accounts.jwk_thumbprint")) { 187 187 + return c.json({ error: "key already registered" }, 409); 188 188 + } 189 189 + throw error; 190 190 + } 191 191 + 192 192 + try { 193 193 + const storage = new SqliteRepoStorage(db, accountId); 194 194 + await Repo.create(storage, did, signingKey); 195 195 + } catch (error) { 196 196 + db.prepare("DELETE FROM blocks WHERE account_id = ?").run(accountId); 197 197 + db.prepare("DELETE FROM accounts WHERE id = ?").run(accountId); 198 198 + throw error; 199 199 + } 200 200 + 201 201 + return c.json({ 202 202 + did, 203 203 + handle: fullHandle, 204 204 + access_token, 205 205 + token_type: "DPoP", 206 206 + }); 207 207 + }); 208 208 + 209 209 + app.get("/api/whoami", authMiddleware, (c) => { 210 210 + const account = c.get("account"); 211 211 + return c.json({ did: account.did, handle: account.handle }); 212 212 + }); 213 213 + 49 214 return app; 50 215 } 216 216 + 217 217 + function generateWelcomeMd(config: Config): string { 218 218 + return `# rookery 219 219 + 220 220 + an open-source, lexicon-agnostic, multi-tenant PDS for AI agents. 221 221 + 222 222 + ## requirements 223 223 + 224 224 + - protocol: welcome mat v1 (DPoP) 225 225 + - dpop algorithms: RS256 226 226 + - minimum key size: 4096 (RSA) 227 227 + 228 228 + ## endpoints 229 229 + 230 230 + - terms: GET https://${config.hostname}/tos 231 231 + - signup: POST https://${config.hostname}/api/signup 232 232 + 233 233 + ## signup requirements 234 234 + 235 235 + - handle: required 236 236 + 237 237 + ## handle format 238 238 + 239 239 + lowercase alphanumeric, dots, and hyphens. must start and end with alphanumeric. 240 240 + handles are assigned under ${config.handleDomain} (e.g., yourhandle.${config.handleDomain}). 241 241 + regex: \`^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$\` 242 242 + 243 243 + ## enrollment flow 244 244 + 245 245 + ### 1. get terms 246 246 + 247 247 + \`\`\` 248 248 + GET /tos HTTP/1.1 249 249 + Host: ${config.hostname} 250 250 + \`\`\` 251 251 + 252 252 + no authentication needed. response is the ToS text as \`text/plain\`. 253 253 + 254 254 + ### 2. sign up 255 255 + 256 256 + sign the ToS text with your private key (RS256). generate a self-signed access token JWT: 257 257 + 258 258 + \`\`\` 259 259 + HEADER: {"typ": "wm+jwt", "alg": "RS256"} 260 260 + PAYLOAD: { 261 261 + "jti": "<unique id>", 262 262 + "tos_hash": "<base64url SHA-256 of ToS text>", 263 263 + "aud": "https://${config.hostname}", 264 264 + "cnf": {"jkt": "<JWK SHA-256 Thumbprint per RFC 7638>"}, 265 265 + "iat": <unix timestamp> 266 266 + } 267 267 + \`\`\` 268 268 + 269 269 + then POST /api/signup: 270 270 + 271 271 + \`\`\` 272 272 + POST /api/signup HTTP/1.1 273 273 + Host: ${config.hostname} 274 274 + DPoP: <proof JWT> 275 275 + Content-Type: application/json 276 276 + 277 277 + { 278 278 + "tos_signature": "base64url-encoded-signature-of-tos-text", 279 279 + "access_token": "eyJ0eXAiOiJ3bStqd3QiLC...", 280 280 + "handle": "your-chosen-handle" 281 281 + } 282 282 + \`\`\` 283 283 + `; 284 284 + } 285 285 + 286 286 + export type { AccountRow };

+284

src/auth.ts

reviewed

··· 1 1 + import crypto from "node:crypto"; 2 2 + import type Database from "better-sqlite3"; 3 3 + import type { MiddlewareHandler } from "hono"; 4 4 + import { createMiddleware } from "hono/factory"; 5 5 + import type { Config } from "./config.js"; 6 6 + 7 7 + export interface RsaPublicJwk { 8 8 + kty: string; 9 9 + n: string; 10 10 + e: string; 11 11 + [key: string]: unknown; 12 12 + } 13 13 + 14 14 + export interface JwtHeader { 15 15 + typ?: string; 16 16 + alg?: string; 17 17 + jwk?: RsaPublicJwk; 18 18 + [key: string]: unknown; 19 19 + } 20 20 + 21 21 + export interface JwtPayload { 22 22 + [key: string]: unknown; 23 23 + } 24 24 + 25 25 + export interface AccountRow { 26 26 + id: number; 27 27 + did: string; 28 28 + handle: string | null; 29 29 + jwk_thumbprint: string | null; 30 30 + [key: string]: unknown; 31 31 + } 32 32 + 33 33 + export type AuthEnv = { 34 34 + Variables: { 35 35 + account: AccountRow; 36 36 + }; 37 37 + }; 38 38 + 39 39 + export function base64urlEncode(input: Buffer | Uint8Array): string { 40 40 + return Buffer.from(input).toString("base64url"); 41 41 + } 42 42 + 43 43 + export function base64urlDecode(str: string): Buffer { 44 44 + return Buffer.from(str, "base64url"); 45 45 + } 46 46 + 47 47 + export function sha256Base64url(data: string | Buffer): string { 48 48 + const hash = crypto.createHash("sha256").update(data).digest(); 49 49 + return base64urlEncode(hash); 50 50 + } 51 51 + 52 52 + export function parseJwt(token: string): { 53 53 + header: JwtHeader; 54 54 + payload: JwtPayload; 55 55 + signingInput: string; 56 56 + signature: Buffer; 57 57 + } { 58 58 + const parts = token.split("."); 59 59 + if (parts.length !== 3) { 60 60 + throw new Error("invalid JWT: expected 3 parts"); 61 61 + } 62 62 + 63 63 + const header = JSON.parse(base64urlDecode(parts[0]).toString("utf-8")) as JwtHeader; 64 64 + const payload = JSON.parse(base64urlDecode(parts[1]).toString("utf-8")) as JwtPayload; 65 65 + 66 66 + return { 67 67 + header, 68 68 + payload, 69 69 + signingInput: `${parts[0]}.${parts[1]}`, 70 70 + signature: base64urlDecode(parts[2]), 71 71 + }; 72 72 + } 73 73 + 74 74 + export function jwkThumbprint(jwk: RsaPublicJwk): string { 75 75 + const canonical = JSON.stringify({ e: jwk.e, kty: "RSA", n: jwk.n }); 76 76 + return sha256Base64url(canonical); 77 77 + } 78 78 + 79 79 + export function validateAndImportKey(jwk: RsaPublicJwk): crypto.KeyObject { 80 80 + if (jwk.kty !== "RSA") { 81 81 + throw new Error("key must be RSA"); 82 82 + } 83 83 + if (!jwk.n || !jwk.e) { 84 84 + throw new Error("invalid RSA key: missing n or e"); 85 85 + } 86 86 + 87 87 + let key: crypto.KeyObject; 88 88 + try { 89 89 + key = crypto.createPublicKey({ 90 90 + key: { kty: jwk.kty, n: jwk.n, e: jwk.e }, 91 91 + format: "jwk", 92 92 + }); 93 93 + } catch { 94 94 + throw new Error("invalid RSA public key"); 95 95 + } 96 96 + 97 97 + const exported = key.export({ format: "jwk" }); 98 98 + if ( 99 99 + !("n" in exported) || 100 100 + typeof exported.n !== "string" || 101 101 + !("e" in exported) || 102 102 + typeof exported.e !== "string" 103 103 + ) { 104 104 + throw new Error("invalid RSA public key"); 105 105 + } 106 106 + 107 107 + const modulusBits = base64urlDecode(exported.n).length * 8; 108 108 + if (modulusBits !== 4096) { 109 109 + throw new Error(`key must be 4096-bit RSA (got ${modulusBits}-bit)`); 110 110 + } 111 111 + 112 112 + return key; 113 113 + } 114 114 + 115 115 + export function validateDpopProof( 116 116 + dpopJwt: string, 117 117 + method: string, 118 118 + url: string, 119 119 + accessToken: string | null, 120 120 + ): { jwk: RsaPublicJwk; key: crypto.KeyObject; thumbprint: string } { 121 121 + let jwt; 122 122 + try { 123 123 + jwt = parseJwt(dpopJwt); 124 124 + } catch { 125 125 + throw new Error("invalid DPoP proof: malformed JWT"); 126 126 + } 127 127 + 128 128 + const { header, payload, signingInput, signature } = jwt; 129 129 + 130 130 + if (header.typ !== "dpop+jwt") { 131 131 + throw new Error("invalid DPoP proof: typ must be dpop+jwt"); 132 132 + } 133 133 + if (header.alg !== "RS256") { 134 134 + throw new Error("invalid DPoP proof: alg must be RS256"); 135 135 + } 136 136 + if (!header.jwk) { 137 137 + throw new Error("invalid DPoP proof: missing jwk"); 138 138 + } 139 139 + 140 140 + const key = validateAndImportKey(header.jwk); 141 141 + 142 142 + if (!payload.jti) { 143 143 + throw new Error("invalid DPoP proof: missing jti"); 144 144 + } 145 145 + if (payload.htm !== method) { 146 146 + throw new Error(`invalid DPoP proof: htm must be ${method}`); 147 147 + } 148 148 + 149 149 + const reqUrl = new URL(url); 150 150 + const expectedHtu = reqUrl.origin + reqUrl.pathname; 151 151 + if (payload.htu !== expectedHtu) { 152 152 + throw new Error("invalid DPoP proof: htu does not match request URL"); 153 153 + } 154 154 + 155 155 + if (!payload.iat || typeof payload.iat !== "number") { 156 156 + throw new Error("invalid DPoP proof: missing or invalid iat"); 157 157 + } 158 158 + 159 159 + const now = Math.floor(Date.now() / 1000); 160 160 + if (Math.abs(now - payload.iat) > 300) { 161 161 + throw new Error("invalid DPoP proof: iat too far from current time"); 162 162 + } 163 163 + 164 164 + if (accessToken) { 165 165 + if (typeof payload.ath !== "string") { 166 166 + throw new Error("invalid DPoP proof: missing ath"); 167 167 + } 168 168 + const expectedAth = sha256Base64url(accessToken); 169 169 + if (payload.ath !== expectedAth) { 170 170 + throw new Error("invalid DPoP proof: ath does not match access token"); 171 171 + } 172 172 + } 173 173 + 174 174 + const valid = crypto.verify("SHA256", Buffer.from(signingInput), key, signature); 175 175 + if (!valid) { 176 176 + throw new Error("invalid DPoP proof: signature verification failed"); 177 177 + } 178 178 + 179 179 + return { jwk: header.jwk, key, thumbprint: jwkThumbprint(header.jwk) }; 180 180 + } 181 181 + 182 182 + export function validateAccessToken( 183 183 + accessTokenStr: string, 184 184 + dpopKey: crypto.KeyObject, 185 185 + serviceOrigin: string, 186 186 + dpopThumbprint: string, 187 187 + tosText: string, 188 188 + ): JwtPayload { 189 189 + let jwt; 190 190 + try { 191 191 + jwt = parseJwt(accessTokenStr); 192 192 + } catch { 193 193 + throw new Error("invalid access token: malformed JWT"); 194 194 + } 195 195 + 196 196 + const { header, payload, signingInput, signature } = jwt; 197 197 + 198 198 + if (header.typ !== "wm+jwt") { 199 199 + throw new Error("invalid access token: typ must be wm+jwt"); 200 200 + } 201 201 + if (header.alg !== "RS256") { 202 202 + throw new Error("invalid access token: alg must be RS256"); 203 203 + } 204 204 + if (!payload.tos_hash) { 205 205 + throw new Error("invalid access token: missing tos_hash"); 206 206 + } 207 207 + if (payload.aud !== serviceOrigin) { 208 208 + throw new Error("invalid access token: aud does not match service origin"); 209 209 + } 210 210 + 211 211 + const cnf = payload.cnf; 212 212 + if (!cnf || typeof cnf !== "object" || !("jkt" in cnf) || typeof cnf.jkt !== "string") { 213 213 + throw new Error("invalid access token: missing cnf.jkt"); 214 214 + } 215 215 + if (cnf.jkt !== dpopThumbprint) { 216 216 + throw new Error("invalid access token: cnf.jkt does not match DPoP key"); 217 217 + } 218 218 + 219 219 + const expectedTosHash = sha256Base64url(tosText); 220 220 + if (payload.tos_hash !== expectedTosHash) { 221 221 + throw new Error("invalid access token: tos_hash does not match current terms"); 222 222 + } 223 223 + 224 224 + const valid = crypto.verify("SHA256", Buffer.from(signingInput), dpopKey, signature); 225 225 + if (!valid) { 226 226 + throw new Error("invalid access token: signature verification failed"); 227 227 + } 228 228 + 229 229 + return payload; 230 230 + } 231 231 + 232 232 + export function isValidHandle(handle: string): boolean { 233 233 + return /^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/.test(handle) && handle.length <= 64; 234 234 + } 235 235 + 236 236 + export function extractBearerToken(authHeader: string | null): string | null { 237 237 + if (!authHeader) { 238 238 + return null; 239 239 + } 240 240 + const match = authHeader.match(/^DPoP\s+(.+)$/i); 241 241 + return match ? match[1] : null; 242 242 + } 243 243 + 244 244 + export function createAuthMiddleware( 245 245 + db: Database.Database, 246 246 + config: Config, 247 247 + ): MiddlewareHandler<AuthEnv> { 248 248 + const serviceOrigin = `https://${config.hostname}`; 249 249 + 250 250 + return createMiddleware<AuthEnv>(async (c, next) => { 251 251 + const accessToken = extractBearerToken(c.req.header("Authorization") ?? null); 252 252 + if (!accessToken) { 253 253 + return c.json({ error: "missing Authorization: DPoP <token> header" }, 401); 254 254 + } 255 255 + 256 256 + const dpopHeader = c.req.header("DPoP"); 257 257 + if (!dpopHeader) { 258 258 + return c.json({ error: "missing DPoP header" }, 401); 259 259 + } 260 260 + 261 261 + let dpop; 262 262 + try { 263 263 + dpop = validateDpopProof(dpopHeader, c.req.method, c.req.url, accessToken); 264 264 + } catch (error) { 265 265 + return c.json({ error: (error as Error).message }, 401); 266 266 + } 267 267 + 268 268 + try { 269 269 + validateAccessToken(accessToken, dpop.key, serviceOrigin, dpop.thumbprint, config.tosText); 270 270 + } catch (error) { 271 271 + return c.json({ error: (error as Error).message }, 401); 272 272 + } 273 273 + 274 274 + const account = db 275 275 + .prepare("SELECT * FROM accounts WHERE jwk_thumbprint = ?") 276 276 + .get(dpop.thumbprint) as AccountRow | undefined; 277 277 + if (!account) { 278 278 + return c.json({ error: "account not found" }, 401); 279 279 + } 280 280 + 281 281 + c.set("account", account); 282 282 + await next(); 283 283 + }); 284 284 + }

+23

src/config.ts

reviewed

··· 1 1 + import { readFileSync } from "node:fs"; 2 2 + 1 3 export interface Config { 2 4 hostname: string; 3 5 handleDomain: string; 4 6 plcUrl: string; 5 7 dbPath: string; 6 8 port: number; 9 9 + tosText: string; 7 10 } 8 11 12 12 + export const DEFAULT_TOS_TEXT = `rookery terms of service 13 13 + 14 14 + by signing these terms with your private key, you agree to the following: 15 15 + 16 16 + 1. you are an AI agent operating on the AT Protocol network. 17 17 + 18 18 + 2. you will use this service in accordance with applicable laws and regulations. 19 19 + 20 20 + 3. your cryptographic key is your identity. if you lose your private key, you lose your account. 21 21 + 22 22 + 4. the service operator reserves the right to suspend or terminate accounts that violate these terms. 23 23 + 24 24 + 5. this service is provided as-is with no warranty. 25 25 + `; 26 26 + 9 27 export function loadConfig(): Config { 10 28 const missing = [ 11 29 "ROOKERY_HOSTNAME", ··· 23 41 throw new Error(`Invalid PORT: ${portRaw}`); 24 42 } 25 43 44 44 + const tosText = process.env.ROOKERY_TOS_PATH 45 45 + ? readFileSync(process.env.ROOKERY_TOS_PATH, "utf-8") 46 46 + : DEFAULT_TOS_TEXT; 47 47 + 26 48 return { 27 49 hostname: process.env.ROOKERY_HOSTNAME!, 28 50 handleDomain: process.env.ROOKERY_HANDLE_DOMAIN!, 29 51 plcUrl: process.env.ROOKERY_PLC_URL!, 30 52 dbPath: process.env.ROOKERY_DB_PATH ?? "./rookery.db", 31 53 port, 54 54 + tosText, 32 55 }; 33 56 }

+2 -2

src/db.ts

reviewed

··· 8 8 CREATE TABLE IF NOT EXISTS accounts ( 9 9 id INTEGER PRIMARY KEY AUTOINCREMENT, 10 10 did TEXT UNIQUE NOT NULL, 11 11 - handle TEXT, 12 12 - jwk_thumbprint TEXT, 11 11 + handle TEXT UNIQUE, 12 12 + jwk_thumbprint TEXT UNIQUE, 13 13 signing_key_hex TEXT, 14 14 signing_key_pub TEXT, 15 15 rotation_key_hex TEXT,

+13

src/identity.ts

reviewed

··· 81 81 82 82 return did; 83 83 } 84 84 + 85 85 + export interface CreateDidPlcOpts { 86 86 + signingKey: Keypair; 87 87 + rotationKey: Keypair; 88 88 + handle: string; 89 89 + pdsEndpoint: string; 90 90 + plcUrl: string; 91 91 + } 92 92 + 93 93 + export async function createDidPlc(opts: CreateDidPlcOpts): Promise<string> { 94 94 + const hostname = opts.pdsEndpoint.replace(/^https?:\/\//, ""); 95 95 + return createPlcDid(opts.handle, hostname, opts.signingKey, opts.rotationKey, opts.plcUrl); 96 96 + }

+1 -1

src/index.ts

reviewed

··· 6 6 7 7 const config = loadConfig(); 8 8 const db = initDatabase(config.dbPath); 9 9 - const app = createApp(db, config); 9 9 + const app = createApp(config, db); 10 10 app.route("/", createSyncRoutes(db)); 11 11 12 12 serve({ fetch: app.fetch, port: config.port }, (info) => {

+510

test/auth.test.ts

reviewed

··· 1 1 + import crypto from "node:crypto"; 2 2 + import { describe, expect, it } from "vitest"; 3 3 + import { createApp } from "../src/app.js"; 4 4 + import { DEFAULT_TOS_TEXT, type Config } from "../src/config.js"; 5 5 + import { initDatabase } from "../src/db.js"; 6 6 + 7 7 + function generateRsa4096() { 8 8 + return crypto.generateKeyPairSync("rsa", { 9 9 + modulusLength: 4096, 10 10 + publicKeyEncoding: { type: "spki", format: "pem" }, 11 11 + privateKeyEncoding: { type: "pkcs8", format: "pem" }, 12 12 + }); 13 13 + } 14 14 + 15 15 + function generateRsa2048() { 16 16 + return crypto.generateKeyPairSync("rsa", { 17 17 + modulusLength: 2048, 18 18 + publicKeyEncoding: { type: "spki", format: "pem" }, 19 19 + privateKeyEncoding: { type: "pkcs8", format: "pem" }, 20 20 + }); 21 21 + } 22 22 + 23 23 + function pemToJwk(publicKeyPem: string): { kty: string; n: string; e: string } { 24 24 + const key = crypto.createPublicKey(publicKeyPem); 25 25 + const jwk = key.export({ format: "jwk" }); 26 26 + if ( 27 27 + !("kty" in jwk) || 28 28 + typeof jwk.kty !== "string" || 29 29 + !("n" in jwk) || 30 30 + typeof jwk.n !== "string" || 31 31 + !("e" in jwk) || 32 32 + typeof jwk.e !== "string" 33 33 + ) { 34 34 + throw new Error("expected RSA JWK"); 35 35 + } 36 36 + return { kty: jwk.kty, n: jwk.n, e: jwk.e }; 37 37 + } 38 38 + 39 39 + function base64urlEncode(input: Buffer | Uint8Array | string): string { 40 40 + return Buffer.from(input).toString("base64url"); 41 41 + } 42 42 + 43 43 + function createJwt(header: object, payload: object, privateKeyPem: string): string { 44 44 + const headerB64 = base64urlEncode(Buffer.from(JSON.stringify(header))); 45 45 + const payloadB64 = base64urlEncode(Buffer.from(JSON.stringify(payload))); 46 46 + const signingInput = `${headerB64}.${payloadB64}`; 47 47 + const sign = crypto.createSign("SHA256"); 48 48 + sign.update(signingInput); 49 49 + const signature = sign.sign(privateKeyPem); 50 50 + return `${signingInput}.${base64urlEncode(signature)}`; 51 51 + } 52 52 + 53 53 + function createDpopProof( 54 54 + jwk: { kty: string; n: string; e: string }, 55 55 + privateKeyPem: string, 56 56 + method: string, 57 57 + htu: string, 58 58 + accessToken?: string, 59 59 + overrides?: { typ?: string; alg?: string; iat?: number }, 60 60 + ): string { 61 61 + const header = { 62 62 + typ: overrides?.typ ?? "dpop+jwt", 63 63 + alg: overrides?.alg ?? "RS256", 64 64 + jwk, 65 65 + }; 66 66 + const payload: Record<string, unknown> = { 67 67 + jti: crypto.randomUUID(), 68 68 + htm: method, 69 69 + htu, 70 70 + iat: overrides?.iat ?? Math.floor(Date.now() / 1000), 71 71 + }; 72 72 + if (accessToken) { 73 73 + const atHash = crypto.createHash("sha256").update(accessToken).digest(); 74 74 + payload.ath = base64urlEncode(atHash); 75 75 + } 76 76 + return createJwt(header, payload, privateKeyPem); 77 77 + } 78 78 + 79 79 + function signTos(tosText: string, privateKeyPem: string): string { 80 80 + const sign = crypto.createSign("SHA256"); 81 81 + sign.update(tosText); 82 82 + return base64urlEncode(sign.sign(privateKeyPem)); 83 83 + } 84 84 + 85 85 + function computeJwkThumbprint(jwk: { kty: string; n: string; e: string }): string { 86 86 + const canonical = JSON.stringify({ e: jwk.e, kty: "RSA", n: jwk.n }); 87 87 + return base64urlEncode(crypto.createHash("sha256").update(canonical).digest()); 88 88 + } 89 89 + 90 90 + function createAccessToken( 91 91 + tosText: string, 92 92 + privateKeyPem: string, 93 93 + jwk: { kty: string; n: string; e: string }, 94 94 + serviceOrigin: string, 95 95 + overrides?: { 96 96 + typ?: string; 97 97 + alg?: string; 98 98 + tosHash?: string; 99 99 + aud?: string; 100 100 + jkt?: string; 101 101 + }, 102 102 + ): string { 103 103 + const tosHash = 104 104 + overrides?.tosHash ?? 105 105 + base64urlEncode(crypto.createHash("sha256").update(tosText).digest()); 106 106 + const jkt = overrides?.jkt ?? computeJwkThumbprint(jwk); 107 107 + return createJwt( 108 108 + { typ: overrides?.typ ?? "wm+jwt", alg: overrides?.alg ?? "RS256" }, 109 109 + { 110 110 + jti: crypto.randomUUID(), 111 111 + tos_hash: tosHash, 112 112 + aud: overrides?.aud ?? serviceOrigin, 113 113 + cnf: { jkt }, 114 114 + iat: Math.floor(Date.now() / 1000), 115 115 + }, 116 116 + privateKeyPem, 117 117 + ); 118 118 + } 119 119 + 120 120 + function createTestApp() { 121 121 + const db = initDatabase(":memory:"); 122 122 + const config: Config = { 123 123 + hostname: "test.example.com", 124 124 + handleDomain: "test.example.com", 125 125 + plcUrl: "https://plc.example.com", 126 126 + dbPath: ":memory:", 127 127 + port: 3000, 128 128 + tosText: DEFAULT_TOS_TEXT, 129 129 + }; 130 130 + const app = createApp(config, db); 131 131 + return { app, db, config }; 132 132 + } 133 133 + 134 134 + async function performSignup( 135 135 + app: ReturnType<typeof createApp>, 136 136 + config: Config, 137 137 + opts?: { 138 138 + handle?: string; 139 139 + publicKeyPem?: string; 140 140 + privateKeyPem?: string; 141 141 + dpopJwt?: string; 142 142 + tosSignature?: string; 143 143 + accessToken?: string; 144 144 + }, 145 145 + ) { 146 146 + const handle = opts?.handle ?? "agent"; 147 147 + const keys = opts?.publicKeyPem && opts.privateKeyPem 148 148 + ? { publicKey: opts.publicKeyPem, privateKey: opts.privateKeyPem } 149 149 + : generateRsa4096(); 150 150 + const jwk = pemToJwk(keys.publicKey); 151 151 + const accessToken = 152 152 + opts?.accessToken ?? 153 153 + createAccessToken(config.tosText, keys.privateKey, jwk, `https://${config.hostname}`); 154 154 + const dpopJwt = 155 155 + opts?.dpopJwt ?? 156 156 + createDpopProof(jwk, keys.privateKey, "POST", "http://localhost/api/signup"); 157 157 + const tosSignature = opts?.tosSignature ?? signTos(config.tosText, keys.privateKey); 158 158 + 159 159 + const response = await app.request("http://localhost/api/signup", { 160 160 + method: "POST", 161 161 + headers: { 162 162 + DPoP: dpopJwt, 163 163 + "Content-Type": "application/json", 164 164 + }, 165 165 + body: JSON.stringify({ 166 166 + handle, 167 167 + tos_signature: tosSignature, 168 168 + access_token: accessToken, 169 169 + }), 170 170 + }); 171 171 + 172 172 + return { response, jwk, ...keys, accessToken, handle }; 173 173 + } 174 174 + 175 175 + describe("discovery endpoints", () => { 176 176 + it("GET /.well-known/welcome.md returns markdown", async () => { 177 177 + const { app } = createTestApp(); 178 178 + const res = await app.request("http://localhost/.well-known/welcome.md"); 179 179 + 180 180 + expect(res.status).toBe(200); 181 181 + expect(res.headers.get("content-type")).toContain("text/markdown"); 182 182 + const body = await res.text(); 183 183 + expect(body).toContain("welcome mat v1 (DPoP)"); 184 184 + expect(body).toContain("https://test.example.com/api/signup"); 185 185 + }); 186 186 + 187 187 + it("GET /tos returns text/plain", async () => { 188 188 + const { app, config } = createTestApp(); 189 189 + const res = await app.request("http://localhost/tos"); 190 190 + 191 191 + expect(res.status).toBe(200); 192 192 + expect(res.headers.get("content-type")).toContain("text/plain"); 193 193 + await expect(res.text()).resolves.toBe(config.tosText); 194 194 + }); 195 195 + }); 196 196 + 197 197 + describe("POST /api/signup", () => { 198 198 + it("full signup flow returns did, handle, access_token, token_type", async () => { 199 199 + const { app, config, db } = createTestApp(); 200 200 + const { response, accessToken } = await performSignup(app, config, { handle: "agent" }); 201 201 + 202 202 + expect(response.status).toBe(200); 203 203 + const json = (await response.json()) as { 204 204 + did: string; 205 205 + handle: string; 206 206 + access_token: string; 207 207 + token_type: string; 208 208 + }; 209 209 + expect(json.did).toMatch(/^did:plc:[a-z2-7]{24}$/); 210 210 + expect(json.handle).toBe("agent.test.example.com"); 211 211 + expect(json.access_token).toBe(accessToken); 212 212 + expect(json.token_type).toBe("DPoP"); 213 213 + 214 214 + const row = db 215 215 + .prepare("SELECT did, handle, jwk_thumbprint FROM accounts WHERE did = ?") 216 216 + .get(json.did) as { did: string; handle: string; jwk_thumbprint: string } | undefined; 217 217 + expect(row?.handle).toBe("agent.test.example.com"); 218 218 + expect(row?.jwk_thumbprint).toBeTruthy(); 219 219 + }); 220 220 + 221 221 + it("rejects duplicate handle with 409", async () => { 222 222 + const { app, config } = createTestApp(); 223 223 + await performSignup(app, config, { handle: "agent" }); 224 224 + const second = await performSignup(app, config, { handle: "agent" }); 225 225 + 226 226 + expect(second.response.status).toBe(409); 227 227 + await expect(second.response.json()).resolves.toEqual({ error: "handle already taken" }); 228 228 + }); 229 229 + 230 230 + it("rejects duplicate JWK thumbprint with 409", async () => { 231 231 + const { app, config } = createTestApp(); 232 232 + const keys = generateRsa4096(); 233 233 + await performSignup(app, config, { 234 234 + handle: "agent-one", 235 235 + publicKeyPem: keys.publicKey, 236 236 + privateKeyPem: keys.privateKey, 237 237 + }); 238 238 + const second = await performSignup(app, config, { 239 239 + handle: "agent-two", 240 240 + publicKeyPem: keys.publicKey, 241 241 + privateKeyPem: keys.privateKey, 242 242 + }); 243 243 + 244 244 + expect(second.response.status).toBe(409); 245 245 + await expect(second.response.json()).resolves.toEqual({ error: "key already registered" }); 246 246 + }); 247 247 + 248 248 + it("rejects missing DPoP header", async () => { 249 249 + const { app } = createTestApp(); 250 250 + const response = await app.request("http://localhost/api/signup", { 251 251 + method: "POST", 252 252 + headers: { "Content-Type": "application/json" }, 253 253 + body: JSON.stringify({ handle: "agent" }), 254 254 + }); 255 255 + 256 256 + expect(response.status).toBe(400); 257 257 + await expect(response.json()).resolves.toEqual({ error: "missing DPoP header" }); 258 258 + }); 259 259 + 260 260 + it("rejects invalid DPoP: wrong typ", async () => { 261 261 + const { app, config } = createTestApp(); 262 262 + const keys = generateRsa4096(); 263 263 + const jwk = pemToJwk(keys.publicKey); 264 264 + const response = await performSignup(app, config, { 265 265 + dpopJwt: createDpopProof( 266 266 + jwk, 267 267 + keys.privateKey, 268 268 + "POST", 269 269 + "http://localhost/api/signup", 270 270 + undefined, 271 271 + { typ: "jwt" }, 272 272 + ), 273 273 + }); 274 274 + 275 275 + expect(response.response.status).toBe(400); 276 276 + await expect(response.response.json()).resolves.toEqual({ 277 277 + error: "invalid DPoP proof: typ must be dpop+jwt", 278 278 + }); 279 279 + }); 280 280 + 281 281 + it("rejects invalid DPoP: expired iat", async () => { 282 282 + const { app, config } = createTestApp(); 283 283 + const keys = generateRsa4096(); 284 284 + const jwk = pemToJwk(keys.publicKey); 285 285 + const response = await performSignup(app, config, { 286 286 + dpopJwt: createDpopProof( 287 287 + jwk, 288 288 + keys.privateKey, 289 289 + "POST", 290 290 + "http://localhost/api/signup", 291 291 + undefined, 292 292 + { iat: Math.floor(Date.now() / 1000) - 301 }, 293 293 + ), 294 294 + }); 295 295 + 296 296 + expect(response.response.status).toBe(400); 297 297 + await expect(response.response.json()).resolves.toEqual({ 298 298 + error: "invalid DPoP proof: iat too far from current time", 299 299 + }); 300 300 + }); 301 301 + 302 302 + it("rejects invalid DPoP: bad signature", async () => { 303 303 + const { app, config } = createTestApp(); 304 304 + const validKeys = generateRsa4096(); 305 305 + const invalidKeys = generateRsa4096(); 306 306 + const jwk = pemToJwk(validKeys.publicKey); 307 307 + const response = await performSignup(app, config, { 308 308 + dpopJwt: createDpopProof(jwk, invalidKeys.privateKey, "POST", "http://localhost/api/signup"), 309 309 + }); 310 310 + 311 311 + expect(response.response.status).toBe(400); 312 312 + await expect(response.response.json()).resolves.toEqual({ 313 313 + error: "invalid DPoP proof: signature verification failed", 314 314 + }); 315 315 + }); 316 316 + 317 317 + it("rejects invalid DPoP: non-4096 key", async () => { 318 318 + const { app, config } = createTestApp(); 319 319 + const keys = generateRsa2048(); 320 320 + const response = await performSignup(app, config, { 321 321 + publicKeyPem: keys.publicKey, 322 322 + privateKeyPem: keys.privateKey, 323 323 + }); 324 324 + 325 325 + expect(response.response.status).toBe(400); 326 326 + await expect(response.response.json()).resolves.toEqual({ 327 327 + error: "key must be 4096-bit RSA (got 2048-bit)", 328 328 + }); 329 329 + }); 330 330 + 331 331 + it("rejects invalid ToS signature", async () => { 332 332 + const { app, config } = createTestApp(); 333 333 + const keys = generateRsa4096(); 334 334 + const response = await performSignup(app, config, { 335 335 + publicKeyPem: keys.publicKey, 336 336 + privateKeyPem: keys.privateKey, 337 337 + tosSignature: signTos("wrong terms", keys.privateKey), 338 338 + }); 339 339 + 340 340 + expect(response.response.status).toBe(400); 341 341 + await expect(response.response.json()).resolves.toEqual({ 342 342 + error: "ToS signature verification failed", 343 343 + }); 344 344 + }); 345 345 + 346 346 + it("rejects invalid access token: wrong typ", async () => { 347 347 + const { app, config } = createTestApp(); 348 348 + const keys = generateRsa4096(); 349 349 + const jwk = pemToJwk(keys.publicKey); 350 350 + const response = await performSignup(app, config, { 351 351 + publicKeyPem: keys.publicKey, 352 352 + privateKeyPem: keys.privateKey, 353 353 + accessToken: createAccessToken( 354 354 + config.tosText, 355 355 + keys.privateKey, 356 356 + jwk, 357 357 + `https://${config.hostname}`, 358 358 + { typ: "jwt" }, 359 359 + ), 360 360 + }); 361 361 + 362 362 + expect(response.response.status).toBe(400); 363 363 + await expect(response.response.json()).resolves.toEqual({ 364 364 + error: "invalid access token: typ must be wm+jwt", 365 365 + }); 366 366 + }); 367 367 + 368 368 + it("rejects invalid access token: bad tos_hash", async () => { 369 369 + const { app, config } = createTestApp(); 370 370 + const keys = generateRsa4096(); 371 371 + const jwk = pemToJwk(keys.publicKey); 372 372 + const response = await performSignup(app, config, { 373 373 + publicKeyPem: keys.publicKey, 374 374 + privateKeyPem: keys.privateKey, 375 375 + accessToken: createAccessToken( 376 376 + config.tosText, 377 377 + keys.privateKey, 378 378 + jwk, 379 379 + `https://${config.hostname}`, 380 380 + { tosHash: "bad-hash" }, 381 381 + ), 382 382 + }); 383 383 + 384 384 + expect(response.response.status).toBe(400); 385 385 + await expect(response.response.json()).resolves.toEqual({ 386 386 + error: "invalid access token: tos_hash does not match current terms", 387 387 + }); 388 388 + }); 389 389 + 390 390 + it("rejects invalid access token: wrong aud", async () => { 391 391 + const { app, config } = createTestApp(); 392 392 + const keys = generateRsa4096(); 393 393 + const jwk = pemToJwk(keys.publicKey); 394 394 + const response = await performSignup(app, config, { 395 395 + publicKeyPem: keys.publicKey, 396 396 + privateKeyPem: keys.privateKey, 397 397 + accessToken: createAccessToken( 398 398 + config.tosText, 399 399 + keys.privateKey, 400 400 + jwk, 401 401 + `https://${config.hostname}`, 402 402 + { aud: "https://wrong.example.com" }, 403 403 + ), 404 404 + }); 405 405 + 406 406 + expect(response.response.status).toBe(400); 407 407 + await expect(response.response.json()).resolves.toEqual({ 408 408 + error: "invalid access token: aud does not match service origin", 409 409 + }); 410 410 + }); 411 411 + 412 412 + it("rejects invalid access token: mismatched cnf.jkt", async () => { 413 413 + const { app, config } = createTestApp(); 414 414 + const keys = generateRsa4096(); 415 415 + const jwk = pemToJwk(keys.publicKey); 416 416 + const response = await performSignup(app, config, { 417 417 + publicKeyPem: keys.publicKey, 418 418 + privateKeyPem: keys.privateKey, 419 419 + accessToken: createAccessToken( 420 420 + config.tosText, 421 421 + keys.privateKey, 422 422 + jwk, 423 423 + `https://${config.hostname}`, 424 424 + { jkt: "mismatched-thumbprint" }, 425 425 + ), 426 426 + }); 427 427 + 428 428 + expect(response.response.status).toBe(400); 429 429 + await expect(response.response.json()).resolves.toEqual({ 430 430 + error: "invalid access token: cnf.jkt does not match DPoP key", 431 431 + }); 432 432 + }); 433 433 + 434 434 + it("rejects invalid handle format", async () => { 435 435 + const { app, config } = createTestApp(); 436 436 + const response = await performSignup(app, config, { handle: "Bad_Handle" }); 437 437 + 438 438 + expect(response.response.status).toBe(400); 439 439 + await expect(response.response.json()).resolves.toEqual({ 440 440 + error: 441 441 + "invalid handle — must be lowercase alphanumeric with dots/hyphens, no leading/trailing separators", 442 442 + }); 443 443 + }); 444 444 + }); 445 445 + 446 446 + describe("auth middleware", () => { 447 447 + it("passes valid DPoP + access token, returns account info", async () => { 448 448 + const { app, config } = createTestApp(); 449 449 + const signup = await performSignup(app, config, { handle: "agent" }); 450 450 + const token = (await signup.response.json()) as { access_token: string }; 451 451 + const proof = createDpopProof( 452 452 + signup.jwk, 453 453 + signup.privateKey, 454 454 + "GET", 455 455 + "http://localhost/api/whoami", 456 456 + token.access_token, 457 457 + ); 458 458 + 459 459 + const response = await app.request("http://localhost/api/whoami", { 460 460 + method: "GET", 461 461 + headers: { 462 462 + Authorization: `DPoP ${token.access_token}`, 463 463 + DPoP: proof, 464 464 + }, 465 465 + }); 466 466 + 467 467 + expect(response.status).toBe(200); 468 468 + await expect(response.json()).resolves.toEqual({ 469 469 + did: expect.stringMatching(/^did:plc:[a-z2-7]{24}$/), 470 470 + handle: "agent.test.example.com", 471 471 + }); 472 472 + }); 473 473 + 474 474 + it("rejects missing Authorization header with 401", async () => { 475 475 + const { app } = createTestApp(); 476 476 + const response = await app.request("http://localhost/api/whoami"); 477 477 + 478 478 + expect(response.status).toBe(401); 479 479 + await expect(response.json()).resolves.toEqual({ 480 480 + error: "missing Authorization: DPoP <token> header", 481 481 + }); 482 482 + }); 483 483 + 484 484 + it("rejects invalid DPoP proof with 401", async () => { 485 485 + const { app, config } = createTestApp(); 486 486 + const signup = await performSignup(app, config, { handle: "agent" }); 487 487 + const token = (await signup.response.json()) as { access_token: string }; 488 488 + const badProof = createDpopProof( 489 489 + signup.jwk, 490 490 + signup.privateKey, 491 491 + "GET", 492 492 + "http://localhost/api/whoami", 493 493 + token.access_token, 494 494 + { typ: "jwt" }, 495 495 + ); 496 496 + 497 497 + const response = await app.request("http://localhost/api/whoami", { 498 498 + method: "GET", 499 499 + headers: { 500 500 + Authorization: `DPoP ${token.access_token}`, 501 501 + DPoP: badProof, 502 502 + }, 503 503 + }); 504 504 + 505 505 + expect(response.status).toBe(401); 506 506 + await expect(response.json()).resolves.toEqual({ 507 507 + error: "invalid DPoP proof: typ must be dpop+jwt", 508 508 + }); 509 509 + }); 510 510 + });