Add proc maps for windows target

Author: etke

Cargo.lock

@@ -38,6 +38,9 @@ serde_derive = "1.0.137"
 serde_json = "1.0.81"
 sysinfo = "0.24.2"
 
+[target.'cfg(target_os="windows")'.dependencies]
+windows = { version = "0.38.0", features = ["Win32_Foundation", "Win32_Security", "Win32_System_Diagnostics_Debug", "Win32_System_Diagnostics_ToolHelp", "Win32_System_Kernel", "Win32_System_Memory", "Win32_System_Threading"] }
+
 [lib]
 name = "checksec"
 path = "src/lib.rs"

Cargo.toml

@@ -1,16 +1,7 @@
 #[cfg(feature = "color")]
 use colored::Colorize;
 use serde::{Deserialize, Serialize};
-use std::fmt;
-#[cfg(all(feature = "maps", target_os = "linux"))]
-use std::fs;
-#[cfg(all(feature = "maps", target_os = "linux"))]
-use std::io::Error;
-#[cfg(all(feature = "maps", target_os = "linux"))]
-use std::io::ErrorKind;
-#[cfg(all(feature = "maps", target_os = "linux"))]
-use std::path::PathBuf;
-use std::usize;
+use std::{fmt, usize};
 
 #[cfg(feature = "elf")]
 use checksec::elf;
@@ -143,179 +134,3 @@ impl Binaries {
         Self { binaries }
     }
 }
