Use rustls to avoid openssl dependency

Author: novafacing

Cargo.toml

@@ -86,12 +86,17 @@ windows = { version = "0.57.0", features = [
     "Win32_System_SystemInformation",
     "Win32_System_Kernel",
 ] }
-reqwest = { version = "0.12.5", features = ["blocking"] }
+reqwest = { version = "0.12.5", features = [
+    "blocking",
+    # NOTE: rustls is used because native-tls does not build with the
+    # compatibility builder and we don't need any advanced features
+    "rustls-tls",
+], default-features = false }
 pdb = "0.8.0"
 intervaltree = "0.2.7"
 lending-iterator = "0.1.7"
 rustc-demangle = "0.1.24"
-symbolic = { version = "12.9.2", features = ["demangle"] }
+cpp_demangle = "0.4.3"
 
 [dev-dependencies]
 simics-test = "0.1.0"

src/os/windows/debug_info.rs

@@ -360,6 +360,7 @@ impl ProcessModule {
                                     if let Some(rva) = p.offset.to_rva(&address_map) {
                                         let info = SymbolInfo::new(
                                             rva.0 as u64,
+                                            self.base,
                                             0,
                                             p.name.to_string().to_string(),
                                             self.full_name.clone(),
@@ -372,6 +373,7 @@ impl ProcessModule {
                                 if let Some(rva) = p.offset.to_rva(&address_map) {
                                     let info = SymbolInfo::new(
                                         rva.0 as u64,
+                                        self.base,
                                         p.len as u64,
                                         p.name.to_string().to_string(),
                                         self.full_name.clone(),
@@ -422,15 +424,17 @@ pub struct Process {
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SymbolInfo {
     pub rva: u64,
+    pub base: u64,
     pub size: u64,
     pub name: String,
     pub module: String,
 }
 
 impl SymbolInfo {
-    pub fn new(rva: u64, size: u64, name: String, module: String) -> Self {
+    pub fn new(rva: u64, base: u64, size: u64, name: String, module: String) -> Self {
         Self {
             rva,
+            base,
             size,
             name,
             module,
@@ -470,6 +474,7 @@ impl Module {
                                     if let Some(rva) = p.offset.to_rva(&address_map) {
                                         let info = SymbolInfo::new(
                                             rva.0 as u64,
+                                            self.base,
                                             1,
                                             p.name.to_string().to_string(),
                                             self.full_name.clone(),
@@ -482,6 +487,7 @@ impl Module {
                                 if let Some(rva) = p.offset.to_rva(&address_map) {
                                     let info = SymbolInfo::new(
                                         rva.0 as u64,
+                                        self.base,
                                         p.len as u64,
                                         p.name.to_string().to_string(),
                                         self.full_name.clone(),

src/tracer/mod.rs

@@ -2,10 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::{anyhow, bail, Error, Result};
+use cpp_demangle::{DemangleOptions, Symbol};
 use ffi::ffi;
 use libafl::prelude::CmpValues;
 use libafl_bolts::{AsMutSlice, AsSlice};
 use libafl_targets::{AFLppCmpLogOperands, AFL_CMP_TYPE_INS, CMPLOG_MAP_H};
+use rustc_demangle::try_demangle;
 use serde::{Deserialize, Serialize};
 use simics::{
     api::{
@@ -18,7 +20,6 @@ use std::{
     collections::HashMap, ffi::c_void, fmt::Display, hash::Hash, num::Wrapping,
     slice::from_raw_parts, str::FromStr,
 };
-use symbolic::demangle::Demangle;
 use typed_builder::TypedBuilder;
 
 use crate::{arch::ArchitectureOperations, Tsffs};
@@ -397,9 +398,15 @@ impl Tsffs {
                 .get(&processor_number)
                 .and_then(|lookup_tree| {
                     lookup_tree.query(pc..pc + 1).next().map(|q| {
-                        let offset = pc - q.range.start;
-                        let symbol_demangled = symbolic::common::Name::from(&q.value.name)
-                            .demangle(symbolic::demangle::DemangleOptions::complete());
+                        let offset = pc - q.value.base + q.value.rva;
+                        let symbol_demangled = try_demangle(&q.value.name)
+                            .map(|d| d.to_string())
+                            .ok()
+                            .or_else(|| {
+                                Symbol::new(&q.value.name)
+                                    .ok()
+                                    .and_then(|s| s.demangle(&DemangleOptions::new()).ok())
+                            });
                         ExecutionTraceSymbol {
                             symbol: q.value.name.clone(),
                             symbol_demangled,