Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

6.6 KB
Raw Blame
//! PE import directory → named IAT slots.

use crate::error::{Error, Result};
use crate::program::{ImportEntry, Program};

/// Parse PE import descriptors into [`Program::imports`] (no-op for non-PE).
pub fn load_imports(prog: &mut Program) -> Result<()> {
    if !prog.format.to_ascii_lowercase().starts_with("pe") {
        prog.imports.clear();
        return Ok(());
    }
    let data = prog.file_bytes.clone();
    prog.imports = parse_pe_imports(&data, prog.image_base)?;
    Ok(())
}

pub fn parse_pe_imports(data: &[u8], image_base: u64) -> Result<Vec<ImportEntry>> {
    if data.len() < 0x40 || &data[0..2] != b"MZ" {
        return Ok(Vec::new());
    }
    let e_lfanew = u32::from_le_bytes(data[0x3C..0x40].try_into().unwrap()) as usize;
    if e_lfanew + 24 > data.len() || &data[e_lfanew..e_lfanew + 4] != b"PE\0\0" {
        return Ok(Vec::new());
    }
    let opt = e_lfanew + 24;
    let magic = rdu16(data, opt)?;
    let (is_pe32plus, data_dir) = match magic {
        0x10b => (false, opt + 96),
        0x20b => (true, opt + 112),
        _ => return Ok(Vec::new()),
    };
    if data_dir + 16 > data.len() {
        return Ok(Vec::new());
    }
    let import_rva = rdu32(data, data_dir + 8)? as u64;
    let import_size = rdu32(data, data_dir + 12)? as u64;
    if import_rva == 0 || import_size == 0 {
        return Ok(Vec::new());
    }

    let mut out = Vec::new();
    let mut desc_off = match rva_to_file(data, import_rva) {
        Some(o) => o,
        None => return Ok(Vec::new()),
    };
    loop {
        if desc_off + 20 > data.len() {
            break;
        }
        let oft = rdu32(data, desc_off)? as u64;
        let name_rva = rdu32(data, desc_off + 12)? as u64;
        let ft = rdu32(data, desc_off + 16)? as u64;
        if oft == 0 && name_rva == 0 && ft == 0 {
            break;
        }
        let dll = read_cstr_rva(data, name_rva).unwrap_or_else(|| "unknown.dll".into());
        let thunk_rva = if oft != 0 { oft } else { ft };
        let mut thunk_file = match rva_to_file(data, thunk_rva) {
            Some(o) => o,
            None => {
                desc_off += 20;
                continue;
            }
        };
        let entry_size = if is_pe32plus { 8usize } else { 4usize };
        let mut idx = 0u64;
        loop {
            if thunk_file + entry_size > data.len() {
                break;
            }
            let raw = if is_pe32plus {
                rdu64(data, thunk_file)?
            } else {
                rdu32(data, thunk_file)? as u64
            };
            if raw == 0 {
                break;
            }
            let ordinal_flag = if is_pe32plus { 1u64 << 63 } else { 1u64 << 31 };
            let (name, ordinal) = if raw & ordinal_flag != 0 {
                (None, Some((raw & 0xffff) as u16))
            } else {
                let hint_rva = raw & 0xffff_ffff;
                let n = read_import_name(data, hint_rva);
                (n, None)
            };
            let slot = idx * entry_size as u64;
            out.push(ImportEntry {
                dll: dll.clone(),
                name,
                ordinal,
                iat_va: image_base.wrapping_add(ft + slot),
                ilt_va: Some(image_base.wrapping_add(thunk_rva + slot)),
            });
            thunk_file += entry_size;
            idx += 1;
        }
        desc_off += 20;
    }
    Ok(out)
}

/// Filter imports by optional DLL / symbol name (case-insensitive substring).
pub fn filter_imports<'a>(
    imports: &'a [ImportEntry],
    dll: Option<&str>,
    name: Option<&str>,
) -> Vec<&'a ImportEntry> {
    imports
        .iter()
        .filter(|e| {
            if let Some(d) = dll {
                if !e.dll.to_ascii_lowercase().contains(&d.to_ascii_lowercase()) {
                    return false;
                }
            }
            if let Some(n) = name {
                let nl = n.to_ascii_lowercase();
                let hit = e
                    .name
                    .as_ref()
                    .map(|s| s.to_ascii_lowercase().contains(&nl))
                    .unwrap_or(false)
                    || e.ordinal
                        .map(|o| format!("ord_{o}").contains(&nl) || o.to_string() == n)
                        .unwrap_or(false);
                if !hit {
                    return false;
                }
            }
            true
        })
        .collect()
}

fn read_import_name(data: &[u8], hint_rva: u64) -> Option<String> {
    let off = rva_to_file(data, hint_rva)? + 2; // skip Hint
    read_cstr_at(data, off)
}

fn read_cstr_rva(data: &[u8], rva: u64) -> Option<String> {
    let off = rva_to_file(data, rva)?;
    read_cstr_at(data, off)
}

fn read_cstr_at(data: &[u8], off: usize) -> Option<String> {
    if off >= data.len() {
        return None;
    }
    let end = data[off..]
        .iter()
        .position(|&b| b == 0)
        .map(|p| off + p)
        .unwrap_or(data.len());
    if end == off {
        return None;
    }
    Some(String::from_utf8_lossy(&data[off..end]).into_owned())
}

fn rva_to_file(data: &[u8], rva: u64) -> Option<usize> {
    if data.len() < 0x40 {
        return None;
    }
    let e_lfanew = u32::from_le_bytes(data[0x3C..0x40].try_into().ok()?) as usize;
    let coff = e_lfanew + 4;
    let num_sections = rdu16(data, coff + 2).ok()? as usize;
    let opt_size = rdu16(data, coff + 16).ok()? as usize;
    let sec_table = coff + 20 + opt_size;
    for i in 0..num_sections {
        let off = sec_table + i * 40;
        if off + 40 > data.len() {
            break;
        }
        let virt_size = rdu32(data, off + 8).ok()? as u64;
        let va_rva = rdu32(data, off + 12).ok()? as u64;
        let raw_size = rdu32(data, off + 16).ok()? as u64;
        let file_off = rdu32(data, off + 20).ok()? as u64;
        let span = virt_size.max(raw_size);
        if rva >= va_rva && rva < va_rva + span {
            let delta = rva - va_rva;
            if delta < raw_size {
                return Some((file_off + delta) as usize);
            }
        }
    }
    None
}

fn rdu16(data: &[u8], off: usize) -> Result<u16> {
    if off + 2 > data.len() {
        return Err(Error::Parse("pe trunc u16".into()));
    }
    Ok(u16::from_le_bytes(data[off..off + 2].try_into().unwrap()))
}

fn rdu32(data: &[u8], off: usize) -> Result<u32> {
    if off + 4 > data.len() {
        return Err(Error::Parse("pe trunc u32".into()));
    }
    Ok(u32::from_le_bytes(data[off..off + 4].try_into().unwrap()))
}

fn rdu64(data: &[u8], off: usize) -> Result<u64> {
    if off + 8 > data.len() {
        return Err(Error::Parse("pe trunc u64".into()));
    }
    Ok(u64::from_le_bytes(data[off..off + 8].try_into().unwrap()))
}