pompelmi/dist/types/engines/hybrid-taint-integration.d.ts

RFI-safe file uploads for Node.js — Express/Koa/Next.js middleware with deep ZIP inspection, MIME/size checks, and optional YARA scanning.

/**
 * Hybrid Taint Analysis Integration
 *
 * Complete integration package for dynamic taint tracking and hybrid orchestration
 * with existing Pompelmi decompilation engines and HIPAA compliance.
 */
import type { TaintConfig, TaintAnalysisResult, HybridConfig, HybridAnalysisResult, AnalysisEngine } from '../types/taint-tracking';
import type { TaintPolicy } from './taint-policies';
import type { DecompilationScanner, DecompilationResult } from '../types/decompilation';
/**
 * Enhanced analysis result combining all engines
 */
export interface EnhancedAnalysisResult {
    /** Analysis session ID */
    sessionId: string;
    /** Overall success status */
    success: boolean;
    /** Total analysis time */
    totalTime: number;
    /** Static analysis results */
    static?: {
        binaryNinja?: DecompilationResult;
        ghidra?: DecompilationResult;
    };
    /** Dynamic taint analysis results */
    taint?: TaintAnalysisResult;
    /** Hybrid orchestration results */
    hybrid?: HybridAnalysisResult;
    /** Policy used for analysis */
    policy?: TaintPolicy;
    /** Security assessment */
    security: {
        riskScore: number;
        vulnerabilities: Array<{
            type: string;
            severity: 'low' | 'medium' | 'high' | 'critical';
            confidence: number;
            description: string;
            evidence: any;
            mitigations: string[];
        }>;
        recommendations: string[];
    };
    /** Compliance assessment */
    compliance?: {
        hipaaCompliant: boolean;
        issues: Array<{
            type: string;
            severity: 'info' | 'warning' | 'critical';
            description: string;
            remediation: string;
        }>;
        auditTrail: any[];
    };
    /** Performance metrics */
    performance: {
        enginesUsed: AnalysisEngine[];
        totalInstructions: number;
        memoryPeak: number;
        cpuTime: number;
    };
}
/**
 * Main integration class for hybrid taint analysis
 */
export declare class HybridTaintAnalyzer {
    private orchestrator;
    private policyManager;
    private taintEngine;
    private registeredEngines;
    constructor();
    /**
     * Initialize the analyzer with registered engines
     */
    initialize(engines: {
        binaryNinja?: DecompilationScanner;
        ghidra?: DecompilationScanner;
    }): Promise<void>;
    /**
     * Perform comprehensive analysis using specified policy
     */
    analyze(data: Uint8Array, policyName?: string, options?: {
        enabledEngines?: AnalysisEngine[];
        customConfig?: Partial<HybridConfig>;
        includeCompliance?: boolean;
    }): Promise<EnhancedAnalysisResult>;
    /**
     * Get available analysis policies
     */
    getAvailablePolicies(): TaintPolicy[];
    /**
     * Get policies by use case
     */
    getPoliciesByUseCase(useCase: 'malware' | 'vulnerability' | 'compliance' | 'forensics' | 'general'): TaintPolicy[];
    /**
     * Register a custom analysis policy
     */
    registerPolicy(policy: TaintPolicy): void;
    /**
     * Perform quick taint analysis without full orchestration
     */
    quickTaintAnalysis(data: Uint8Array, config?: Partial<TaintConfig>): Promise<TaintAnalysisResult>;
    /**
     * Check if data contains taint at specific location
     */
    checkTaint(address: string): Promise<boolean>;
    /**
     * Add custom taint source for analysis
     */
    addTaintSource(address: string, source: string, metadata?: any): Promise<void>;
    private registerEngine;
    private createEngineCapabilities;
    private createHybridConfig;
    private mergeConfigs;
    private processResults;
    private extractStaticResults;
    private calculateSecurityAssessment;
    private calculateComplianceAssessment;
    private calculatePerformanceMetrics;
    private generateSecurityRecommendations;
    private generateAuditTrail;
    private getDefaultTaintConfig;
    private generateSessionId;
    private createFailureResult;
}
export declare function analyzeWithTaint(data: Uint8Array, engines: {
    binaryNinja?: DecompilationScanner;
    ghidra?: DecompilationScanner;
}, policy?: string): Promise<EnhancedAnalysisResult>;