@oculum/scanner 1.0.10 → 1.0.12

package/src/layer2/data-exposure.ts

@@ -5,7 +5,8 @@
  */
 
 import type { Vulnerability, VulnerabilitySeverity } from '../types'
-import { isComment, isTestOrMockFile } from '../utils/context-helpers'
+import type { ParsedFile } from '../utils/parsed-file'
+import { isComment, isTestOrMockFile, isScannerOrFixtureFile } from '../utils/context-helpers'
 
 interface DataExposurePattern {
   name: string
@@ -18,44 +19,17 @@ interface DataExposurePattern {
 
 const DATA_EXPOSURE_PATTERNS: DataExposurePattern[] = [
   // ============================================================================
-  // LOG SINKS (generally lower severity - server-side only)
-  // These are hygiene issues, not security vulnerabilities in most cases
+  // LOG SINKS - DISABLED
+  // Server logs are never exposed to users. After analysis of real codebases,
+  // 100% of console.error/warn findings were false positives.
+  // Logging is a standard debugging practice, not a security vulnerability.
   // ============================================================================
 
-  // Logging sensitive variables - kept low/info
-  // NOTE: Generic "query" or "search" logging is NOT flagged - only actual sensitive data
-  {
-    name: 'Logging user ID',
-    pattern: /console\.(log|info|debug|warn|error)\s*\([^)]*\b(userId|user_id|user\.id)\b/gi,
-    sink: 'log',
-    severity: 'info',
-    description: 'User ID logged to console. Common debugging practice - verify logs are secured.',
-    suggestedFix: 'Use structured logging with appropriate access controls. Remove before production if not needed.',
-  },
-  {
-    name: 'Logging error objects',
-    pattern: /console\.(log|error|warn)\s*\(\s*(err|error|e)\s*\)/gi,
-    sink: 'log',
-    severity: 'info', // Downgraded from 'low' - this is standard practice
-    description: 'Error object logged to console. Standard debugging practice, but may expose stack traces in logs.',
-    suggestedFix: 'Consider logging only error.message in production. Use structured logging for better control.',
-  },
-  {
-    name: 'Logging request body',
-    pattern: /console\.(log|info|debug)\s*\([^)]*\b(req\.body|request\.body|body)\b/gi,
-    sink: 'log',
-    severity: 'low',
-    description: 'Request body logged to console. May contain sensitive user input.',
-    suggestedFix: 'Redact sensitive fields (passwords, tokens) before logging.',
-  },
-  {
-    name: 'JSON.stringify error to log',
-    pattern: /console\.(log|error|warn)\s*\([^)]*JSON\.stringify\s*\(\s*(err|error|e)\s*\)/gi,
-    sink: 'log',
-    severity: 'info',
-    description: 'Error object serialized to JSON for logging. May include stack traces.',
-    suggestedFix: 'Consider logging specific error properties instead of the full serialized object.',
-  },
+  // NOTE: The following patterns have been REMOVED to eliminate false positives:
+  // - 'Logging user ID' - user IDs in logs are standard practice
+  // - 'Logging error objects' - console.error(err) is correct error handling
+  // - 'Logging request body' - server logs are not exposed to clients
+  // - 'JSON.stringify error to log' - serializing errors for logs is fine
 
   // ============================================================================
   // RESPONSE SINKS (higher severity - exposed to clients)
@@ -171,10 +145,15 @@ function isLowRiskLoggingFile(filePath: string): boolean {
  */
 export function detectDataExposure(
   content: string,
-  filePath: string
+  filePath: string,
+  options?: { parsed?: ParsedFile }
 ): Vulnerability[] {
   const vulnerabilities: Vulnerability[] = []
-  const lines = content.split('\n')
+
+  // Skip scanner/fixture files to avoid self-detection
+  if (isScannerOrFixtureFile(filePath)) return vulnerabilities
+
+  const lines = options?.parsed?.lines ?? content.split('\n')
   const isTestFile = isTestOrMockFile(filePath)
   const isLowRiskFile = isLowRiskLoggingFile(filePath)
 

package/src/layer2/framework-checks.ts

@@ -4,12 +4,14 @@
  */
 
 import type { Vulnerability, VulnerabilitySeverity } from '../types'
+import type { ParsedFile } from '../utils/parsed-file'
 import {
   isComment,
   isServerOnlyFile,
   isEnvVarReference,
   getServiceRoleKeyContext,
   isTestOrMockFile,
+  isScannerOrFixtureFile,
 } from '../utils/context-helpers'
 
 interface FrameworkPattern {
@@ -278,10 +280,15 @@ function detectFramework(content: string, filePath: string): string[] {
 
 export function detectFrameworkIssues(
   content: string,
-  filePath: string
+  filePath: string,
+  options?: { parsed?: ParsedFile }
 ): Vulnerability[] {
   const vulnerabilities: Vulnerability[] = []
-  const lines = content.split('\n')
+
+  // Skip scanner/fixture files to avoid self-detection
+  if (isScannerOrFixtureFile(filePath)) return vulnerabilities
+
+  const lines = options?.parsed?.lines ?? content.split('\n')
   const detectedFrameworks = detectFramework(content, filePath)
   const isTestFile = isTestOrMockFile(filePath)
 

package/src/layer2/index.ts

@@ -5,7 +5,7 @@
  * and AI code fingerprinting
  */
 
-import type { Vulnerability, ScanFile, CancellationToken } from '../types'
+import type { Vulnerability, ScanFile, CancellationToken, DetectorContext } from '../types'
 import type { ProgressCallback } from '../index'
 import type { MiddlewareAuthConfig } from '../utils/middleware-detector'
 import { detectAuthHelpers, type AuthHelperContext } from '../utils/auth-helper-detector'
@@ -14,6 +14,7 @@ import {
   filterFindingsByPath,
   type ExclusionConfig,
 } from '../utils/path-exclusions'
+import { buildFileContext, type FileContext } from '../utils/context-helpers'
 import { detectSensitiveVariables } from './variables'
 import { detectLogicGates } from './logic-gates'
 import { detectDangerousFunctions } from './dangerous-functions'
@@ -31,6 +32,11 @@ import { detectAIAgentTools } from './ai-agent-tools'
 import { detectRAGSafetyIssues } from './ai-rag-safety'
 import { detectAIEndpointProtection } from './ai-endpoint-protection'
 import { detectAISchemaValidation } from './ai-schema-validation'
+// AI Detection Roadmap Phase 1
+import { detectAIPackageHallucination } from './ai-package-hallucination'
+import { detectMCPSecurity } from './ai-mcp-security'
+// AI Detection Roadmap Phase 2
+import { detectModelSupplyChain } from './model-supply-chain'
 // Tier system imports
 import {
   type TierStats,
@@ -39,6 +45,9 @@ import {
   getLayer2DetectorTier,
   type Layer2DetectorName,
 } from '../tiers'
+import { severityRank } from '../utils/parsed-file'
+import { ParsedFile } from '../utils/parsed-file'
+import { applyContextAdjustments } from '../filtering/context-adjustments'
 
 export interface Layer2Options {
   middlewareConfig?: MiddlewareAuthConfig
@@ -50,6 +59,14 @@ export interface Layer2Options {
   excludeSeedFiles?: boolean
   /** Custom exclusion patterns (glob format) */
   customExclusions?: string[]
+  /**
+   * Detector context for context-aware detection (Phase 2b)
+   * When provided, detectors can make smarter decisions based on:
+   * - Project-level auth configuration
+   * - Framework detection
+   * - Per-file context (server vs client, test vs production)
+   */
+  detectorContext?: DetectorContext
 }
 
 export interface Layer2Stats {
@@ -90,6 +107,11 @@ type Layer2DetectorStats = {
   ragSafety: number
   endpointProtection: number
   schemaValidation: number
+  // AI Detection Roadmap Phase 1
+  packageHallucination: number
+  mcpSecurity: number
+  // AI Detection Roadmap Phase 2
+  modelSupplyChain: number
 }
 
 // Process a single file through all Layer 2 detectors
@@ -114,35 +136,65 @@ function processFileLayer2(
     ragSafety: 0,
     endpointProtection: 0,
     schemaValidation: 0,
+    // AI Detection Roadmap Phase 1
+    packageHallucination: 0,
+    mcpSecurity: 0,
+    // AI Detection Roadmap Phase 2
+    modelSupplyChain: 0,
   }
 
-  // Skip non-code files
+  // Build file-specific context for context-aware detection (Phase 2b)
+  const fileContext = buildFileContext(file.path)
+
+  // Create ParsedFile once for all detectors to share (avoids redundant content.split('\n'))
+  const parsed = ParsedFile.from(file)
+
+  // Check if this is a manifest file (package.json, requirements.txt, etc.)
+  const isManifestFile = (filePath: string) => {
+    const manifestFiles = ['package.json', 'requirements.txt', 'Pipfile', 'pyproject.toml', 'setup.py']
+    return manifestFiles.some(f => filePath.endsWith(f))
+  }
+
+  // For non-code files, only run package hallucination detector on manifest files
   if (!isCodeFile(file.path)) {
+    if (isManifestFile(file.path)) {
+      // Run package hallucination detector on manifest files
+      const packageHallucinationFindings = detectAIPackageHallucination(file.content, file.path)
+      stats.packageHallucination = packageHallucinationFindings.length
+      return { findings: packageHallucinationFindings, stats }
+    }
     return { findings: [], stats }
   }
 
-  // Run all detectors
-  const variableFindings = detectSensitiveVariables(file.content, file.path)
-  const logicFindings = detectLogicGates(file.content, file.path)
-  const dangerousFuncFindings = detectDangerousFunctions(file.content, file.path)
-  const riskyImportFindings = detectRiskyImports(file.content, file.path)
+  // Run all detectors — parsed is passed via options for detectors that support it
+  const variableFindings = detectSensitiveVariables(file.content, file.path, { parsed })
+  const logicFindings = detectLogicGates(file.content, file.path, { parsed })
+  const dangerousFuncFindings = detectDangerousFunctions(file.content, file.path, { parsed })
+  const riskyImportFindings = detectRiskyImports(file.content, file.path, { parsed })
   const authFindings = detectAuthAntipatterns(file.content, file.path, {
     middlewareConfig: options.middlewareConfig,
     authHelpers: authHelperContext,
     fileAuthImports: options.fileAuthImports,
+    parsed,
   })
-  const frameworkFindings = detectFrameworkIssues(file.content, file.path)
-  const aiFindings = detectAIFingerprints(file.content, file.path)
-  const dataExposureFindings = detectDataExposure(file.content, file.path)
-  const byokFindings = detectBYOKPatterns(file.content, file.path, options.middlewareConfig)
-  const promptHygieneFindings = detectAIPromptHygiene(file.content, file.path)
-  const executionSinkFindings = detectAIExecutionSinks(file.content, file.path)
-  const agentToolFindings = detectAIAgentTools(file.content, file.path)
-  const ragSafetyFindings = detectRAGSafetyIssues(file.content, file.path)
+  const frameworkFindings = detectFrameworkIssues(file.content, file.path, { parsed })
+  const aiFindings = detectAIFingerprints(file.content, file.path, { parsed })
+  const dataExposureFindings = detectDataExposure(file.content, file.path, { parsed })
+  const byokFindings = detectBYOKPatterns(file.content, file.path, options.middlewareConfig, { parsed })
+  const promptHygieneFindings = detectAIPromptHygiene(file.content, file.path, { parsed })
+  const executionSinkFindings = detectAIExecutionSinks(file.content, file.path, { parsed })
+  const agentToolFindings = detectAIAgentTools(file.content, file.path, { parsed })
+  const ragSafetyFindings = detectRAGSafetyIssues(file.content, file.path, { parsed })
   const endpointProtectionFindings = detectAIEndpointProtection(file.content, file.path, {
     middlewareConfig: options.middlewareConfig,
+    parsed,
   })
-  const schemaValidationFindings = detectAISchemaValidation(file.content, file.path)
+  const schemaValidationFindings = detectAISchemaValidation(file.content, file.path, { parsed })
+  // AI Detection Roadmap Phase 1
+  const packageHallucinationFindings = detectAIPackageHallucination(file.content, file.path, { parsed })
+  const mcpSecurityFindings = detectMCPSecurity(file.content, file.path, { parsed })
+  // AI Detection Roadmap Phase 2
+  const modelSupplyChainFindings = detectModelSupplyChain(file.content, file.path, { parsed })
 
   // Update stats
   stats.variables = variableFindings.length
@@ -160,29 +212,47 @@ function processFileLayer2(
   stats.ragSafety = ragSafetyFindings.length
   stats.endpointProtection = endpointProtectionFindings.length
   stats.schemaValidation = schemaValidationFindings.length
+  // AI Detection Roadmap Phase 1
+  stats.packageHallucination = packageHallucinationFindings.length
+  stats.mcpSecurity = mcpSecurityFindings.length
+  // AI Detection Roadmap Phase 2
+  stats.modelSupplyChain = modelSupplyChainFindings.length
+
+  // Combine all findings
+  const allFindings = [
+    ...variableFindings,
+    ...logicFindings,
+    ...dangerousFuncFindings,
+    ...riskyImportFindings,
+    ...authFindings,
+    ...frameworkFindings,
+    ...aiFindings,
+    ...dataExposureFindings,
+    ...byokFindings,
+    ...promptHygieneFindings,
+    ...executionSinkFindings,
+    ...agentToolFindings,
+    ...ragSafetyFindings,
+    ...endpointProtectionFindings,
+    ...schemaValidationFindings,
+    // AI Detection Roadmap Phase 1
+    ...packageHallucinationFindings,
+    ...mcpSecurityFindings,
+    // AI Detection Roadmap Phase 2
+    ...modelSupplyChainFindings,
+  ]
+
+  // Apply context-based severity adjustments (Phase 2b)
+  const adjustedFindings = applyContextAdjustments(allFindings, fileContext)
 
   return {
-    findings: [
-      ...variableFindings,
-      ...logicFindings,
-      ...dangerousFuncFindings,
-      ...riskyImportFindings,
-      ...authFindings,
-      ...frameworkFindings,
-      ...aiFindings,
-      ...dataExposureFindings,
-      ...byokFindings,
-      ...promptHygieneFindings,
-      ...executionSinkFindings,
-      ...agentToolFindings,
-      ...ragSafetyFindings,
-      ...endpointProtectionFindings,
-      ...schemaValidationFindings,
-    ],
+    findings: adjustedFindings,
     stats,
   }
 }
 
+// applyFileContextAdjustments consolidated into filtering/context-adjustments.ts
+
 // Parallel batch size for Layer 2 processing (larger batches for performance)
 const LAYER2_PARALLEL_BATCH_SIZE = 50
 // Progress update interval (report every N files for better UX)
@@ -212,6 +282,11 @@ export async function runLayer2Scan(
     ragSafety: 0,
     endpointProtection: 0,
     schemaValidation: 0,
+    // AI Detection Roadmap Phase 1
+    packageHallucination: 0,
+    mcpSecurity: 0,
+    // AI Detection Roadmap Phase 2
+    modelSupplyChain: 0,
   }
 
   // Detect auth helpers once for all files (if not already provided)
@@ -303,6 +378,11 @@ export async function runLayer2Scan(
     ai_rag_safety: stats.ragSafety,
     ai_endpoint_protection: stats.endpointProtection,
     ai_schema_validation: stats.schemaValidation,
+    // AI Detection Roadmap Phase 1
+    ai_package_hallucination: stats.packageHallucination,
+    ai_mcp_security: stats.mcpSecurity,
+    // AI Detection Roadmap Phase 2
+    model_supply_chain: stats.modelSupplyChain,
   }
 
   // Compute deduped counts per category
@@ -341,6 +421,11 @@ export async function runLayer2Scan(
     ai_rag_safety: 'ai_rag_safety',
     ai_endpoint_protection: 'ai_endpoint_protection',
     ai_schema_validation: 'ai_schema_validation',
+    // AI Detection Roadmap Phase 1
+    ai_package_hallucination: 'ai_package_hallucination',
+    ai_mcp_security: 'ai_mcp_security',
+    // AI Detection Roadmap Phase 2
+    model_supply_chain: 'model_supply_chain',
   }
 
   // Heuristic breakdown available in stats.raw and stats.tiers for debugging
@@ -510,16 +595,7 @@ function subsumeRelatedFindings(vulnerabilities: Vulnerability[]): Vulnerability
   return result
 }
 
-function severityRank(severity: string): number {
-  const ranks: Record<string, number> = {
-    critical: 4,
-    high: 3,
-    medium: 2,
-    low: 1,
-    info: 0,
-  }
-  return ranks[severity] || 0
-}
+// severityRank imported from utils/parsed-file
 
 export { detectSensitiveVariables } from './variables'
 export { detectLogicGates } from './logic-gates'
@@ -538,3 +614,8 @@ export { detectAIAgentTools } from './ai-agent-tools'
 export { detectRAGSafetyIssues } from './ai-rag-safety'
 export { detectAIEndpointProtection } from './ai-endpoint-protection'
 export { detectAISchemaValidation } from './ai-schema-validation'
+// AI Detection Roadmap Phase 1
+export { detectAIPackageHallucination } from './ai-package-hallucination'
+export { detectMCPSecurity } from './ai-mcp-security'
+// AI Detection Roadmap Phase 2
+export { detectModelSupplyChain } from './model-supply-chain'

package/src/layer2/logic-gates.ts

@@ -4,6 +4,10 @@
  */
 
 import type { Vulnerability } from '../types'
+import type { ParsedFile } from '../utils/parsed-file'
+import { isScannerOrFixtureFile } from '../utils/context-helpers'
+import { isDisabledAuthComment } from '../utils/comment-analyzer'
+import { isReactStateSetter, isActualRedirect } from '../utils/intent-detector'
 
 interface LogicPattern {
   name: string
@@ -38,13 +42,9 @@ const LOGIC_PATTERNS: LogicPattern[] = [
     description: 'Hardcoded truthy condition may bypass authentication',
     suggestedFix: 'Remove hardcoded bypass and implement proper authentication check',
   },
-  {
-    name: 'Commented auth check',
-    pattern: /\/\/\s*(if|await|return).*auth|\/\/.*verify.*token|\/\/.*check.*permission/gi,
-    severity: 'high',
-    description: 'Commented out authentication/authorization code detected',
-    suggestedFix: 'Remove commented code or restore the security check',
-  },
+  // NOTE: 'Commented auth check' pattern has been replaced with smart comment analysis
+  // The isDisabledAuthComment() function distinguishes explanatory comments from disabled code
+  // This is handled specially in detectLogicGates() below
   // Skip validation patterns
   {
     name: 'Validation skip',
@@ -92,15 +92,20 @@ const LOGIC_PATTERNS: LogicPattern[] = [
     description: 'SSL/TLS certificate verification disabled',
     suggestedFix: 'Enable SSL verification to prevent man-in-the-middle attacks',
   },
-  // Insecure comparisons
+  // Insecure comparisons - ONLY flag actual secret comparisons
+  // Timing attacks are only relevant when comparing cryptographic secrets
+  // Do NOT flag: error codes, UI state, null checks, empty strings, route IDs, type checks
   {
     name: 'Timing attack vulnerable comparison',
-    pattern: /===?\s*['"][^'"]{20,}['"]|password\s*===?\s*|token\s*===?\s*|secret\s*===?\s*/gi,
+    // Only match explicit secret-related variable names being compared with ===
+    // This avoids flagging general string comparisons which are not timing-sensitive
+    pattern: /\b(password|secret|token|apiKey|api_key|credential|hash|digest|signature|privateKey|private_key|secretKey|secret_key)\s*===?\s*['"][^'"]+['"]/gi,
     severity: 'medium',
-    description: 'Direct string comparison may be vulnerable to timing attacks',
+    description: 'Direct comparison of secret value may be vulnerable to timing attacks',
     suggestedFix: 'Use constant-time comparison for secrets (e.g., crypto.timingSafeEqual)',
   },
-  // Unsafe redirects
+  // Unsafe redirects - NOTE: Now uses intent detection to distinguish from React state setters
+  // The pattern is checked, but isReactStateSetter() is used to skip false positives
   {
     name: 'Open redirect vulnerability',
     pattern: /redirect\s*\(\s*(req\.(query|params|body)\.|request\.|url\.)/gi,
@@ -131,26 +136,39 @@ function isComment(line: string): boolean {
 
 export function detectLogicGates(
   content: string,
-  filePath: string
+  filePath: string,
+  options?: { parsed?: ParsedFile }
 ): Vulnerability[] {
   const vulnerabilities: Vulnerability[] = []
-  const lines = content.split('\n')
+
+  // Skip scanner/fixture files to avoid self-detection
+  if (isScannerOrFixtureFile(filePath)) return vulnerabilities
+
+  const lines = options?.parsed?.lines ?? content.split('\n')
 
   // Check each line against patterns
   lines.forEach((line, index) => {
-    // Don't skip comments for the "commented auth check" pattern
-    const shouldSkipComments = !line.trim().startsWith('//')
+    // Skip comment lines (handled separately below for auth comments)
+    if (isComment(line)) {
+      return
+    }
 
     for (const logicPattern of LOGIC_PATTERNS) {
-      // Skip comment lines for most patterns
-      if (shouldSkipComments && isComment(line) && 
-          logicPattern.name !== 'Commented auth check') {
-        continue
-      }
-
       const regex = new RegExp(logicPattern.pattern.source, logicPattern.pattern.flags)
-      
+
       if (regex.test(line)) {
+        // Special handling for redirect patterns - check if it's actually a React state setter
+        if (logicPattern.name === 'Open redirect vulnerability') {
+          if (isReactStateSetter(line)) {
+            // This is a React state setter like setState(), not a redirect
+            continue
+          }
+          if (!isActualRedirect(line)) {
+            // This doesn't look like an actual redirect function
+            continue
+          }
+        }
+
         vulnerabilities.push({
           id: `logic-${filePath}-${index + 1}-${logicPattern.name}`,
           filePath,
@@ -169,6 +187,30 @@ export function detectLogicGates(
     }
   })
 
+  // Smart comment analysis for disabled auth patterns
+  // Only flag comments that are genuinely disabled code, not explanatory comments
+  lines.forEach((line, index) => {
+    // Check if this is a comment line with auth-related content
+    if (isComment(line) && /auth|permission|verify|check|token/i.test(line)) {
+      // Use smart analysis to determine if this is disabled code
+      if (isDisabledAuthComment(lines, index)) {
+        vulnerabilities.push({
+          id: `logic-${filePath}-${index + 1}-commented-auth-check`,
+          filePath,
+          lineNumber: index + 1,
+          lineContent: line.trim(),
+          severity: 'high',
+          category: 'security_bypass',
+          title: 'Commented auth check',
+          description: 'Commented out authentication/authorization code detected. This may indicate disabled security controls.',
+          suggestedFix: 'Remove commented code or restore the security check',
+          confidence: 'medium',
+          layer: 2,
+        })
+      }
+    }
+  })
+
   // Multi-line pattern detection (for more complex patterns)
   const multiLineFindings = detectMultiLinePatterns(content, filePath)
   vulnerabilities.push(...multiLineFindings)