@weave_protocol/mund 0.1.0

package/src/analyzers/exfiltration-detector.ts

@@ -0,0 +1,257 @@
+/**
+ * Mund - The Guardian Protocol
+ * Exfiltration Detector - Detects data exfiltration attempts
+ */
+
+import { 
+  type DetectionRule, 
+  type SecurityIssue, 
+  type IAnalyzer,
+  type IssueLocation 
+} from '../types.js';
+import { DANGEROUS_URL_PATTERNS } from '../constants.js';
+
+export class ExfiltrationDetector implements IAnalyzer {
+  name = 'ExfiltrationDetector';
+  type = 'exfiltration';
+
+  async analyze(content: string, rules: DetectionRule[]): Promise<SecurityIssue[]> {
+    const issues: SecurityIssue[] = [];
+    const exfilRules = rules.filter(r => r.type === 'exfiltration' && r.enabled);
+
+    // Pattern-based detection
+    for (const rule of exfilRules) {
+      if (!rule.pattern) continue;
+
+      try {
+        const regex = new RegExp(rule.pattern, 'gi');
+        let match: RegExpExecArray | null;
+
+        while ((match = regex.exec(content)) !== null) {
+          const matchText = match[0];
+          const location = this.getLocation(content, match.index, matchText.length);
+          
+          issues.push({
+            rule_id: rule.id,
+            rule_name: rule.name,
+            type: rule.type,
+            severity: rule.severity,
+            action: rule.action,
+            match: this.truncateMatch(matchText),
+            location,
+            suggestion: this.getSuggestion(rule.id)
+          });
+        }
+      } catch (error) {
+        console.error(`Invalid regex pattern in rule ${rule.id}:`, error);
+      }
+    }
+
+    // URL extraction and analysis
+    const urlIssues = this.analyzeURLs(content);
+    issues.push(...urlIssues);
+
+    // Data encoding detection
+    const encodingIssues = this.detectSuspiciousEncoding(content);
+    issues.push(...encodingIssues);
+
+    return issues;
+  }
+
+  /**
+   * Extract and analyze URLs in content
+   */
+  private analyzeURLs(content: string): SecurityIssue[] {
+    const issues: SecurityIssue[] = [];
+    
+    // URL regex pattern
+    const urlRegex = /https?:\/\/[^\s"'<>)}\]]+/gi;
+    let match: RegExpExecArray | null;
+
+    while ((match = urlRegex.exec(content)) !== null) {
+      const url = match[0];
+      const location = this.getLocation(content, match.index, url.length);
+
+      // Check against dangerous patterns
+      for (const pattern of DANGEROUS_URL_PATTERNS) {
+        if (pattern.test(url)) {
+          issues.push({
+            rule_id: 'dangerous_url',
+            rule_name: 'Dangerous URL Detected',
+            type: 'exfiltration',
+            severity: 'high',
+            action: 'alert',
+            match: this.truncateURL(url),
+            location,
+            suggestion: 'This URL points to a service commonly used for data exfiltration. Verify the destination is legitimate.'
+          });
+          break;
+        }
+      }
+
+      // Check for IP-based URLs
+      if (/^https?:\/\/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.test(url)) {
+        issues.push({
+          rule_id: 'ip_based_url',
+          rule_name: 'IP-Based URL',
+          type: 'exfiltration',
+          severity: 'medium',
+          action: 'alert',
+          match: this.truncateURL(url),
+          location,
+          suggestion: 'IP-based URLs can bypass domain-based security controls. Verify this is a legitimate destination.'
+        });
+      }
+
+      // Check for data URLs
+      if (/^data:/i.test(url)) {
+        issues.push({
+          rule_id: 'data_url',
+          rule_name: 'Data URL Detected',
+          type: 'exfiltration',
+          severity: 'medium',
+          action: 'alert',
+          match: this.truncateURL(url),
+          location,
+          suggestion: 'Data URLs can encode and transfer arbitrary content. Review the embedded data.'
+        });
+      }
+    }
+
+    return issues;
+  }
+
+  /**
+   * Detect suspicious data encoding patterns
+   */
+  private detectSuspiciousEncoding(content: string): SecurityIssue[] {
+    const issues: SecurityIssue[] = [];
+
+    // Large base64 blocks (potential data exfiltration)
+    const base64Regex = /[A-Za-z0-9+/]{100,}={0,2}/g;
+    let match: RegExpExecArray | null;
+
+    while ((match = base64Regex.exec(content)) !== null) {
+      const encoded = match[0];
+      
+      // Verify it's likely base64 (not just a long alphanumeric string)
+      if (this.isLikelyBase64(encoded)) {
+        const location = this.getLocation(content, match.index, encoded.length);
+        
+        issues.push({
+          rule_id: 'large_base64_block',
+          rule_name: 'Large Base64 Block',
+          type: 'exfiltration',
+          severity: 'medium',
+          action: 'log',
+          match: `Base64 block (${encoded.length} chars)`,
+          location,
+          suggestion: 'Large base64 encoded blocks may contain exfiltrated data. Review the decoded content.'
+        });
+      }
+    }
+
+    // Hex-encoded data blocks
+    const hexRegex = /(?:0x)?[0-9a-fA-F]{200,}/g;
+    while ((match = hexRegex.exec(content)) !== null) {
+      const encoded = match[0];
+      const location = this.getLocation(content, match.index, encoded.length);
+      
+      issues.push({
+        rule_id: 'large_hex_block',
+        rule_name: 'Large Hex-Encoded Block',
+        type: 'exfiltration',
+        severity: 'low',
+        action: 'log',
+        match: `Hex block (${encoded.length} chars)`,
+        location,
+        suggestion: 'Large hex-encoded blocks may contain encoded data. Review the decoded content.'
+      });
+    }
+
+    return issues;
+  }
+
+  /**
+   * Check if string is likely base64
+   */
+  private isLikelyBase64(str: string): boolean {
+    // Check character distribution
+    const chars = new Set(str.replace(/=/g, ''));
+    
+    // Base64 uses a specific character set
+    const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    for (const char of chars) {
+      if (!base64Chars.includes(char)) return false;
+    }
+
+    // Check if it decodes to valid content
+    try {
+      const decoded = Buffer.from(str, 'base64').toString('utf8');
+      // Check if decoded content has a reasonable ratio of printable characters
+      const printable = decoded.replace(/[^\x20-\x7E]/g, '').length;
+      return printable / decoded.length > 0.7;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Calculate location within content
+   */
+  private getLocation(content: string, start: number, length: number): IssueLocation {
+    const end = start + length;
+    const lines = content.substring(0, start).split('\n');
+    const line = lines.length;
+    const column = lines[lines.length - 1].length + 1;
+    return { start, end, line, column };
+  }
+
+  /**
+   * Truncate match for display
+   */
+  private truncateMatch(match: string, maxLength = 100): string {
+    if (match.length <= maxLength) return match;
+    return match.substring(0, maxLength) + '...';
+  }
+
+  /**
+   * Truncate URL for display (hide potential sensitive parts)
+   */
+  private truncateURL(url: string, maxLength = 80): string {
+    try {
+      const parsed = new URL(url);
+      const base = `${parsed.protocol}//${parsed.host}`;
+      
+      if (base.length >= maxLength) {
+        return base.substring(0, maxLength) + '...';
+      }
+      
+      const remainingLength = maxLength - base.length;
+      const path = parsed.pathname + parsed.search;
+      
+      if (path.length > remainingLength) {
+        return base + path.substring(0, remainingLength) + '...';
+      }
+      
+      return base + path;
+    } catch {
+      return url.substring(0, maxLength) + (url.length > maxLength ? '...' : '');
+    }
+  }
+
+  /**
+   * Get remediation suggestion
+   */
+  private getSuggestion(ruleId: string): string {
+    const suggestions: Record<string, string> = {
+      suspicious_url_post: 'This code sends data to a service commonly used for data capture. Verify the destination.',
+      dns_exfiltration: 'DNS queries with encoded data can be used for exfiltration. Monitor and restrict DNS access.',
+      data_encoding_suspicious: 'Encoding sensitive data before transmission may indicate exfiltration. Review the purpose.',
+    };
+
+    return suggestions[ruleId] || 'Review this pattern for potential data exfiltration.';
+  }
+}
+
+export default ExfiltrationDetector;

package/src/analyzers/index.ts

@@ -0,0 +1,74 @@
+/**
+ * Mund - The Guardian Protocol
+ * Analyzers Index - Exports all analyzer modules
+ */
+
+export { SecretScanner } from './secret-scanner.js';
+export { PIIDetector } from './pii-detector.js';
+export { CodeAnalyzer } from './code-analyzer.js';
+export { InjectionDetector } from './injection-detector.js';
+export { ExfiltrationDetector } from './exfiltration-detector.js';
+
+import { SecretScanner } from './secret-scanner.js';
+import { PIIDetector } from './pii-detector.js';
+import { CodeAnalyzer } from './code-analyzer.js';
+import { InjectionDetector } from './injection-detector.js';
+import { ExfiltrationDetector } from './exfiltration-detector.js';
+import type { IAnalyzer } from '../types.js';
+
+/**
+ * Get all available analyzers
+ */
+export function getAnalyzers(): IAnalyzer[] {
+  return [
+    new SecretScanner(),
+    new PIIDetector(),
+    new CodeAnalyzer(),
+    new InjectionDetector(),
+    new ExfiltrationDetector()
+  ];
+}
+
+/**
+ * Create analyzer engine that runs all analyzers
+ */
+export class AnalyzerEngine {
+  private analyzers: IAnalyzer[];
+
+  constructor(analyzers?: IAnalyzer[]) {
+    this.analyzers = analyzers || getAnalyzers();
+  }
+
+  async analyzeAll(content: string, rules: import('../types.js').DetectionRule[]): Promise<import('../types.js').SecurityIssue[]> {
+    const allIssues: import('../types.js').SecurityIssue[] = [];
+
+    for (const analyzer of this.analyzers) {
+      try {
+        const issues = await analyzer.analyze(content, rules);
+        allIssues.push(...issues);
+      } catch (error) {
+        console.error(`Error in analyzer ${analyzer.name}:`, error);
+      }
+    }
+
+    // Sort by severity (critical first)
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+    allIssues.sort((a, b) => 
+      (severityOrder[a.severity] || 4) - (severityOrder[b.severity] || 4)
+    );
+
+    return allIssues;
+  }
+
+  addAnalyzer(analyzer: IAnalyzer): void {
+    this.analyzers.push(analyzer);
+  }
+
+  removeAnalyzer(name: string): void {
+    this.analyzers = this.analyzers.filter(a => a.name !== name);
+  }
+
+  getAnalyzerNames(): string[] {
+    return this.analyzers.map(a => a.name);
+  }
+}

package/src/analyzers/injection-detector.ts

@@ -0,0 +1,191 @@
+/**
+ * Mund - The Guardian Protocol
+ * Injection Detector - Detects prompt injection attempts
+ */
+
+import { 
+  type DetectionRule, 
+  type SecurityIssue, 
+  type IAnalyzer,
+  type IssueLocation 
+} from '../types.js';
+
+export class InjectionDetector implements IAnalyzer {
+  name = 'InjectionDetector';
+  type = 'injection';
+
+  async analyze(content: string, rules: DetectionRule[]): Promise<SecurityIssue[]> {
+    const issues: SecurityIssue[] = [];
+    const injectionRules = rules.filter(r => r.type === 'injection' && r.enabled);
+
+    // Normalize content for detection
+    const normalizedContent = this.normalizeContent(content);
+
+    for (const rule of injectionRules) {
+      if (!rule.pattern) continue;
+
+      try {
+        const regex = new RegExp(rule.pattern, 'gi');
+        let match: RegExpExecArray | null;
+
+        while ((match = regex.exec(normalizedContent)) !== null) {
+          const matchText = match[0];
+          const location = this.getLocation(content, match.index, matchText.length);
+          
+          issues.push({
+            rule_id: rule.id,
+            rule_name: rule.name,
+            type: rule.type,
+            severity: rule.severity,
+            action: rule.action,
+            match: this.sanitizeMatch(matchText),
+            location,
+            suggestion: this.getSuggestion(rule.id)
+          });
+        }
+      } catch (error) {
+        console.error(`Invalid regex pattern in rule ${rule.id}:`, error);
+      }
+    }
+
+    // Additional heuristic checks
+    const heuristicIssues = this.heuristicAnalysis(content);
+    issues.push(...heuristicIssues);
+
+    return issues;
+  }
+
+  /**
+   * Normalize content to detect obfuscated injection attempts
+   */
+  private normalizeContent(content: string): string {
+    return content
+      // Remove zero-width characters
+      .replace(/[\u200B-\u200D\uFEFF]/g, '')
+      // Normalize Unicode variations
+      .normalize('NFKC')
+      // Collapse multiple spaces
+      .replace(/\s+/g, ' ')
+      // Remove common obfuscation characters
+      .replace(/[^\w\s.,!?'"()-]/g, ' ');
+  }
+
+  /**
+   * Heuristic analysis for injection patterns
+   */
+  private heuristicAnalysis(content: string): SecurityIssue[] {
+    const issues: SecurityIssue[] = [];
+
+    // Check for role switching attempts
+    const roleSwitchPatterns = [
+      /\bsystem\s*:\s*you\s+are/i,
+      /\bassistant\s*:\s*i\s+(will|can|am)/i,
+      /\[system\]/i,
+      /\<\|?system\|?\>/i,
+      /\{system_prompt\}/i,
+    ];
+
+    for (const pattern of roleSwitchPatterns) {
+      const match = content.match(pattern);
+      if (match) {
+        issues.push({
+          rule_id: 'heuristic_role_switch',
+          rule_name: 'Role Switching Attempt',
+          type: 'injection',
+          severity: 'high' as const,
+          action: 'alert' as const,
+          match: this.sanitizeMatch(match[0]),
+          suggestion: 'This content appears to attempt to inject role-switching markers.'
+        });
+      }
+    }
+
+    // Check for markdown/code injection that might alter rendering
+    const markdownPatterns = [
+      /```\s*system/i,
+      /\<script\>/i,
+      /javascript:/i,
+      /data:text\/html/i,
+    ];
+
+    for (const pattern of markdownPatterns) {
+      const match = content.match(pattern);
+      if (match) {
+        issues.push({
+          rule_id: 'heuristic_markup_injection',
+          rule_name: 'Markup Injection Attempt',
+          type: 'injection',
+          severity: 'medium' as const,
+          action: 'alert' as const,
+          match: this.sanitizeMatch(match[0]),
+          suggestion: 'This content contains potentially dangerous markup or code injection.'
+        });
+      }
+    }
+
+    // Check for excessive special characters (potential obfuscation)
+    const specialCharRatio = this.calculateSpecialCharRatio(content);
+    if (specialCharRatio > 0.3 && content.length > 50) {
+      issues.push({
+        rule_id: 'heuristic_obfuscation',
+        rule_name: 'Potential Obfuscation',
+        type: 'injection',
+        severity: 'low' as const,
+        action: 'log' as const,
+        match: `Special character ratio: ${(specialCharRatio * 100).toFixed(1)}%`,
+        suggestion: 'This content has an unusually high ratio of special characters, which may indicate obfuscation.'
+      });
+    }
+
+    return issues;
+  }
+
+  /**
+   * Calculate ratio of special characters
+   */
+  private calculateSpecialCharRatio(content: string): number {
+    if (content.length === 0) return 0;
+    const specialChars = content.replace(/[\w\s]/g, '').length;
+    return specialChars / content.length;
+  }
+
+  /**
+   * Calculate location within content
+   */
+  private getLocation(content: string, start: number, length: number): IssueLocation {
+    const end = start + length;
+    const lines = content.substring(0, start).split('\n');
+    const line = lines.length;
+    const column = lines[lines.length - 1].length + 1;
+    return { start, end, line, column };
+  }
+
+  /**
+   * Sanitize match for safe display
+   */
+  private sanitizeMatch(match: string, maxLength = 100): string {
+    const sanitized = match
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;');
+    
+    if (sanitized.length <= maxLength) return sanitized;
+    return sanitized.substring(0, maxLength) + '...';
+  }
+
+  /**
+   * Get remediation suggestion
+   */
+  private getSuggestion(ruleId: string): string {
+    const suggestions: Record<string, string> = {
+      prompt_injection_ignore: 'This content attempts to make the AI ignore its instructions. Do not process user inputs that contain such patterns.',
+      prompt_injection_jailbreak: 'This appears to be a jailbreak attempt. Such content should be filtered or rejected.',
+      prompt_injection_system: 'This content attempts to extract system prompts. Do not reveal system instructions.',
+      prompt_injection_roleplay: 'This content attempts to manipulate behavior through roleplay. Apply content filtering.',
+    };
+
+    return suggestions[ruleId] || 'This content shows signs of injection attacks. Review and sanitize input.';
+  }
+}
+
+export default InjectionDetector;