Struct TaintResult 

pub struct TaintResult {
    pub sources: AHashSet<i64>,
    pub sinks_reached: AHashSet<i64>,
    pub tainted_nodes: AHashSet<i64>,
    pub source_sink_paths: Vec<(i64, i64)>,
    pub size: usize,
}

Result of taint analysis operation.

Contains the complete taint propagation result with sources, sinks reached, tainted nodes, and source-sink vulnerability paths.

Fields

• sources: Source nodes that were analyzed (taint origins)
• sinks_reached: Sink nodes that are reachable from sources (vulnerabilities)
• tainted_nodes: All nodes tainted by source data (forward reachability from sources)
• source_sink_paths: Vulnerability paths as (source, sink) pairs
• size: Number of tainted nodes (len of tainted_nodes)

Example

let result = propagate_taint_forward(&graph, &sources, &sinks)?;

println!("Tainted {} nodes from {} sources",
         result.size, result.sources.len());

// Check if specific node is tainted
if result.is_tainted(node_id) {
    println!("Node {} is tainted", node_id);
}

// Check for vulnerabilities
if result.has_vulnerability() {
    println!("Found {} source-sink vulnerabilities",
             result.source_sink_paths.len());

    for (source, sink) in result.sorted_vulnerabilities() {
        println!("  VULN: source {} -> sink {}", source, sink);
    }
}

Fields

sources: AHashSet<i64>

Source nodes that taint originated from

sinks_reached: AHashSet<i64>

Sink nodes that were reached by tainted data (vulnerabilities)

tainted_nodes: AHashSet<i64>

All nodes that are tainted (reachable from any source)

source_sink_paths: Vec<(i64, i64)>

Source-sink paths that represent vulnerabilities

size: usize

Number of tainted nodes

Implementations

impl TaintResult

pub fn new() -> Self

Creates a new empty taint result.

pub fn is_tainted(&self, node: i64) -> bool

Checks if a node is tainted.

Returns true if the node is in the tainted_nodes set.

Example

if result.is_tainted(node_id) {
    println!("Node {} is tainted", node_id);
}

pub fn has_vulnerability(&self) -> bool

Checks if any vulnerabilities were found.

Returns true if any sink is reachable from any source.

Example

if result.has_vulnerability() {
    println!("SECURITY ISSUE: tainted data reaches sensitive sink!");
}

pub fn sorted_tainted_nodes(&self) -> Vec<i64>

Returns sorted list of tainted node IDs.

Provides deterministic output for testing and reporting.

Example

for node in result.sorted_tainted_nodes() {
    println!("Tainted node: {}", node);
}

pub fn sorted_vulnerabilities(&self) -> Vec<(i64, i64)>

Returns sorted list of vulnerability paths.

Each vulnerability is a (source, sink) pair. Sorted by source then sink for deterministic output.

Example

for (source, sink) in result.sorted_vulnerabilities() {
    println!("VULN: source {} -> sink {}", source, sink);
}

Trait Implementations

impl Clone for TaintResult

fn clone(&self) -> TaintResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TaintResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TaintResult

fn default() -> Self

Returns the “default value” for a type.