fix: security audit — blossom SSRF protection, decode nsec safety, key zeroing, response size limits, comprehensive docs

Author: TheCryptoDonkey

src/social/blossom.ts

@@ -1,7 +1,7 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, statSync } from 'node:fs'
 import { createHash } from 'node:crypto'
+import { validatePublicUrl } from '../validation.js'
 import type { IdentityContext } from '../context.js'
-import type { RelayPool } from '../relay-pool.js'
 
 export interface BlobDescriptor {
   url: string
@@ -16,8 +16,13 @@ export async function handleBlossomUpload(
   ctx: IdentityContext,
   args: { server: string; filePath?: string; data?: Uint8Array; contentType?: string },
 ): Promise<BlobDescriptor> {
+  validatePublicUrl(args.server)
+  const MAX_UPLOAD = 100 * 1024 * 1024 // 100MB
+
   let body: Uint8Array
   if (args.filePath) {
+    const size = statSync(args.filePath).size
+    if (size > MAX_UPLOAD) throw new Error(`File too large: ${size} bytes (max ${MAX_UPLOAD})`)
     body = readFileSync(args.filePath)
   } else if (args.data) {
     body = args.data
@@ -66,6 +71,7 @@ export async function handleBlossomUpload(
 export async function handleBlossomList(
   args: { server: string; pubkeyHex: string },
 ): Promise<BlobDescriptor[]> {
+  validatePublicUrl(args.server)
   const serverUrl = args.server.replace(/\/$/, '')
   const response = await fetch(`${serverUrl}/list/${args.pubkeyHex}`, {
     headers: { Accept: 'application/json' },
@@ -80,6 +86,7 @@ export async function handleBlossomList(
 export async function handleBlossomDownload(
   args: { server: string; sha256: string },
 ): Promise<{ data: Uint8Array; contentType: string }> {
+  validatePublicUrl(args.server)
   const serverUrl = args.server.replace(/\/$/, '')
   const response = await fetch(`${serverUrl}/${args.sha256}`, {
     signal: AbortSignal.timeout(30_000),
@@ -96,6 +103,7 @@ export async function handleBlossomDelete(
   ctx: IdentityContext,
   args: { server: string; sha256: string },
 ): Promise<{ deleted: boolean }> {
+  validatePublicUrl(args.server)
   const now = Math.floor(Date.now() / 1000)
   const sign = ctx.getSigningFunction()
   const authEvent = await sign({

src/util/handlers.ts

@@ -20,8 +20,9 @@ export function handleDecode(input: string): DecodeResult {
   const decoded = decode(cleaned)
 
   if (decoded.type === 'nsec') {
-    // Return hex, not raw bytes
-    return { type: 'nsec', data: { hex: Buffer.from(decoded.data as Uint8Array).toString('hex') } }
+    // Never return private key — derive pubkey instead
+    const pubkey = getPublicKey(decoded.data as Uint8Array)
+    return { type: 'nsec', data: { pubkeyHex: pubkey, npub: npubEncode(pubkey), warning: 'Private key not returned for safety' } }
   }
 
   return { type: decoded.type, data: decoded.data }
@@ -173,8 +174,12 @@ export function handleKeyPublic(secret: string): { pubkeyHex: string; npub: stri
   } else {
     bytes = Buffer.from(secret, 'hex')
   }
-  const pubkeyHex = getPublicKey(bytes)
-  return { pubkeyHex, npub: npubEncode(pubkeyHex) }
+  try {
+    const pubkeyHex = getPublicKey(bytes)
+    return { pubkeyHex, npub: npubEncode(pubkeyHex) }
+  } finally {
+    bytes.fill(0)
+  }
 }
 
 // --- Encode nsec ---
@@ -200,6 +205,7 @@ export async function handleNipList(): Promise<Array<{ number: number; title: st
   })
   if (!response.ok) throw new Error(`Failed to fetch NIP list: ${response.status}`)
   const text = await response.text()
+  if (text.length > 1_048_576) throw new Error('NIP list response too large')
 
   const nips: Array<{ number: number; title: string }> = []
   const re = /- \[NIP-(\d+)\]\([^)]+\)\s*[-—:]+\s*(.+)/g
@@ -217,6 +223,7 @@ export async function handleNipShow(number: number): Promise<{ number: number; c
     signal: AbortSignal.timeout(10_000),
   })
   if (!response.ok) throw new Error(`NIP-${padded} not found: ${response.status}`)
-  const content = await response.text()
-  return { number, content }
+  const text = await response.text()
+  if (text.length > 1_048_576) throw new Error('NIP content too large')
+  return { number, content: text }
 }

src/util/tools.ts

@@ -151,7 +151,7 @@ export function registerUtilTools(server: McpServer, deps: ToolDeps): void {
   })
 
   server.registerTool('key_public', {
-    description: 'Derive a public key (hex + npub) from a secret key (nsec or hex).',
+    description: 'Derive a public key (hex + npub) from a secret key (nsec or hex). WARNING: the secret key is transmitted through the MCP transport — use only for local/trusted setups.',
     inputSchema: {
       secret: z.string().describe('Secret key as nsec or hex'),
     },
@@ -162,7 +162,7 @@ export function registerUtilTools(server: McpServer, deps: ToolDeps): void {
   })
 
   server.registerTool('encode_nsec', {
-    description: 'Encode a hex private key as a bech32 nsec.',
+    description: 'Encode a hex private key as a bech32 nsec. WARNING: private key material flows through the MCP transport.',
     inputSchema: { hex: z.string().regex(/^[0-9a-f]{64}$/).describe('Hex private key') },
     annotations: { readOnlyHint: true },
   }, async ({ hex }) => {

src/validation.ts

@@ -5,3 +5,23 @@ export const hexId = z.string().regex(/^[0-9a-f]{64}$/, 'Must be a 64-character
 
 /** Relay WebSocket URL — wss:// or ws:// only */
 export const relayUrl = z.string().regex(/^wss?:\/\//, 'Must be a wss:// or ws:// URL')
+
+/** HTTPS URL — no private networks */
+export const httpsUrl = z.string().regex(/^https?:\/\//, 'Must be an https:// URL')
+
+const PRIVATE_HOSTS = ['localhost', '[::1]', '169.254.169.254']
+const PRIVATE_PREFIXES = ['127.', '10.', '192.168.']
+const PRIVATE_REGEX = /^172\.(1[6-9]|2\d|3[01])\./
+
+/** Validate a URL is not pointing at private/internal networks */
+export function validatePublicUrl(url: string): void {
+  const parsed = new URL(url)
+  const host = parsed.hostname.toLowerCase()
+  if (
+    PRIVATE_HOSTS.includes(host) ||
+    PRIVATE_PREFIXES.some(p => host.startsWith(p)) ||
+    PRIVATE_REGEX.test(host)
+  ) {
+    throw new Error('URL must not point to private network addresses')
+  }
+}

test/util/handlers.test.ts

@@ -35,10 +35,13 @@ describe('util handlers', () => {
       expect(result.data).toBe(pk)
     })
 
-    it('decodes nsec to hex private key', () => {
+    it('decodes nsec — returns pubkey, not private key', () => {
       const result = handleDecode(nsec)
       expect(result.type).toBe('nsec')
-      expect((result.data as any).hex).toBe(skHex)
+      expect((result.data as any).pubkeyHex).toBe(pk)
+      expect((result.data as any).warning).toMatch(/not returned/)
+      // Must NOT contain the private key hex
+      expect(JSON.stringify(result)).not.toContain(skHex)
     })
 
     it('decodes note to hex event id', () => {
@@ -229,10 +232,11 @@ describe('util handlers', () => {
       expect(result).toMatch(/^nsec1/)
     })
 
-    it('round-trips with decode', () => {
+    it('round-trips with decode (returns pubkey, not hex)', () => {
       const encoded = handleEncodeNsec(skHex)
       const decoded = handleDecode(encoded)
-      expect((decoded.data as any).hex).toBe(skHex)
+      // decode now returns pubkey instead of private key
+      expect((decoded.data as any).pubkeyHex).toBe(pk)
     })
   })