fix: prevent Squid config injection via domain inputs

Malicious input to --allow-domains or --allow-urls containing
whitespace, newlines, or null bytes could inject arbitrary
directives into the generated squid.conf. This adds:

1. Character validation in validateDomainOrPattern() rejects
   whitespace, null bytes, quotes, semicolons, backslashes
2. assertSafeForSquidConfig() in squid-config.ts validates
   every value before interpolation into squid.conf
3. URL pattern validation in cli.ts for --allow-urls

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Mossaka

src/cli.ts

@@ -1639,6 +1639,13 @@ program
           }
         }
 
+        // Reject whitespace and null bytes to prevent Squid config injection
+        if (/[\s\0]/.test(url)) {
+          logger.error(`URL pattern contains illegal whitespace or control characters: ${JSON.stringify(url)}`);
+          logger.error('URL patterns must not contain spaces, tabs, newlines, or null bytes.');
+          process.exit(1);
+        }
+
         // Ensure pattern has a path component (not just domain)
         const urlWithoutScheme = url.replace(/^https:\/\//, '');
         if (!urlWithoutScheme.includes('/')) {

src/domain-patterns.test.ts

@@ -232,6 +232,70 @@ describe('validateDomainOrPattern', () => {
     });
   });
 
+  describe('rejects injection characters', () => {
+    it('should reject LF in domain', () => {
+      expect(() => validateDomainOrPattern('evil.com\nhttp_access allow all')).toThrow('contains invalid character');
+    });
+
+    it('should reject CR in domain', () => {
+      expect(() => validateDomainOrPattern('evil.com\rhttp_access allow all')).toThrow('contains invalid character');
+    });
+
+    it('should reject CRLF in domain', () => {
+      expect(() => validateDomainOrPattern('evil.com\r\nhttp_access allow all')).toThrow('contains invalid character');
+    });
+
+    it('should reject null bytes', () => {
+      expect(() => validateDomainOrPattern('evil.com\0')).toThrow('contains invalid character');
+    });
+
+    it('should reject tabs', () => {
+      expect(() => validateDomainOrPattern('evil.com\tallowed')).toThrow('contains invalid character');
+    });
+
+    it('should reject interior spaces', () => {
+      expect(() => validateDomainOrPattern('evil.com allowed')).toThrow('contains invalid character');
+    });
+
+    it('should reject space-separated domains (ACL token injection)', () => {
+      expect(() => validateDomainOrPattern('.evil.com .attacker.com')).toThrow('contains invalid character');
+    });
+
+    it('should reject semicolons', () => {
+      expect(() => validateDomainOrPattern('evil.com;rm -rf')).toThrow('contains invalid character');
+    });
+
+    it('should reject hash characters', () => {
+      expect(() => validateDomainOrPattern('evil.com#comment')).toThrow('contains invalid character');
+    });
+
+    it('should reject backslashes', () => {
+      expect(() => validateDomainOrPattern('evil.com\\n')).toThrow('contains invalid character');
+    });
+
+    it('should reject single quotes', () => {
+      expect(() => validateDomainOrPattern("evil.com'")).toThrow('contains invalid character');
+    });
+
+    it('should reject double quotes', () => {
+      expect(() => validateDomainOrPattern('evil.com"')).toThrow('contains invalid character');
+    });
+  });
+
+  describe('accepts valid DNS names with underscores', () => {
+    it('should accept _dmarc.example.com', () => {
+      expect(() => validateDomainOrPattern('_dmarc.example.com')).not.toThrow();
+    });
+
+    it('should accept _acme-challenge.example.com', () => {
+      expect(() => validateDomainOrPattern('_acme-challenge.example.com')).not.toThrow();
+    });
+
+    it('should accept _srv._tcp.example.com', () => {
+      expect(() => validateDomainOrPattern('_srv._tcp.example.com')).not.toThrow();
+    });
+  });
+
   describe('protocol-prefixed domains', () => {
     it('should accept valid http:// prefixed domains', () => {
       expect(() => validateDomainOrPattern('http://github.com')).not.toThrow();

src/domain-patterns.ts

@@ -151,6 +151,23 @@ export function validateDomainOrPattern(input: string): void {
     throw new Error('Domain cannot be empty');
   }
 
+  // Reject characters that could inject Squid config directives or tokens.
+  // Squid config is line-and-space delimited, so whitespace (space, tab, CR, LF),
+  // null bytes, and comment/quote characters are dangerous.
+  // This prevents Squid config injection via --allow-domains.
+  const DANGEROUS_CHARS = /[\s\0"'`;#\\]/;
+  const match = trimmed.match(DANGEROUS_CHARS);
+  if (match) {
+    const charCode = match[0].charCodeAt(0);
+    const charDesc = charCode <= 0x20 || charCode === 0x7f
+      ? `U+${charCode.toString(16).padStart(4, '0')}`
+      : `'${match[0]}'`;
+    throw new Error(
+      `Invalid domain '${trimmed}': contains invalid character ${charDesc}. ` +
+      `Domain names must not contain whitespace, quotes, semicolons, backslashes, or control characters.`
+    );
+  }
+
   // Check for overly broad patterns
   if (trimmed === '*') {
     throw new Error("Pattern '*' matches all domains and is not allowed");

src/squid-config.test.ts

@@ -1,6 +1,44 @@
 import { generateSquidConfig, generatePolicyManifest } from './squid-config';
 import { SquidConfig } from './types';
 
+describe('defense-in-depth: rejects injected values', () => {
+  const defaultPort = 3128;
+
+  it('should reject newline in domain via validateDomainOrPattern', () => {
+    expect(() => {
+      generateSquidConfig({
+        domains: ['evil.com\nhttp_access allow all'],
+        port: defaultPort,
+      });
+    }).toThrow();
+  });
+
+  it('should reject newline in URL pattern', () => {
+    // URL patterns go through generateSslBumpSection, which interpolates into squid.conf.
+    // The assertSafeForSquidConfig guard should catch this.
+    const maliciousPattern = 'https://evil.com/path\nhttp_access allow all';
+    expect(() => {
+      generateSquidConfig({
+        domains: ['evil.com'],
+        port: defaultPort,
+        sslBump: true,
+        caFiles: { certPath: '/tmp/cert.pem', keyPath: '/tmp/key.pem' },
+        sslDbPath: '/tmp/ssl_db',
+        urlPatterns: [maliciousPattern],
+      });
+    }).toThrow(/SECURITY|whitespace/);
+  });
+
+  it('should reject space in domain (ACL token injection)', () => {
+    expect(() => {
+      generateSquidConfig({
+        domains: ['.evil.com .attacker.com'],
+        port: defaultPort,
+      });
+    }).toThrow();
+  });
+});
+
 // Pattern constant for the safer domain character class (matches the implementation)
 const DOMAIN_CHAR_PATTERN = '[a-zA-Z0-9.-]*';
 

src/squid-config.ts

@@ -53,10 +53,26 @@ interface PatternsByProtocol {
   both: DomainPattern[];
 }
 
+/**
+ * Defense-in-depth: assert a domain/regex/URL-pattern string is safe for Squid config interpolation.
+ * Rejects any whitespace (\s covers space, tab, CR, LF, Unicode whitespace) and null bytes.
+ * Squid config is line-and-space delimited, so any whitespace could inject directives or tokens.
+ */
+function assertSafeForSquidConfig(value: string): string {
+  if (/[\s\0]/.test(value)) {
+    throw new Error(
+      `SECURITY: Domain or pattern contains whitespace or null bytes and cannot be ` +
+      `interpolated into squid.conf: ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
+
 /**
  * Helper to add leading dot to domain for Squid subdomain matching
  */
 function formatDomainForSquid(domain: string): string {
+  assertSafeForSquidConfig(domain);
   return domain.startsWith('.') ? domain : `.${domain}`;
 }
 
@@ -151,7 +167,7 @@ function generateSslBumpSection(
   let urlAccessRules = '';
   if (urlPatterns && urlPatterns.length > 0) {
     const urlAcls = urlPatterns
-      .map((pattern, i) => `acl allowed_url_${i} url_regex ${pattern}`)
+      .map((pattern, i) => `acl allowed_url_${i} url_regex ${assertSafeForSquidConfig(pattern)}`)
       .join('\n');
     urlAclSection = `\n# URL pattern ACLs for HTTPS content inspection\n${urlAcls}\n`;
 
@@ -262,7 +278,7 @@ export function generateSquidConfig(config: SquidConfig): string {
     aclLines.push('');
     aclLines.push('# ACL definitions for allowed domain patterns (HTTP and HTTPS)');
     for (const p of patternsByProto.both) {
-      aclLines.push(`acl allowed_domains_regex dstdom_regex -i ${p.regex}`);
+      aclLines.push(`acl allowed_domains_regex dstdom_regex -i ${assertSafeForSquidConfig(p.regex)}`);
     }
   }
 
@@ -280,7 +296,7 @@ export function generateSquidConfig(config: SquidConfig): string {
     aclLines.push('');
     aclLines.push('# ACL definitions for HTTP-only domain patterns');
     for (const p of patternsByProto.http) {
-      aclLines.push(`acl allowed_http_only_regex dstdom_regex -i ${p.regex}`);
+      aclLines.push(`acl allowed_http_only_regex dstdom_regex -i ${assertSafeForSquidConfig(p.regex)}`);
     }
   }
 
@@ -298,7 +314,7 @@ export function generateSquidConfig(config: SquidConfig): string {
     aclLines.push('');
     aclLines.push('# ACL definitions for HTTPS-only domain patterns');
     for (const p of patternsByProto.https) {
-      aclLines.push(`acl allowed_https_only_regex dstdom_regex -i ${p.regex}`);
+      aclLines.push(`acl allowed_https_only_regex dstdom_regex -i ${assertSafeForSquidConfig(p.regex)}`);
     }
   }
 
@@ -362,7 +378,7 @@ export function generateSquidConfig(config: SquidConfig): string {
       blockedAclLines.push('');
       blockedAclLines.push('# ACL definitions for blocked domain patterns (wildcard)');
       for (const p of blockedPatterns) {
-        blockedAclLines.push(`acl blocked_domains_regex dstdom_regex -i ${p.regex}`);
+        blockedAclLines.push(`acl blocked_domains_regex dstdom_regex -i ${assertSafeForSquidConfig(p.regex)}`);
       }
       blockedAccessRules.push('http_access deny blocked_domains_regex');
     }