-
-#[cfg(all(feature = "maps", target_os = "linux"))]
-#[derive(Deserialize, Serialize)]
-pub struct Region {
-    pub start: usize,
-    pub end: usize,
-}
-#[cfg(all(feature = "maps", target_os = "linux"))]
-impl Region {
-    pub fn new(start: usize, end: usize) -> Self {
-        Self { start, end }
-    }
-}
-
-#[cfg(all(feature = "maps", target_os = "linux"))]
-#[derive(Deserialize, Serialize)]
-pub struct MapFlags {
-    pub r: bool,
-    pub w: bool,
-    pub x: bool,
-}
-#[cfg(all(feature = "maps", target_os = "linux"))]
-impl MapFlags {
-    pub fn new(flagstr: &str) -> Self {
-        let r = flagstr.get(0..1) == Some("r");
-        let w = flagstr.get(1..2) == Some("w");
-        let x = flagstr.get(2..3) == Some("x");
-        Self { r, w, x }
-    }
-}
-#[cfg(all(not(feature = "color"), feature = "maps", target_os = "linux"))]
-impl fmt::Display for MapFlags {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}{}{}",
-            if self.r { "r" } else { "-" },
-            if self.w { "w" } else { "-" },
-            if self.x { "x" } else { "-" }
-        )
-    }
-}
-#[cfg(all(feature = "color", feature = "maps", target_os = "linux"))]
-impl fmt::Display for MapFlags {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.r & self.w & self.x {
-            return write!(f, "{}", "rwx".red());
-        }
-        write!(
-            f,
-            "{}{}{}",
-            if self.r { "r" } else { "-" },
-            if self.w { "w" } else { "-" },
-            if self.x { "x" } else { "-" }
-        )
-    }
-}
-
-#[cfg(all(feature = "maps", target_os = "linux"))]
-#[derive(Deserialize, Serialize)]
-pub struct MapEntry {
-    pub region: Region,
-    pub flags: MapFlags,
-    pub pathname: Option<PathBuf>,
-}
-#[cfg(all(not(feature = "color"), feature = "maps", target_os = "linux"))]
-impl fmt::Display for MapEntry {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "0x{:x}->0x{:x} {} {}",
-            self.region.start,
-            self.region.end,
-            self.flags,
-            match &self.pathname {
-                Some(pathname) => pathname.display().to_string(),
-                None => "".to_string(),
-            }
-        )
-    }
-}
-#[cfg(all(feature = "color", feature = "maps", target_os = "linux"))]
-impl fmt::Display for MapEntry {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.flags.r & self.flags.w & self.flags.x {
-            write!(
-                f,
-                "{} {}",
-                format!(
-                    "0x{:x}->0x{:x} {}",
-                    self.region.start, self.region.end, self.flags
-                )
-                .red(),
-                match &self.pathname {
-                    Some(pathname) => pathname.display().to_string().red(),
-                    None => "".to_string().red(),
-                }
-            )
-        } else {
-            write!(
-                f,
-                "0x{:x}->0x{:x} {} {}",
-                self.region.start,
-                self.region.end,
-                self.flags,
-                match &self.pathname {
-                    Some(pathname) => pathname.display().to_string(),
-                    None => "".to_string(),
-                }
-            )
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Process {
-    pub pid: usize,
-    pub binary: Vec<Binary>,
-    #[cfg(all(feature = "maps", target_os = "linux"))]
-    pub maps: Option<Vec<MapEntry>>,
-}
-impl Process {
-    #[cfg(any(not(feature = "maps"), not(target_os = "linux")))]
-    pub fn new(pid: usize, binary: Vec<Binary>) -> Self {
-        Self { pid, binary }
-    }
-    #[cfg(all(feature = "maps", target_os = "linux"))]
-    pub fn new(pid: usize, binary: Vec<Binary>) -> Self {
-        match Process::parse_maps(pid) {
-            Ok(maps) => Self { pid, binary, maps: Some(maps) },
-            Err(_) => Self { pid, binary, maps: None },
-        }
-    }
-    #[cfg(all(feature = "maps", target_os = "linux"))]
-    pub fn parse_maps(pid: usize) -> Result<Vec<MapEntry>, Error> {
-        let mut maps: Vec<MapEntry> = Vec::new();
-        if let Ok(maps_str) = fs::read_to_string(format!("/proc/{}/maps", pid))
-        {
-            for line in maps_str.lines() {
-                let mut split_line = line.split_whitespace();
-                let (start_str, end_str) = split_line
-                    .next()
-                    .ok_or(ErrorKind::InvalidData)?
-                    .split_once('-')
-                    .ok_or(ErrorKind::InvalidData)?;
-                let region = Region::new(
-                    usize::from_str_radix(start_str, 16).unwrap_or(0),
-                    usize::from_str_radix(end_str, 16).unwrap_or(0),
-                );
-                let flags = MapFlags::new(
-                    split_line.next().ok_or(ErrorKind::InvalidData)?,
-                );
-                split_line.next(); // skip offset
-                split_line.next(); // skip dev
-                split_line.next(); // skip inode
-                let pathname =
-                    Some(split_line.collect::<Vec<&str>>().join(" "))
-                        .filter(|x| !x.is_empty())
-                        .map(PathBuf::from);
-                maps.push(MapEntry { region, flags, pathname });
-            }
-            return Ok(maps);
-        }
-        Err(Error::last_os_error())
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Processes {
-    pub processes: Vec<Process>,
-}
-impl Processes {
-    pub fn new(processes: Vec<Process>) -> Self {
-        Self { processes }
-    }
-}

src/binary.rs

@@ -26,10 +26,11 @@ use colored::Colorize;
 use colored_json::to_colored_json_auto;
 
 mod binary;
+mod proc;
+
+use binary::{BinSpecificProperties, BinType, Binaries, Binary};
+use proc::{Process, Processes};
 
-use binary::{
-    BinSpecificProperties, BinType, Binaries, Binary, Process, Processes,
-};
 #[cfg(feature = "elf")]
 use checksec::elf;
 #[cfg(feature = "macho")]
@@ -103,7 +104,10 @@ fn print_process_results(processes: &Processes, settings: &output::Settings) {
                         }
                     }
                 }
-                #[cfg(all(target_os = "linux", feature = "maps"))]
+                #[cfg(all(
+                    feature = "maps",
+                    any(target_os = "linux", target_os = "windows")
+                ))]
                 if settings.maps {
                     if let Some(maps) = &process.maps {
                         println!("{:>12}", "\u{21aa} Maps:");