Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -1,41 +1,167 @@
import { createHash } from "node:crypto";
import { cache } from "~/utils/cache.server";
import { getTrustedClientIp } from "~/utils/server/IpUtils";
import { MemoryAdapter, type SharedStore } from "@hivegrid/shared-store";
import { getPseudonymousAuthBucketKey, type AuthThrottleAction } from "~/services/auth/auth-rate-limit-key.server";
import { getSharedStore } from "~/shared-store.server";
import { createScopedLogger } from "~/utils/logger.server";
type AuthRateLimitOptions = {
request: Request;
action: "login" | "forgot-password" | "reset-password" | "mfa";
action: AuthThrottleAction;
identifier?: string | null;
limit: number;
windowMs: number;
/** Optional hard cap shared by all trusted clients for one identifier. Null
* keeps the per-client and client/identifier pair buckets while disabling
* the globally poisonable identifier bucket for unauthenticated input. */
identifierLimit?: number | null;
/** Optional hard cap for one trusted client across identifier churn. */
clientLimit?: number;
};
type AuthRateLimitResult =
| { allowed: true }
| { allowed: false; retryAfterSeconds: number };
type AuthRateLimitResult = { allowed: true } | { allowed: false; retryAfterSeconds: number };
export function getAuthRateLimitKey({ request, action, identifier }: Omit<AuthRateLimitOptions, "limit" | "windowMs">) {
// Trusted proxy-set header only; leftmost X-Forwarded-For / X-Client-IP are
// client-spoofable and would let an attacker reset this per-IP auth throttle.
const ipAddress = getTrustedClientIp(request) || "unknown";
const normalizedIdentifier = identifier?.trim().toLowerCase() ?? "";
const digest = createHash("sha256").update(`${action}:${ipAddress}:${normalizedIdentifier}`).digest("hex");
return `auth-rate-limit:${action}:${digest}`;
}
const authRateLimitLogger = createScopedLogger("auth-rate-limit");
const MAX_WINDOW_MS = 24 * 60 * 60 * 1000;
const MAX_LIMIT = 10_000;
const PER_CLIENT_LIMIT_FACTOR = 10;
const PER_IDENTIFIER_LIMIT_FACTOR = 3;
export function checkAuthRateLimit(options: AuthRateLimitOptions): AuthRateLimitResult {
const key = getAuthRateLimitKey(options);
const now = Date.now();
const entry = cache.get(key)?.value as { count: number; resetAt: number } | undefined;
const current = entry && entry.resetAt > now ? entry : { count: 0, resetAt: now + options.windowMs };
const count = current.count + 1;
const AUTH_RATE_LIMIT_SCRIPT = `
local window = tonumber(ARGV[1])
local clientMax = tonumber(ARGV[2])
local identifierMax = tonumber(ARGV[3])
local pairMax = tonumber(ARGV[4])
local hasIdentifier = ARGV[5] == '1'
cache.set(key, { value: { count, resetAt: current.resetAt }, metadata: { createdTime: now } }, { ttl: Math.max(1, current.resetAt - now) });
local function reserve(key)
local current = redis.call('INCR', key)
if current == 1 then
redis.call('EXPIRE', key, window)
end
local ttl = redis.call('TTL', key)
if ttl <= 0 then ttl = window end
return current, ttl
end
if (count > options.limit) {
return { allowed: false, retryAfterSeconds: Math.max(1, Math.ceil((current.resetAt - now) / 1000)) };
local clientCurrent, clientTtl = reserve(KEYS[1])
if clientCurrent > clientMax then
return { 0, clientTtl, 1 }
end
if hasIdentifier then
local identifierCurrent, identifierTtl = reserve(KEYS[2])
if identifierCurrent > identifierMax then
return { 0, identifierTtl, 2 }
end
end
local pairCurrent, pairTtl = reserve(KEYS[3])
if pairCurrent > pairMax then
return { 0, pairTtl, 3 }
end
return { 1, pairTtl, 0 }
`;
MemoryAdapter.registerScript(AUTH_RATE_LIMIT_SCRIPT, async (adapter, keys, args) => {
const windowSeconds = Number.parseInt(args[0] ?? "0", 10);
const clientMax = Number.parseInt(args[1] ?? "0", 10);
const identifierMax = Number.parseInt(args[2] ?? "0", 10);
const pairMax = Number.parseInt(args[3] ?? "0", 10);
const hasIdentifier = args[4] === "1";
const reserve = async (key: string) => {
const current = await adapter.incr(key);
if (current === 1) await adapter.expire(key, windowSeconds);
return current;
};
const clientCurrent = await reserve(keys[0]);
if (clientCurrent > clientMax) return [0, windowSeconds, 1];
if (hasIdentifier) {
const identifierCurrent = await reserve(keys[1]);
if (identifierCurrent > identifierMax) return [0, windowSeconds, 2];
}
const pairCurrent = await reserve(keys[2]);
if (pairCurrent > pairMax) return [0, windowSeconds, 3];
return [1, windowSeconds, 0];
});
return { allowed: true };
let storeFactory: () => SharedStore = () => getSharedStore();
function normalizeWindowSeconds(windowMs: number): number {
if (!Number.isSafeInteger(windowMs) || windowMs <= 0 || windowMs > MAX_WINDOW_MS) {
throw new Error("Auth rate-limit window is outside the supported range.");
}
return Math.ceil(windowMs / 1000);
}
function validateLimit(limit: number): void {
if (!Number.isSafeInteger(limit) || limit <= 0 || limit > MAX_LIMIT) {
throw new Error("Auth rate-limit maximum is outside the supported range.");
}
}
/**
* Returns a stable, pseudonymous bucket key. The HMAC keeps enumerable email
* addresses and client IPs out of Redis keys and diagnostic snapshots.
*/
export function getAuthRateLimitKey({ request, action, identifier }: Omit<AuthRateLimitOptions, "limit" | "windowMs">) {
return getPseudonymousAuthBucketKey({ request, action, identifier });
}
/**
* Atomically reserves an auth attempt in the shared store. Store and
* configuration failures deny the request: losing the distributed throttle
* must never silently turn into an unlimited authentication endpoint.
*/
export async function checkAuthRateLimit(options: AuthRateLimitOptions): Promise<AuthRateLimitResult> {
const safeRetryAfterSeconds = Math.max(1, Math.ceil(Math.min(Math.max(options.windowMs || 0, 1000), MAX_WINDOW_MS) / 1000));
try {
validateLimit(options.limit);
if (options.identifierLimit !== undefined && options.identifierLimit !== null) validateLimit(options.identifierLimit);
if (options.clientLimit !== undefined) validateLimit(options.clientLimit);
const windowSeconds = normalizeWindowSeconds(options.windowMs);
const store = storeFactory();
const normalizedIdentifier = options.identifier?.trim().toLowerCase() ?? "";
const keyPrefix = `rl:auth:v1:${options.action}:${options.limit}:${windowSeconds}`;
const clientKey = getPseudonymousAuthBucketKey({ ...options, scope: "client" });
const identifierKey = getPseudonymousAuthBucketKey({ ...options, scope: "identifier" });
const pairKey = getPseudonymousAuthBucketKey({ ...options, scope: "pair" });
const clientLimit = options.clientLimit ?? Math.min(MAX_LIMIT, options.limit * PER_CLIENT_LIMIT_FACTOR);
const identifierLimit = options.identifierLimit ?? Math.min(MAX_LIMIT, options.limit * PER_IDENTIFIER_LIMIT_FACTOR);
const reserveIdentifierBucket = normalizedIdentifier.length > 0 && options.identifierLimit !== null;
const result = (await store.eval(
AUTH_RATE_LIMIT_SCRIPT,
[`${keyPrefix}:client:${clientKey}`, `${keyPrefix}:identifier:${identifierKey}`, `${keyPrefix}:pair:${pairKey}`],
[String(windowSeconds), String(clientLimit), String(identifierLimit), String(options.limit), reserveIdentifierBucket ? "1" : "0"]
)) as [number | string, number | string, number | string] | undefined;
const allowed = Number(result?.[0]) === 1;
const ttl = Number(result?.[1]);
if (!allowed) {
return {
allowed: false,
retryAfterSeconds: Number.isFinite(ttl) && ttl > 0 ? Math.ceil(ttl) : windowSeconds,
};
}
return { allowed: true };
} catch (error) {
authRateLimitLogger.error(
{
event: "auth.rate_limit.store_unavailable",
action: options.action,
errorName: error instanceof Error ? error.name : "UnknownError",
},
"Auth rate-limit reservation failed; request denied"
);
return { allowed: false, retryAfterSeconds: safeRetryAfterSeconds };
}
}
export function __setAuthRateLimitStoreForTests(store: SharedStore): void {
storeFactory = () => store;
}
export function __resetAuthRateLimitStoreForTests(): void {
storeFactory = () => getSharedStore();
}