Struct SymbolicValue 

pub struct SymbolicValue {
    pub id: u64,
    pub cil_flavor: CilFlavor,
    pub source: TaintSource,
    pub name: Option<String>,
    pub dependencies: Vec<u64>,
}

A symbolic (unknown) value for partial emulation.

Symbolic values represent unknown or partially-known values during emulation. Each symbolic value has:

• A unique ID for tracking
• A CIL type flavor indicating what kind of value it represents
• A taint source indicating the origin of the value
• Optional constraints collected during execution

Identity

Each symbolic value has a unique ID. Two symbolic values with different IDs are considered distinct, even if they have the same type and source. This enables precise tracking of data flow.

Fields

id: u64

Unique identifier for this symbolic value.

cil_flavor: CilFlavor

The CIL type flavor of this symbolic value.

source: TaintSource

The source/origin of this symbolic value.

name: Option<String>

Optional name for debugging (e.g., parameter name).

dependencies: Vec<u64>

Dependencies on other symbolic values (for derived values).

Implementations

impl SymbolicValue

pub fn new(cil_flavor: CilFlavor, source: TaintSource) -> Self

Creates a new symbolic value with the given type and source.

Examples

use dotscope::emulation::{SymbolicValue, TaintSource};
use dotscope::metadata::typesystem::CilFlavor;

let sym = SymbolicValue::new(CilFlavor::I4, TaintSource::Unknown);

pub fn parameter(index: u16, cil_flavor: CilFlavor) -> Self

Creates a symbolic value representing a method parameter.

Arguments

• index - The parameter index (0-based)
• cil_flavor - The type of the parameter

Examples

use dotscope::emulation::SymbolicValue;
use dotscope::metadata::typesystem::CilFlavor;

let param0 = SymbolicValue::parameter(0, CilFlavor::I4);
assert!(matches!(param0.source, dotscope::emulation::TaintSource::Parameter(0)));

pub fn local(index: u16, cil_flavor: CilFlavor) -> Self

Creates a symbolic value representing a local variable.

Arguments

• index - The local variable index (0-based)
• cil_flavor - The type of the local

pub fn field(field_token: u32, cil_flavor: CilFlavor) -> Self

Creates a symbolic value representing a field value.

Arguments

• field_token - The metadata token of the field
• cil_flavor - The type of the field

pub fn return_value(method_token: u32, cil_flavor: CilFlavor) -> Self

Creates a symbolic value representing a method return value.

Arguments

• method_token - The metadata token of the called method
• cil_flavor - The return type

pub fn derived(cil_flavor: CilFlavor, source: TaintSource) -> Self

Creates a symbolic value derived from other values through computation.

Arguments

• cil_flavor - The result type
• source - The source type (typically TaintSource::Computation)

pub fn derived_from(cil_flavor: CilFlavor, dependencies: Vec<u64>) -> Self

Creates a derived symbolic value with explicit dependencies.

Arguments

• cil_flavor - The result type
• dependencies - IDs of symbolic values this depends on

pub fn user_input(cil_flavor: CilFlavor) -> Self

Creates a symbolic value representing external/user input.

Values from this source should be treated as potentially malicious.

pub fn with_name(self, name: impl Into<String>) -> Self

Sets a human-readable name for this symbolic value.

pub fn is_tainted(&self) -> bool

Returns true if this value originates from a tainted source.

Tainted sources include user input, external data, and values derived from tainted values.

Examples

use dotscope::emulation::{SymbolicValue, TaintSource};
use dotscope::metadata::typesystem::CilFlavor;

let user = SymbolicValue::user_input(CilFlavor::I4);
assert!(user.is_tainted());

let param = SymbolicValue::parameter(0, CilFlavor::I4);
assert!(param.is_tainted()); // Parameters are untrusted

let unknown = SymbolicValue::new(CilFlavor::I4, TaintSource::Unknown);
assert!(!unknown.is_tainted());

pub fn is_parameter(&self) -> bool

Returns true if this value represents a method parameter.

Examples

use dotscope::emulation::SymbolicValue;
use dotscope::metadata::typesystem::CilFlavor;

let param = SymbolicValue::parameter(0, CilFlavor::I4);
assert!(param.is_parameter());

pub fn is_local(&self) -> bool

Returns true if this value represents a local variable.

Examples

use dotscope::emulation::SymbolicValue;
use dotscope::metadata::typesystem::CilFlavor;

let local = SymbolicValue::local(0, CilFlavor::I4);
assert!(local.is_local());

pub fn is_computed(&self) -> bool

Returns true if this value was derived from computation.

Computed values result from operations on other symbolic values.

pub fn parameter_index(&self) -> Option<u16>

Returns the parameter index if this is a parameter value.

Returns

• Some(index) if this symbolic value represents a method parameter
• None if this is not a parameter value

pub fn local_index(&self) -> Option<u16>

Returns the local variable index if this is a local value.

Returns

• Some(index) if this symbolic value represents a local variable
• None if this is not a local variable value

Trait Implementations

impl Clone for SymbolicValue

fn clone(&self) -> SymbolicValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolicValue

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

Formats the value using the given formatter.

impl Display for SymbolicValue

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

Formats the value using the given formatter.