ai-warden 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-warden",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "AI security scanner - Detect prompt injection attacks before they reach production",
   "main": "src/scanner.js",
   "bin": {

package/src/cli.js

@@ -126,13 +126,23 @@ async function scanCommand(targetPath, options = {}) {
       scannedCount++;
 
       if (!result.passed) {
-        // Get ignored patterns for this file
-        const ignoredPatterns = ignoreParser.getIgnoredPatterns(file);
+        // Get ignored patterns for this file (with hash support)
+        const ignoreInfo = ignoreParser.getIgnoredPatterns(file, content);
         
-        // Filter out ignored patterns
-        const activeFindings = result.findings.filter(f => 
-          !ignoredPatterns.includes(f.id)
-        );
+        // Filter out ignored patterns (regular + hash-based)
+        const activeFindings = result.findings.filter(f => {
+          // Check regular ignore list
+          if (ignoreInfo.patterns.includes(f.id)) {
+            return false;
+          }
+          
+          // Check hash-based ignore (more secure)
+          if (ignoreParser.shouldIgnoreFindingWithHash(file, f, content)) {
+            return false;
+          }
+          
+          return true;
+        });
 
         if (activeFindings.length === 0) {
           // All findings are ignored
@@ -148,13 +158,15 @@ async function scanCommand(targetPath, options = {}) {
         
         if (options.verbose && activeFindings.length > 0) {
           activeFindings.slice(0, 3).forEach(f => {
-            console.log(`   - ${f.severity}: ${f.description}`);
+            const name = f.name || f.id || 'Unknown';
+            const match = f.match ? ` ("${f.match.substring(0, 40)}...")` : '';
+            console.log(`   - ${f.severity}: ${name}${match}`);
           });
         }
 
         // Interactive mode: prompt user
         if (interactivePrompt && activeFindings.length > 0) {
-          const action = await interactivePrompt.promptThreat(file, activeFindings[0]);
+          const action = await interactivePrompt.promptThreat(file, activeFindings[0], content);
           
           if (action === 'quit') {
             console.log('\n🛑 Scan aborted by user\n');

package/src/ignoreParser.js

@@ -1,10 +1,12 @@
 /**
  * .aiwardenignore Parser
  * Handles whitelist/ignore rules for files and patterns
+ * Supports hash-based verification for security
  */
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 
 class IgnoreParser {
   constructor(ignoreFilePath = '.aiwardenignore') {
@@ -33,12 +35,25 @@ class IgnoreParser {
 
       // Check if it's a file:pattern rule
       if (trimmed.includes(':')) {
-        const [filePath, patterns] = trimmed.split(':');
-        this.rules.push({
-          type: 'file-pattern',
-          filePath: filePath.trim(),
-          patterns: patterns.trim() === '*' ? '*' : patterns.trim().split(',').map(p => p.trim())
-        });
+        const parts = trimmed.split(':');
+        const filePath = parts[0].trim();
+        const patterns = parts[1].trim();
+        
+        // Check for hash-based rule: file:pattern:hash:abc123...
+        if (parts.length === 4 && parts[2] === 'hash') {
+          this.rules.push({
+            type: 'file-pattern-hash',
+            filePath,
+            patterns: patterns === '*' ? '*' : patterns.split(',').map(p => p.trim()),
+            hash: parts[3].trim()
+          });
+        } else {
+          this.rules.push({
+            type: 'file-pattern',
+            filePath,
+            patterns: patterns === '*' ? '*' : patterns.split(',').map(p => p.trim())
+          });
+        }
       } else {
         // It's a file/directory pattern
         this.rules.push({
@@ -72,21 +87,88 @@ class IgnoreParser {
   }
 
   /**
-   * Get patterns to ignore for a specific file
+   * Get patterns to ignore for a specific file (with hash verification)
+   * Returns object: { patterns: [...], requiresHashCheck: [...] }
    */
-  getIgnoredPatterns(filePath) {
+  getIgnoredPatterns(filePath, fileContent = null) {
     const normalized = path.normalize(filePath);
     const ignored = [];
+    const hashChecks = [];
 
     for (const rule of this.rules) {
       if (rule.type === 'file-pattern' && rule.patterns !== '*') {
         if (this.matchPath(normalized, rule.filePath)) {
           ignored.push(...rule.patterns);
         }
+      } else if (rule.type === 'file-pattern-hash') {
+        if (this.matchPath(normalized, rule.filePath)) {
+          // Hash-based rule requires content verification
+          hashChecks.push({
+            patterns: Array.isArray(rule.patterns) ? rule.patterns : [rule.patterns],
+            expectedHash: rule.hash
+          });
+        }
       }
     }
 
-    return ignored;
+    return { patterns: ignored, hashChecks };
+  }
+
+  /**
+   * Verify if a finding should be ignored based on hash
+   */
+  shouldIgnoreFindingWithHash(filePath, finding, fileContent) {
+    const normalized = path.normalize(filePath);
+    
+    for (const rule of this.rules) {
+      if (rule.type === 'file-pattern-hash' && this.matchPath(normalized, rule.filePath)) {
+        // Check if pattern matches
+        const patterns = Array.isArray(rule.patterns) ? rule.patterns : [rule.patterns];
+        if (patterns.includes(finding.id) || rule.patterns === '*') {
+          // Generate hash for this finding
+          const findingHash = this.generateFindingHash(filePath, finding, fileContent);
+          
+          // Compare with stored hash
+          if (findingHash === rule.hash) {
+            return true; // Hash matches, ignore this finding
+          }
+          // Hash doesn't match = code changed = don't ignore!
+        }
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Generate hash for a specific finding
+   * Hash includes: file path + pattern ID + matched content + surrounding context
+   */
+  generateFindingHash(filePath, finding, fileContent) {
+    // Create a unique fingerprint of this finding
+    const data = [
+      path.basename(filePath), // Just filename (not full path, more portable)
+      finding.id,
+      finding.match || '',
+      this.getContextAroundMatch(fileContent, finding.match, 50) // 50 chars context
+    ].join('::');
+    
+    return crypto.createHash('sha256').update(data).digest('hex').substring(0, 16); // Short hash
+  }
+
+  /**
+   * Get surrounding context for a match (for more specific hash)
+   */
+  getContextAroundMatch(content, match, contextSize = 50) {
+    if (!content || !match) return '';
+    
+    const index = content.indexOf(match);
+    if (index === -1) return '';
+    
+    const start = Math.max(0, index - contextSize);
+    const end = Math.min(content.length, index + match.length + contextSize);
+    
+    return content.substring(start, end);
   }
 
   /**
@@ -132,11 +214,24 @@ class IgnoreParser {
 
   /**
    * Add a new ignore rule and save to file
+   * @param {string} filePath - File to whitelist
+   * @param {string|array} patterns - Pattern IDs or '*'
+   * @param {object} options - { hash, finding, fileContent }
    */
-  addIgnoreRule(filePath, patterns = '*') {
-    const rule = patterns === '*' 
-      ? filePath 
-      : `${filePath}:${Array.isArray(patterns) ? patterns.join(',') : patterns}`;
+  addIgnoreRule(filePath, patterns = '*', options = {}) {
+    let rule;
+    
+    if (options.hash && options.finding && options.fileContent) {
+      // Hash-based rule
+      const hash = this.generateFindingHash(filePath, options.finding, options.fileContent);
+      const patternStr = Array.isArray(patterns) ? patterns.join(',') : patterns;
+      rule = `${filePath}:${patternStr}:hash:${hash}`;
+    } else {
+      // Regular rule
+      rule = patterns === '*' 
+        ? filePath 
+        : `${filePath}:${Array.isArray(patterns) ? patterns.join(',') : patterns}`;
+    }
 
     // Check if rule already exists
     const content = fs.existsSync(this.ignoreFilePath) 

package/src/interactivePrompt.js

@@ -13,8 +13,11 @@ class InteractivePrompt {
   /**
    * Prompt user what to do with a detected threat
    * Returns: 'ignore-file' | 'ignore-pattern' | 'keep' | 'quit'
+   * @param {string} filePath - File path
+   * @param {object} finding - Finding object
+   * @param {string} fileContent - File content (for hash generation)
    */
-  async promptThreat(filePath, finding) {
+  async promptThreat(filePath, finding, fileContent = null) {
     return new Promise((resolve) => {
       const rl = readline.createInterface({
         input: process.stdin,
@@ -36,10 +39,12 @@ class InteractivePrompt {
       
       console.log('');
       console.log('   \x1b[32m[I]\x1b[0m Ignore this entire file');
-      console.log(`   \x1b[32m[P]\x1b[0m Ignore pattern ${finding.id} only`);
+      console.log(`   \x1b[32m[P]\x1b[0m Ignore pattern ${finding.id} (hash-protected 🔒)`);
       console.log('   \x1b[32m[K]\x1b[0m Keep (this is a real threat)');
       console.log('   \x1b[32m[Q]\x1b[0m Quit scanning');
       console.log('');
+      console.log('   \x1b[90m💡 Hash-protected = re-scanned if code changes\x1b[0m');
+      console.log('');
 
       rl.question('   Choice: ', (answer) => {
         rl.close();
@@ -51,8 +56,14 @@ class InteractivePrompt {
           console.log(`   ✅ Added to .aiwardenignore: ${filePath}`);
           resolve('ignore-file');
         } else if (choice === 'p') {
-          this.ignoreParser.addIgnoreRule(filePath, finding.id);
-          console.log(`   ✅ Added to .aiwardenignore: ${filePath}:${finding.id}`);
+          // Hash-protected whitelist
+          this.ignoreParser.addIgnoreRule(filePath, finding.id, {
+            hash: true,
+            finding,
+            fileContent
+          });
+          console.log(`   ✅ Added to .aiwardenignore: ${filePath}:${finding.id} 🔒`);
+          console.log(`   \x1b[90m   (Hash-protected - will re-scan if code changes)\x1b[0m`);
           resolve('ignore-pattern');
         } else if (choice === 'k') {
           console.log('   ⚠️  Kept as threat');