Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

Security and validation

Edward Cuif5f0d65e5e1f
diff --git a/server/src/lib/dataValidation.ts b/server/src/lib/dataValidation.ts
new file mode 100644
index 000000000..50f9a1eff
--- /dev/null
+++ b/server/src/lib/dataValidation.ts
@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { SecurityValidator } from "./security.js";
+
+export class DataValidator {
+ private static readonly MAX_STRING_LENGTH = 1000;
+ private static readonly MAX_URL_LENGTH = 2000;
+ private static readonly VALID_LANGUAGES = new Set([
+ "en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "zh", "ar", "hi", "nl", "pl", "tr"
+ ]);
+
+ static readonly umamiEventSchema = z.object({
+ website_id: z.string().uuid(),
+ session_id: z.string().min(1).max(100),
+ visit_id: z.string().uuid(),
+ event_id: z.string().uuid(),
+ hostname: z.string().min(1).max(255).refine(SecurityValidator.validateDomain),
+ browser: z.string().max(50),
+ os: z.string().max(50),
+ device: z.string().max(50),
+ screen: z.string().regex(/^\d+x\d+$/).optional(),
+ language: z.string().max(10).refine(lang =>
+ this.VALID_LANGUAGES.has(lang.toLowerCase().split("-")[0])
+ ).optional(),
+ country: z.string().length(2).optional(),
+ region: z.string().max(100).optional(),
+ city: z.string().max(100).optional(),
+ url_path: z.string().max(this.MAX_URL_LENGTH).refine(path =>
+ path.startsWith("/") && !path.includes("..")
+ ),
+ url_query: z.string().max(this.MAX_URL_LENGTH).optional(),
+ referrer_domain: z.string().max(255).refine(domain =>
+ !domain || SecurityValidator.validateDomain(domain)
+ ).optional(),
+ page_title: z.string().max(this.MAX_STRING_LENGTH).transform(SecurityValidator.sanitizeString),
+ event_type: z.number().int().min(1).max(2),
+ event_name: z.string().max(100).transform(SecurityValidator.sanitizeString).optional(),
+ distinct_id: z.string().min(1).max(100),
+ created_at: z.string().refine(date => {
+ const timestamp = new Date(date);
+ return !isNaN(timestamp.getTime()) &&
+ timestamp <= new Date() &&
+ timestamp >= new Date("2020-01-01");
+ }),
+ });
+
+ static validateUmamiEvent(event: any): z.infer<typeof DataValidator.umamiEventSchema> {
+ return this.umamiEventSchema.parse(event);
+ }
+
+ static validateBatch(events: any[]): {
+ valid: any[];
+ invalid: Array<{ index: number; error: string }>;
+ } {
+ const valid: any[] = [];
+ const invalid: Array<{ index: number; error: string }> = [];
+
+ events.forEach((event, index) => {
+ try {
+ const validatedEvent = this.validateUmamiEvent(event);
+ valid.push(validatedEvent);
+ } catch (error) {
+ invalid.push({
+ index,
+ error: error instanceof z.ZodError
+ ? error.errors.map(e => `${e.path.join(".")}: ${e.message}`).join(", ")
+ : "error.message"
+ });
+ }
+ });
+
+ return { valid, invalid };
+ }
+}
diff --git a/server/src/lib/security.ts b/server/src/lib/security.ts
new file mode 100644
index 000000000..e62bb7ac7
--- /dev/null
+++ b/server/src/lib/security.ts
@@ -0,0 +1,68 @@
+export class SecurityValidator {
+ private static readonly DANGEROUS_PATTERNS = [
+ /script/i,
+ /javascript:/i,
+ /vbscript:/i,
+ /onload/i,
+ /onerror/i,
+ /eval\s*\(/i,
+ /expression\s*\(/i,
+ /<\s*iframe/i,
+ /<\s*object/i,
+ /<\s*embed/i,
+ /<\s*link/i,
+ /<\s*meta/i,
+ /<\s*style/i,
+ ];
+
+ static sanitizeString(value: string): string {
+ if (!value || typeof value !== "string") {
+ return "";
+ }
+
+ // Remove null bytes
+ value = value.replace(/\0/g, "");
+
+ // Remove control characters except tab, newline, and carriage return
+ value = value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+
+ // Check for dangerous patterns
+ for (const pattern of this.DANGEROUS_PATTERNS) {
+ if (pattern.test(value)) {
+ console.warn(`Potentially dangerous content detected: ${value.substring(0, 100)}`);
+ return "";
+ }
+ }
+
+ return value.trim();
+ }
+
+ static validateUrl(url: string): boolean {
+ try {
+ const parsed = new URL(url);
+ return ["http:", "https:"].includes(parsed.protocol);
+ } catch {
+ return false;
+ }
+ }
+
+ static validateDomain(domain: string): boolean {
+ const domainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+ return domainRegex.test(domain) && domain.length <= 253;
+ }
+
+ static validateFileSignature(buffer: Buffer, filename: string): boolean {
+ // Check if file is actually a CSV based on content
+ const csvSignatures = [
+ Buffer.from([0xEF, 0xBB, 0xBF]), // UTF-8 BOM
+ Buffer.from("sep="), // Excel CSV separator
+ ];
+
+ // Check for CSV-like content (basic heuristic)
+ const firstLine = buffer.subarray(0, 1024).toString("utf-8").split("\n")[0];
+ const hasCommas = firstLine.includes(",");
+ const hasHeaders = /^[a-zA-Z_][a-zA-Z0-9_,\s"]*$/.test(firstLine);
+
+ return hasCommas && hasHeaders;
+ }
+}