Defensive

Author: stever

apps/gif-service/src/emulator.ts

@@ -242,6 +242,11 @@ export class Emulator {
         let trapCount = 0;
         while (status) {
             trapCount++;
+            // Bound the trap loop: a normal tape load fires a few hundred traps,
+            // so a runaway here is a malformed/hostile program, not real work.
+            if (trapCount > 20000) {
+                throw new Error('Too many tape traps in one frame');
+            }
             switch (status) {
                 case 1:
                     throw new Error('Unrecognized opcode');

apps/gif-service/src/gif-generator.ts

@@ -118,13 +118,22 @@ export class GIFGenerator {
         const staleStop = this.options.staleFrameThreshold;
         const tailFrames = 25; // ~0.5s of static tail kept for readability
 
+        // Hard wall-clock backstop independent of frame count: emulation is
+        // normally faster than real time, so generous headroom over the clip
+        // length still catches a pathologically slow program.
+        const renderDeadline = Date.now() + Math.max(this.options.maxDurationMs * 4, 60_000);
+
         const frames: Uint8Array[] = [];
         const audio: AudioFrame[] = [];
         let previousFrame: Uint8Array | null = null;
         let staleCount = 0;
         let lastChangeIndex = -1;
 
         for (let f = 0; f < maxFrames; f++) {
+            if (Date.now() > renderDeadline) {
+                console.warn(`Render wall-clock budget exceeded after ${f} frames; stopping`);
+                break;
+            }
             const frameBuffer = new Uint8Array(this.emulator.runFrame());
             frames.push(frameBuffer);
 

apps/gif-service/src/hasura.ts

@@ -5,29 +5,44 @@ import { CompileError } from './errors.js';
 // and call the compile / compileC actions. No admin secret is sent, so the
 // service keeps holding no secrets.
 const HASURA_URL = process.env.HASURA_URL ?? 'http://hasura:8080/v1/graphql';
+// Cap every Hasura call so a hung upstream compiler (zxbasic/z88dk) or a slow
+// lookup can't tie up a request indefinitely.
+const HASURA_TIMEOUT_MS = parseInt(process.env.HASURA_TIMEOUT_MS ?? '20000', 10);
 
 interface GraphQLResponse<T> {
     data?: T;
     errors?: Array<{ message: string }>;
 }
 
 async function gql<T>(query: string, variables: Record<string, unknown>): Promise<T> {
-    const res = await fetch(HASURA_URL, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ query, variables }),
-    });
-    if (!res.ok) {
-        throw new Error(`Hasura returned ${res.status}`);
-    }
-    const body = (await res.json()) as GraphQLResponse<T>;
-    if (body.errors?.length) {
-        throw new Error(body.errors.map((e) => e.message).join('; '));
-    }
-    if (!body.data) {
-        throw new Error('Hasura returned no data');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), HASURA_TIMEOUT_MS);
+    try {
+        const res = await fetch(HASURA_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query, variables }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`Hasura returned ${res.status}`);
+        }
+        const body = (await res.json()) as GraphQLResponse<T>;
+        if (body.errors?.length) {
+            throw new Error(body.errors.map((e) => e.message).join('; '));
+        }
+        if (!body.data) {
+            throw new Error('Hasura returned no data');
+        }
+        return body.data;
+    } catch (err) {
+        if (controller.signal.aborted) {
+            throw new Error(`Hasura request timed out after ${HASURA_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    } finally {
+        clearTimeout(timer);
     }
-    return body.data;
 }
 
 export interface ProjectRecord {

apps/mastodon-bot/src/config.ts

@@ -11,6 +11,7 @@ export const config = {
     pollIntervalMs: parseInt(process.env.POLL_INTERVAL_MS ?? '15000', 10),
     maxSeconds: parseInt(process.env.MAX_SECONDS ?? '30', 10),
     maxMediaBytes: parseInt(process.env.MAX_MEDIA_BYTES ?? '8000000', 10),
+    maxPerUserPerHour: parseInt(process.env.MAX_PER_USER_PER_HOUR ?? '10', 10),
     replyCaption: process.env.REPLY_CAPTION ?? '#ZXPlay',
     dryRun: process.env.DRY_RUN === 'true',
 };

apps/mastodon-bot/src/index.ts

@@ -2,6 +2,7 @@ import { config, assertRuntimeConfig } from './config.js';
 import { htmlToBasic } from './basic.js';
 import { extractProjectRef } from './project.js';
 import { parseDirectives } from './directives.js';
+import { allowRequest } from './ratelimit.js';
 import { sourceToMedia, projectToMedia } from './media.js';
 import { loadState, saveState } from './state.js';
 import {
@@ -44,6 +45,13 @@ async function handleMention(self: MastodonAccount, n: MastodonNotification): Pr
         return;
     }
 
+    // Rate-limit per account to blunt a flood of mentions. Skip silently rather
+    // than reply, so an attacker can't turn the limit into reply amplification.
+    if (!allowRequest(status.account.acct, config.maxPerUserPerHour)) {
+        console.log(`Mention ${n.id} from @${status.account.acct}: rate limit reached, skipping`);
+        return;
+    }
+
     const machineType = projectRef ? (projectRef.machineType ?? directives.machineType) : directives.machineType;
     const lang = directives.lang ?? 'basic';
     const projectPath = projectRef ? `${projectRef.userSlug}/${projectRef.projectSlug}` : '';

apps/mastodon-bot/src/ratelimit.ts

@@ -0,0 +1,21 @@
+// In-memory sliding-window rate limiter, keyed by account. State is per-process
+// (resets on restart), which is fine: the bot is a single instance and this only
+// needs to blunt a flood of mentions from one account, not enforce hard quotas.
+const hits = new Map<string, number[]>();
+const WINDOW_MS = 3_600_000; // one hour
+
+/**
+ * Record an attempt for `key` and report whether it is within `limit` over the
+ * past hour. Returns false (and does not record) once the limit is reached.
+ */
+export function allowRequest(key: string, limit: number): boolean {
+    const now = Date.now();
+    const recent = (hits.get(key) ?? []).filter((t) => now - t < WINDOW_MS);
+    if (recent.length >= limit) {
+        hits.set(key, recent);
+        return false;
+    }
+    recent.push(now);
+    hits.set(key, recent);
+    return true;
+}