Skip to content

Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.

🔒 Limit guest poll creation per IP per day (#3480)

Luke Vella9a67d6ce004f
diff --git a/apps/web/src/app/api/trpc/[trpc]/route.ts b/apps/web/src/app/api/trpc/[trpc]/route.ts
index bdaa7c8ef..c2ee896eb 100644
--- a/apps/web/src/app/api/trpc/[trpc]/route.ts
+++ b/apps/web/src/app/api/trpc/[trpc]/route.ts
@@ -12,7 +12,7 @@ import { appRouter } from "@/trpc/routers";
const handler = async (req: NextRequest) => {
const session = await getSession();
- const ip = ipAddress(req) ?? "127.0.0.1";
+ const ip = ipAddress(req);
const ja4Digest = req.headers.get("x-vercel-ja4-digest") ?? undefined;
const startTime = Date.now();
const event = createWideEvent({
@@ -41,12 +41,13 @@ const handler = async (req: NextRequest) => {
createContext: async () => {
const locale = await getLocale();
- const identifier = session?.user?.id ?? ja4Digest ?? ip;
+ const identifier = session?.user?.id ?? ja4Digest ?? ip ?? "127.0.0.1";
return {
user: session?.user,
locale,
identifier,
+ ip,
event,
} satisfies TRPCContext;
},
diff --git a/apps/web/src/trpc/context.ts b/apps/web/src/trpc/context.ts
index d5b560924..045eebe3a 100644
--- a/apps/web/src/trpc/context.ts
+++ b/apps/web/src/trpc/context.ts
@@ -5,5 +5,6 @@ export type TRPCContext = {
user?: UserDTO;
locale?: string;
identifier?: string;
+ ip?: string;
event?: WideEvent;
};
diff --git a/apps/web/src/trpc/init.ts b/apps/web/src/trpc/init.ts
new file mode 100644
index 000000000..1d3acfcc9
--- /dev/null
+++ b/apps/web/src/trpc/init.ts
@@ -0,0 +1,18 @@
+import { initTRPC } from "@trpc/server";
+import superjson from "superjson";
+import { AppError } from "@/lib/errors/app-error";
+import type { TRPCContext } from "./context";
+
+export const t = initTRPC.context<TRPCContext>().create({
+ transformer: superjson,
+ errorFormatter({ shape, error }) {
+ return {
+ ...shape,
+ data: {
+ ...shape.data,
+ appError:
+ error.cause instanceof AppError ? error.cause.code : undefined,
+ },
+ };
+ },
+});
diff --git a/apps/web/src/trpc/rate-limit.test.ts b/apps/web/src/trpc/rate-limit.test.ts
new file mode 100644
index 000000000..fc484767c
--- /dev/null
+++ b/apps/web/src/trpc/rate-limit.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/env", () => ({ env: {} }));
+
+import type { UserDTO } from "@/features/user/schema";
+import { t } from "./init";
+import { createGuestIpRateLimitMiddleware } from "./rate-limit";
+
+const createRouter = () =>
+ t.router({
+ create: t.procedure
+ .use(
+ createGuestIpRateLimitMiddleware({
+ name: "create_poll",
+ requests: 3,
+ duration: "1 d",
+ }),
+ )
+ .mutation(() => "created"),
+ });
+
+const guest = (id: string) => ({ id, isGuest: true }) as UserDTO;
+const member = (id: string) => ({ id, isGuest: false }) as UserDTO;
+
+describe("createGuestIpRateLimitMiddleware", () => {
+ it("refuses guests from one address past the cap, whatever their session", async () => {
+ const router = createRouter();
+
+ for (let i = 0; i < 3; i++) {
+ const caller = router.createCaller({
+ user: guest(`g${i}`),
+ ip: "1.2.3.4",
+ });
+ await expect(caller.create()).resolves.toBe("created");
+ }
+
+ const fresh = router.createCaller({ user: guest("g9"), ip: "1.2.3.4" });
+ await expect(fresh.create()).rejects.toMatchObject({
+ code: "TOO_MANY_REQUESTS",
+ });
+
+ const elsewhere = router.createCaller({ user: guest("g9"), ip: "5.6.7.8" });
+ await expect(elsewhere.create()).resolves.toBe("created");
+ });
+
+ it("does not limit registered users", async () => {
+ const router = createRouter();
+ const caller = router.createCaller({ user: member("u1"), ip: "1.2.3.4" });
+
+ for (let i = 0; i < 5; i++) {
+ await expect(caller.create()).resolves.toBe("created");
+ }
+ });
+
+ it("does not limit guests with no known address", async () => {
+ const router = createRouter();
+ const caller = router.createCaller({ user: guest("g1") });
+
+ for (let i = 0; i < 5; i++) {
+ await expect(caller.create()).resolves.toBe("created");
+ }
+ });
+});
diff --git a/apps/web/src/trpc/rate-limit.ts b/apps/web/src/trpc/rate-limit.ts
new file mode 100644
index 000000000..87d4851a2
--- /dev/null
+++ b/apps/web/src/trpc/rate-limit.ts
@@ -0,0 +1,86 @@
+import { TRPCError } from "@trpc/server";
+import { AppError } from "@/lib/errors/app-error";
+import type { Duration } from "@/lib/rate-limit";
+import { createRateLimitGuard, createRatelimit } from "@/lib/rate-limit";
+import { t } from "./init";
+
+export const createRateLimitMiddleware = (
+ name: string,
+ requests: number,
+ duration: "1 m" | "1 h",
+) => {
+ const ratelimit = createRatelimit(requests, duration);
+
+ return t.middleware(async ({ ctx, next }) => {
+ if (ctx.event) {
+ ctx.event.rateLimiter = ratelimit?.name ?? "none";
+ }
+
+ if (!ratelimit) {
+ return next();
+ }
+
+ if (!ctx.identifier) {
+ throw new TRPCError({
+ code: "INTERNAL_SERVER_ERROR",
+ message: "Failed to get identifier",
+ });
+ }
+
+ const { success, remainingPoints } = await ratelimit.limit(
+ `${name}:${ctx.identifier}`,
+ );
+
+ if (ctx.event) {
+ ctx.event.rateLimiterRemainingPoints = remainingPoints;
+ }
+
+ if (!success) {
+ throw new TRPCError({
+ code: "TOO_MANY_REQUESTS",
+ message: "Too many requests",
+ });
+ }
+
+ return next();
+ });
+};
+
+/**
+ * Limits guests per client address. A guest's user id is a cookie, so a
+ * per-user limit resets with a cleared cookie; the address does not.
+ * Registered users pass through. An unknown address is not limited, so
+ * unrelated visitors never share one bucket.
+ */
+export const createGuestIpRateLimitMiddleware = ({
+ name,
+ requests,
+ duration,
+}: {
+ name: string;
+ requests: number;
+ duration: Duration;
+}) => {
+ const guard = createRateLimitGuard(requests, duration);
+
+ return t.middleware(async ({ ctx, next }) => {
+ if (!ctx.user?.isGuest || !ctx.ip) {
+ return next();
+ }
+
+ try {
+ await guard(`${name}:guest_ip:${ctx.ip}`, ctx.event);
+ } catch (error) {
+ if (error instanceof AppError && error.code === "TOO_MANY_REQUESTS") {
+ throw new TRPCError({
+ code: "TOO_MANY_REQUESTS",
+ message: "Too many requests",
+ cause: error,
+ });
+ }
+ throw error;
+ }
+
+ return next();
+ });
+};
diff --git a/apps/web/src/trpc/routers/auth.ts b/apps/web/src/trpc/routers/auth.ts
index fbc8e84b9..4c1d71a50 100644
--- a/apps/web/src/trpc/routers/auth.ts
+++ b/apps/web/src/trpc/routers/auth.ts
@@ -1,7 +1,8 @@
import { prisma } from "@rallly/database";
import * as z from "zod";
-import { createRateLimitMiddleware, publicProcedure, router } from "../trpc";
+import { createRateLimitMiddleware } from "../rate-limit";
+import { publicProcedure, router } from "../trpc";
export const auth = router({
getLoginMethod: publicProcedure
diff --git a/apps/web/src/trpc/routers/polls.ts b/apps/web/src/trpc/routers/polls.ts
index 6473594a8..f834bc8c4 100644
--- a/apps/web/src/trpc/routers/polls.ts
+++ b/apps/web/src/trpc/routers/polls.ts
@@ -61,7 +61,10 @@ import { AppError } from "@/lib/errors/app-error";
import { identifyGroup, track } from "@/lib/posthog";
import { createIcsEvent } from "@/lib/utils/ics";
import {
+ createGuestIpRateLimitMiddleware,
createRateLimitMiddleware,
+} from "../rate-limit";
+import {
possiblyPublicProcedure,
privateProcedure,
publicProcedure,
@@ -75,6 +78,16 @@ import { timeZoneInput } from "./polls/schema";
const collapseNewlines = (s: string) => s.replace(/\n{3,}/g, "\n\n");
+// A guest's id is a cookie, so the hourly per-user limit resets with a
+// cleared cookie. Only about 700 guests create 4 or more polls in a month,
+// so a daily cap of 20 per address touches nobody real and leaves room for
+// offices and campuses where many guests share one address.
+const guestPollCreationIpLimit = createGuestIpRateLimitMiddleware({
+ name: "create_poll",
+ requests: 20,
+ duration: "1 d",
+});
+
// Mirrors the auto-close-polls house-keeping task: an option ends at
// start + duration, with all-day options (duration 0) treated as 24h.
const optionEndsInFuture = (option: { startTime: Date; duration: number }) =>
@@ -231,6 +244,7 @@ export const polls = router({
)
.use(requireUserMiddleware)
.use(createRateLimitMiddleware("create_poll", 20, "1 h"))
+ .use(guestPollCreationIpLimit)
.mutation(async ({ ctx, input }) => {
const activeSpace = ctx.user.isGuest
? null
diff --git a/apps/web/src/trpc/trpc.ts b/apps/web/src/trpc/trpc.ts
index 2552b4009..45b2654ad 100644
--- a/apps/web/src/trpc/trpc.ts
+++ b/apps/web/src/trpc/trpc.ts
@@ -1,6 +1,5 @@
import { prisma } from "@rallly/database";
-import { initTRPC, TRPCError } from "@trpc/server";
-import superjson from "superjson";
+import { TRPCError } from "@trpc/server";
import { isQuickCreateEnabled } from "@/features/quick-create/constants";
import { getActiveSpaceForUser } from "@/features/space/data";
import { createSpaceContentScope } from "@/features/space/utils";
@@ -8,22 +7,7 @@ import { createUserDTO } from "@/features/user/data";
import { signOut } from "@/lib/auth";
import { AppError } from "@/lib/errors/app-error";
import { isMaintenanceActiveForRequest } from "@/lib/maintenance-server";
-import { createRatelimit } from "@/lib/rate-limit";
-import type { TRPCContext } from "./context";
-
-const t = initTRPC.context<TRPCContext>().create({
- transformer: superjson,
- errorFormatter({ shape, error }) {
- return {
- ...shape,
- data: {
- ...shape.data,
- appError:
- error.cause instanceof AppError ? error.cause.code : undefined,
- },
- };
- },
-});
+import { t } from "./init";
export const router = t.router;
@@ -183,46 +167,4 @@ export const spaceOwnerProcedure = spaceProcedure.use(async ({ ctx, next }) => {
return next();
});
-export const createRateLimitMiddleware = (
- name: string,
- requests: number,
- duration: "1 m" | "1 h",
-) => {
- const ratelimit = createRatelimit(requests, duration);
-
- return middleware(async ({ ctx, next }) => {
- if (ctx.event) {
- ctx.event.rateLimiter = ratelimit?.name ?? "none";
- }
-
- if (!ratelimit) {
- return next();
- }
-
- if (!ctx.identifier) {
- throw new TRPCError({
- code: "INTERNAL_SERVER_ERROR",
- message: "Failed to get identifier",
- });
- }
-
- const { success, remainingPoints } = await ratelimit.limit(
- `${name}:${ctx.identifier}`,
- );
-
- if (ctx.event) {
- ctx.event.rateLimiterRemainingPoints = remainingPoints;
- }
-
- if (!success) {
- throw new TRPCError({
- code: "TOO_MANY_REQUESTS",
- message: "Too many requests",
- });
- }
-
- return next();
- });
-};
-
export const mergeRouters = t.mergeRouters;