use crate::error::{Error, Result};
use crate::import::RawImport;
use crate::{ImportKind, Symbol};
use std::sync::Arc;
const IMAGE_ORDINAL_FLAG64: u64 = 0x8000_0000_0000_0000;
const MAGIC_PE32_PLUS: u16 = 0x020B;
const MAGIC_PE32: u16 = 0x010B;
const DIRECTORY_ENTRY_IMPORT: usize = 1;
const DIRECTORY_ENTRY_DELAY_IMPORT: usize = 13;
const IMPORT_DESCRIPTOR_SIZE: usize = 20;
const DELAY_DESCRIPTOR_SIZE: usize = 32;
const THUNK_SIZE: usize = 8;
const MAX_DESCRIPTORS: usize = 8192;
const MAX_THUNKS: usize = 1 << 20;
const MAX_NAME_LEN: usize = 8192;
pub(crate) struct MappedImage {
base: usize,
size: usize,
}
impl MappedImage {
pub(crate) unsafe fn from_loaded(base: usize, size: usize) -> Self {
Self { base, size }
}
fn read<const N: usize>(&self, offset: usize) -> Result<[u8; N]> {
let end = offset
.checked_add(N)
.ok_or(Error::Malformed("offset arithmetic overflow"))?;
if end > self.size {
return Err(Error::Malformed("read past end of mapped image"));
}
let addr = self
.base
.checked_add(offset)
.ok_or(Error::Malformed("address arithmetic overflow"))?;
let mut buf = [0u8; N];
unsafe {
core::ptr::copy_nonoverlapping(addr as *const u8, buf.as_mut_ptr(), N);
}
Ok(buf)
}
fn u16(&self, offset: usize) -> Result<u16> {
Ok(u16::from_le_bytes(self.read::<2>(offset)?))
}
fn u32_as_usize(&self, offset: usize) -> Result<usize> {
Ok(u32::from_le_bytes(self.read::<4>(offset)?) as usize)
}
fn thunk(&self, offset: usize) -> Result<u64> {
Ok(u64::from_le_bytes(self.read::<8>(offset)?))
}
fn cstr(&self, offset: usize) -> Result<String> {
let mut bytes = Vec::new();
let mut cursor = offset;
loop {
let [byte] = self.read::<1>(cursor)?;
if byte == 0 {
break;
}
bytes.push(byte);
if bytes.len() > MAX_NAME_LEN {
return Err(Error::Malformed("unterminated import name string"));
}
cursor += 1;
}
Ok(String::from_utf8_lossy(&bytes).into_owned())
}
fn slot_address(&self, rva: usize) -> Result<usize> {
let end = rva
.checked_add(THUNK_SIZE)
.ok_or(Error::Malformed("slot arithmetic overflow"))?;
if end > self.size {
return Err(Error::Malformed("import slot past end of mapped image"));
}
if !rva.is_multiple_of(core::mem::align_of::<usize>()) {
return Err(Error::Malformed("import slot is not pointer-aligned"));
}
self.base
.checked_add(rva)
.ok_or(Error::Malformed("slot address overflow"))
}
fn field_rva(&self, field: usize, uses_rva: bool) -> Result<usize> {
if uses_rva {
return Ok(field);
}
let rva = field.checked_sub(self.base).ok_or(Error::Malformed(
"delay-import absolute VA below module base",
))?;
if rva >= self.size {
return Err(Error::Malformed(
"delay-import absolute VA outside mapped image",
));
}
Ok(rva)
}
}
struct Directories {
import: Option<usize>,
delay: Option<usize>,
}
fn parse_headers(image: &MappedImage) -> Result<Directories> {
if image.u16(0)? != 0x5A4D {
return Err(Error::Malformed("missing 'MZ' DOS signature"));
}
let e_lfanew = image.u32_as_usize(0x3C)?;
if image.read::<4>(e_lfanew)? != *b"PE\0\0" {
return Err(Error::Malformed("missing 'PE\\0\\0' NT signature"));
}
let file_header = e_lfanew
.checked_add(4)
.ok_or(Error::Malformed("NT header offset overflow"))?;
let machine = image.u16(file_header)?;
let size_of_optional = image.u16(file_header + 16)? as usize;
let optional = file_header
.checked_add(20)
.ok_or(Error::Malformed("optional header offset overflow"))?;
if size_of_optional < 112 {
return Err(Error::Malformed("optional header too small"));
}
let magic = image.u16(optional)?;
match magic {
MAGIC_PE32_PLUS => {}
MAGIC_PE32 => {
return Err(Error::Unsupported(
"PE32 (32-bit) image; only PE32+ is supported at runtime",
));
}
_ => return Err(Error::Malformed("unrecognized optional-header magic")),
}
if machine != crate::arch::HOST_MACHINE {
return Err(Error::Unsupported(
"image machine does not match host process",
));
}
let number_of_rva_and_sizes = image.u32_as_usize(optional + 108)?;
let data_dir_base = optional + 112;
let directory = |index: usize| -> Result<Option<usize>> {
if index >= number_of_rva_and_sizes {
return Ok(None);
}
let entry = data_dir_base + index * 8;
let rva = image.u32_as_usize(entry)?;
Ok((rva != 0).then_some(rva))
};
Ok(Directories {
import: directory(DIRECTORY_ENTRY_IMPORT)?,
delay: directory(DIRECTORY_ENTRY_DELAY_IMPORT)?,
})
}
pub(crate) fn validate(image: &MappedImage) -> Result<()> {
parse_headers(image).map(|_| ())
}
pub(crate) fn parse_imports(image: &MappedImage) -> Result<Vec<RawImport>> {
let dirs = parse_headers(image)?;
let mut out = Vec::new();
if let Some(rva) = dirs.import {
parse_standard(image, rva, &mut out)?;
}
if let Some(rva) = dirs.delay {
let mut delay = Vec::new();
if parse_delay(image, rva, &mut delay).is_ok() {
out.append(&mut delay);
}
}
Ok(out)
}
fn parse_standard(image: &MappedImage, dir_rva: usize, out: &mut Vec<RawImport>) -> Result<()> {
for i in 0..MAX_DESCRIPTORS {
let desc = dir_rva + i * IMPORT_DESCRIPTOR_SIZE;
let original_first_thunk = image.u32_as_usize(desc)?;
let name_rva = image.u32_as_usize(desc + 12)?;
let first_thunk = image.u32_as_usize(desc + 16)?;
if name_rva == 0 {
return Ok(());
}
if first_thunk == 0 {
continue;
}
let library: Arc<str> = image.cstr(name_rva)?.into();
collect_thunks(
image,
original_first_thunk,
first_thunk,
&library,
ImportKind::Standard,
out,
)?;
}
Err(Error::Malformed(
"import descriptor table is not NUL-terminated",
))
}
fn parse_delay(image: &MappedImage, dir_rva: usize, out: &mut Vec<RawImport>) -> Result<()> {
for i in 0..MAX_DESCRIPTORS {
let desc = dir_rva + i * DELAY_DESCRIPTOR_SIZE;
let attributes = image.u32_as_usize(desc)?;
let dll_name_rva = image.u32_as_usize(desc + 4)?;
let slots_field = image.u32_as_usize(desc + 12)?;
let names_field = image.u32_as_usize(desc + 16)?;
if dll_name_rva == 0 {
return Ok(());
}
let uses_rva = attributes & 0x1 != 0;
let library: Arc<str> = image.cstr(dll_name_rva)?.into();
if library.is_empty() {
continue;
}
if slots_field == 0 {
continue;
}
let names_rva = if names_field == 0 {
0
} else {
image.field_rva(names_field, uses_rva)?
};
let slots_rva = image.field_rva(slots_field, uses_rva)?;
collect_thunks(
image,
names_rva,
slots_rva,
&library,
ImportKind::DelayLoad,
out,
)?;
}
Err(Error::Malformed(
"delay-import descriptor table is not NUL-terminated",
))
}
fn collect_thunks(
image: &MappedImage,
names_rva: usize,
slots_rva: usize,
library: &Arc<str>,
kind: ImportKind,
out: &mut Vec<RawImport>,
) -> Result<()> {
if names_rva == 0 {
for j in 0..MAX_THUNKS {
let entry_rva = slots_rva + j * THUNK_SIZE;
if image.thunk(entry_rva)? == 0 {
return Ok(());
}
out.push(RawImport {
library: Arc::clone(library),
symbol: None,
version: None,
slot: image.slot_address(entry_rva)?,
kind,
authenticated: false,
});
}
return Err(Error::Malformed(
"import address table is not NUL-terminated",
));
}
let is_winsock2 = library.eq_ignore_ascii_case("ws2_32.dll");
for j in 0..MAX_THUNKS {
let name_entry = image.thunk(names_rva + j * THUNK_SIZE)?;
if name_entry == 0 {
return Ok(());
}
let symbol = if name_entry & IMAGE_ORDINAL_FLAG64 != 0 {
let ordinal = (name_entry & 0xFFFF) as u16;
match winsock2_ordinal2name(ordinal).filter(|_| is_winsock2) {
Some(name) => Symbol::Name(name.to_owned()),
None => Symbol::Ordinal(ordinal),
}
} else {
let by_name_rva = (name_entry & !IMAGE_ORDINAL_FLAG64) as usize;
Symbol::Name(image.cstr(by_name_rva + 2)?)
};
out.push(RawImport {
library: Arc::clone(library),
symbol: Some(symbol),
version: None,
slot: image.slot_address(slots_rva + j * THUNK_SIZE)?,
kind,
authenticated: false,
});
}
Err(Error::Malformed("import name table is not NUL-terminated"))
}
fn winsock2_ordinal2name(ordinal: u16) -> Option<&'static str> {
Some(match ordinal {
1 => "accept",
2 => "bind",
3 => "closesocket",
4 => "connect",
5 => "getpeername",
6 => "getsockname",
7 => "getsockopt",
8 => "htonl",
9 => "htons",
10 => "inet_addr",
11 => "inet_ntoa",
12 => "ioctlsocket",
13 => "listen",
14 => "ntohl",
15 => "ntohs",
16 => "recv",
17 => "recvfrom",
18 => "select",
19 => "send",
20 => "sendto",
21 => "setsockopt",
22 => "shutdown",
23 => "socket",
24 => "MigrateWinsockConfiguration",
51 => "gethostbyaddr",
52 => "gethostbyname",
53 => "getprotobyname",
54 => "getprotobynumber",
55 => "getservbyname",
56 => "getservbyport",
57 => "gethostname",
101 => "WSAAsyncSelect",
102 => "WSAAsyncGetHostByAddr",
103 => "WSAAsyncGetHostByName",
104 => "WSAAsyncGetProtoByNumber",
105 => "WSAAsyncGetProtoByName",
106 => "WSAAsyncGetServByPort",
107 => "WSAAsyncGetServByName",
108 => "WSACancelAsyncRequest",
109 => "WSASetBlockingHook",
110 => "WSAUnhookBlockingHook",
111 => "WSAGetLastError",
112 => "WSASetLastError",
113 => "WSACancelBlockingCall",
114 => "WSAIsBlocking",
115 => "WSAStartup",
116 => "WSACleanup",
151 => "__WSAFDIsSet",
500 => "WEP",
1000 => "WSApSetPostRoutine",
1001 => "WsControl",
1002 => "closesockinfo",
1003 => "Arecv",
1004 => "Asend",
1005 => "WSHEnumProtocols",
1100 => "inet_network",
1101 => "getnetbyname",
1102 => "rcmd",
1103 => "rexec",
1104 => "rresvport",
1105 => "sethostname",
1106 => "dn_expand",
1107 => "WSARecvEx",
1108 => "s_perror",
1109 => "GetAddressByNameA",
1110 => "GetAddressByNameW",
1111 => "EnumProtocolsA",
1112 => "EnumProtocolsW",
1113 => "GetTypeByNameA",
1114 => "GetTypeByNameW",
1115 => "GetNameByTypeA",
1116 => "GetNameByTypeW",
1117 => "SetServiceA",
1118 => "SetServiceW",
1119 => "GetServiceA",
1120 => "GetServiceW",
1130 => "NPLoadNameSpaces",
1131 => "NSPStartup",
1140 => "TransmitFile",
1141 => "AcceptEx",
1142 => "GetAcceptExSockaddrs",
_ => return None,
})
}
#[cfg(test)]
#[allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::indexing_slicing,
clippy::cast_possible_truncation,
clippy::panic,
// INT/IAT are the canonical PE abbreviations; their similarity is not a smell.
clippy::similar_names
)]
mod tests {
use super::*;
struct Builder {
buf: Vec<u8>,
}
const HEADER_AREA: usize = 0x200;
const E_LFANEW: usize = 0x80;
const OPTIONAL: usize = E_LFANEW + 4 + 20;
const DATA_DIR: usize = OPTIONAL + 112;
impl Builder {
fn new() -> Self {
Self {
buf: vec![0u8; HEADER_AREA],
}
}
fn rva(&self) -> u32 {
self.buf.len() as u32
}
fn align(&mut self, n: usize) {
while !self.buf.len().is_multiple_of(n) {
self.buf.push(0);
}
}
fn u16(&mut self, v: u16) {
self.buf.extend_from_slice(&v.to_le_bytes());
}
fn u32(&mut self, v: u32) {
self.buf.extend_from_slice(&v.to_le_bytes());
}
fn u64(&mut self, v: u64) {
self.buf.extend_from_slice(&v.to_le_bytes());
}
fn cstr(&mut self, s: &str) -> u32 {
let rva = self.rva();
self.buf.extend_from_slice(s.as_bytes());
self.buf.push(0);
rva
}
fn hint_name(&mut self, hint: u16, name: &str) -> u32 {
self.align(2);
let rva = self.rva();
self.u16(hint);
self.buf.extend_from_slice(name.as_bytes());
self.buf.push(0);
rva
}
fn poke(&mut self, off: usize, bytes: &[u8]) {
self.buf[off..off + bytes.len()].copy_from_slice(bytes);
}
fn finish(mut self, import_dir: (u32, u32), delay_dir: (u32, u32)) -> Vec<u8> {
let size_of_image = self.buf.len() as u32;
self.poke(0, b"MZ");
self.poke(0x3C, &(E_LFANEW as u32).to_le_bytes());
self.poke(E_LFANEW, b"PE\0\0");
self.poke(E_LFANEW + 4, &crate::arch::HOST_MACHINE.to_le_bytes());
self.poke(E_LFANEW + 4 + 16, &240u16.to_le_bytes()); self.poke(OPTIONAL, &MAGIC_PE32_PLUS.to_le_bytes());
self.poke(OPTIONAL + 56, &size_of_image.to_le_bytes()); self.poke(OPTIONAL + 108, &16u32.to_le_bytes()); self.poke(
DATA_DIR + DIRECTORY_ENTRY_IMPORT * 8,
&import_dir.0.to_le_bytes(),
);
self.poke(
DATA_DIR + DIRECTORY_ENTRY_IMPORT * 8 + 4,
&import_dir.1.to_le_bytes(),
);
self.poke(
DATA_DIR + DIRECTORY_ENTRY_DELAY_IMPORT * 8,
&delay_dir.0.to_le_bytes(),
);
self.poke(
DATA_DIR + DIRECTORY_ENTRY_DELAY_IMPORT * 8 + 4,
&delay_dir.1.to_le_bytes(),
);
self.buf
}
}
fn parse(bytes: &[u8]) -> Result<Vec<RawImport>> {
let image = unsafe { MappedImage::from_loaded(bytes.as_ptr() as usize, bytes.len()) };
parse_imports(&image)
}
#[test]
fn standard_named_and_ordinal_imports() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..5 {
b.u32(0);
}
b.u32(0); for _ in 0..4 {
b.u32(0);
}
let name_rva = b.cstr("KERNEL32.dll");
let create = b.hint_name(0x0100, "CreateFileW");
b.align(8);
let int_rva = b.rva();
b.u64(u64::from(create)); b.u64(IMAGE_ORDINAL_FLAG64 | 7); b.u64(0); let iat_rva = b.rva();
b.u64(0x1111); b.u64(0x2222); b.u64(0); b.poke(desc_rva as usize, &int_rva.to_le_bytes()); b.poke(desc_rva as usize + 12, &name_rva.to_le_bytes()); b.poke(desc_rva as usize + 16, &iat_rva.to_le_bytes());
let bytes = b.finish((desc_rva, 40), (0, 0));
let base = bytes.as_ptr() as usize;
let imports = parse(&bytes).expect("well-formed image parses");
assert_eq!(imports.len(), 2);
assert_eq!(&*imports[0].library, "KERNEL32.dll");
assert_eq!(imports[0].symbol, Some(Symbol::Name("CreateFileW".into())));
assert_eq!(imports[0].kind, ImportKind::Standard);
assert_eq!(imports[0].slot, base + iat_rva as usize);
assert_eq!(imports[1].symbol, Some(Symbol::Ordinal(7)));
assert_eq!(imports[1].slot, base + iat_rva as usize + 8); }
#[test]
fn undersized_import_directory_size_enumerates_to_null_terminator() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..(3 * 5) {
b.u32(0);
}
let name_a = b.cstr("KERNEL32.dll");
let func_a = b.hint_name(0, "CreateFileW");
b.align(8);
let int_a = b.rva();
b.u64(u64::from(func_a));
b.u64(0);
let iat_a = b.rva();
b.u64(0x1111);
b.u64(0);
let name_b = b.cstr("USER32.dll");
let func_b = b.hint_name(0, "MessageBoxW");
b.align(8);
let int_b = b.rva();
b.u64(u64::from(func_b));
b.u64(0);
let iat_b = b.rva();
b.u64(0x2222);
b.u64(0);
b.poke(desc_rva as usize, &int_a.to_le_bytes());
b.poke(desc_rva as usize + 12, &name_a.to_le_bytes());
b.poke(desc_rva as usize + 16, &iat_a.to_le_bytes());
b.poke(desc_rva as usize + 20, &int_b.to_le_bytes());
b.poke(desc_rva as usize + 20 + 12, &name_b.to_le_bytes());
b.poke(desc_rva as usize + 20 + 16, &iat_b.to_le_bytes());
let bytes = b.finish((desc_rva, IMPORT_DESCRIPTOR_SIZE as u32), (0, 0));
let imports = parse(&bytes).expect("under-sized directory still parses");
assert_eq!(
imports.len(),
2,
"both descriptors enumerated past the under-sized Size"
);
assert_eq!(&*imports[0].library, "KERNEL32.dll");
assert_eq!(imports[0].symbol, Some(Symbol::Name("CreateFileW".into())));
assert_eq!(&*imports[1].library, "USER32.dll");
assert_eq!(imports[1].symbol, Some(Symbol::Name("MessageBoxW".into())));
}
#[test]
fn original_first_thunk_zero_is_address_only() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..10 {
b.u32(0);
}
let name_rva = b.cstr("LEGACY.dll");
b.align(8);
let iat_rva = b.rva();
b.u64(0xAAAA); b.u64(0xBBBB);
b.u64(0); b.poke(desc_rva as usize + 12, &name_rva.to_le_bytes());
b.poke(desc_rva as usize + 16, &iat_rva.to_le_bytes());
let bytes = b.finish((desc_rva, 40), (0, 0));
let imports = parse(&bytes).expect("OFT==0 image parses");
assert_eq!(imports.len(), 2);
assert!(imports.iter().all(|i| i.symbol.is_none()));
assert!(imports.iter().all(|i| &*i.library == "LEGACY.dll"));
}
#[test]
fn delay_import_rva_based() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..8 {
b.u32(0);
}
b.u32(0); for _ in 0..7 {
b.u32(0);
}
let name_rva = b.cstr("DELAYED.dll");
let func = b.hint_name(0, "DelayedFunc");
b.align(8);
let int_rva = b.rva();
b.u64(u64::from(func));
b.u64(0);
let iat_rva = b.rva();
b.u64(0xDEAD); b.u64(0);
b.poke(desc_rva as usize, &1u32.to_le_bytes()); b.poke(desc_rva as usize + 4, &name_rva.to_le_bytes()); b.poke(desc_rva as usize + 12, &iat_rva.to_le_bytes()); b.poke(desc_rva as usize + 16, &int_rva.to_le_bytes());
let bytes = b.finish((0, 0), (desc_rva, 64));
let imports = parse(&bytes).expect("delay-import image parses");
assert_eq!(imports.len(), 1);
assert_eq!(&*imports[0].library, "DELAYED.dll");
assert_eq!(imports[0].symbol, Some(Symbol::Name("DelayedFunc".into())));
assert_eq!(imports[0].kind, ImportKind::DelayLoad);
}
#[test]
fn field_rva_interprets_rva_and_va() {
let buf = vec![0u8; 0x1000];
let base = buf.as_ptr() as usize;
let image = unsafe { MappedImage::from_loaded(base, buf.len()) };
assert_eq!(image.field_rva(0x500, true).unwrap(), 0x500);
assert_eq!(image.field_rva(base + 0x40, false).unwrap(), 0x40);
assert_eq!(image.field_rva(base + 0xFFF, false).unwrap(), 0xFFF);
assert!(image.field_rva(base - 1, false).is_err());
assert!(image.field_rva(base + 0x1000, false).is_err());
}
#[test]
fn delay_failure_preserves_standard_imports() {
let mut b = Builder::new();
let std_desc = b.rva();
for _ in 0..10 {
b.u32(0); }
let kname = b.cstr("KERNEL32.dll");
let create = b.hint_name(0, "CreateFileW");
b.align(8);
let std_int = b.rva();
b.u64(u64::from(create));
b.u64(0);
let std_iat = b.rva();
b.u64(0x1111);
b.u64(0);
b.poke(std_desc as usize, &std_int.to_le_bytes());
b.poke(std_desc as usize + 12, &kname.to_le_bytes());
b.poke(std_desc as usize + 16, &std_iat.to_le_bytes());
let delay_desc = b.rva();
for _ in 0..8 {
b.u32(0); }
for _ in 0..8 {
b.u32(0); }
let oldname = b.cstr("OLD.dll");
b.poke(delay_desc as usize + 4, &oldname.to_le_bytes()); b.poke(delay_desc as usize + 12, &0x100u32.to_le_bytes());
let bytes = b.finish((std_desc, 40), (delay_desc, 64));
let imports = parse(&bytes).expect("standard imports survive a broken delay directory");
assert_eq!(
imports.len(),
1,
"delay contribution dropped, standard import kept"
);
assert_eq!(&*imports[0].library, "KERNEL32.dll");
assert_eq!(imports[0].symbol, Some(Symbol::Name("CreateFileW".into())));
assert_eq!(imports[0].kind, ImportKind::Standard);
}
#[test]
fn winsock2_ordinal_resolves_to_name() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..10 {
b.u32(0);
}
let name_rva = b.cstr("WS2_32.dll");
b.align(8);
let int_rva = b.rva();
let unknown_ordinal: u64 = 8888; b.u64(IMAGE_ORDINAL_FLAG64 | 4); b.u64(IMAGE_ORDINAL_FLAG64 | unknown_ordinal);
b.u64(0);
let iat_rva = b.rva();
b.u64(0x1111);
b.u64(0x2222);
b.u64(0);
b.poke(desc_rva as usize, &int_rva.to_le_bytes());
b.poke(desc_rva as usize + 12, &name_rva.to_le_bytes());
b.poke(desc_rva as usize + 16, &iat_rva.to_le_bytes());
let bytes = b.finish((desc_rva, 40), (0, 0));
let imports = parse(&bytes).expect("winsock image parses");
assert_eq!(imports.len(), 2);
assert_eq!(imports[0].symbol, Some(Symbol::Name("connect".into())));
assert_eq!(imports[1].symbol, Some(Symbol::Ordinal(8888)));
}
#[test]
fn non_winsock_ordinal_is_not_named() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..10 {
b.u32(0);
}
let name_rva = b.cstr("OLEAUT32.dll");
b.align(8);
let int_rva = b.rva();
b.u64(IMAGE_ORDINAL_FLAG64 | 4);
b.u64(0);
let iat_rva = b.rva();
b.u64(0x1111);
b.u64(0);
b.poke(desc_rva as usize, &int_rva.to_le_bytes());
b.poke(desc_rva as usize + 12, &name_rva.to_le_bytes());
b.poke(desc_rva as usize + 16, &iat_rva.to_le_bytes());
let bytes = b.finish((desc_rva, 40), (0, 0));
let imports = parse(&bytes).expect("image parses");
assert_eq!(imports.len(), 1);
assert_eq!(imports[0].symbol, Some(Symbol::Ordinal(4)));
}
#[test]
fn bad_dos_signature_is_malformed() {
let bytes = vec![0u8; HEADER_AREA];
assert!(matches!(parse(&bytes), Err(Error::Malformed(_))));
}
#[test]
fn validate_accepts_a_good_header_and_rejects_a_bad_one() {
let good = Builder::new().finish((0, 0), (0, 0));
let image = unsafe { MappedImage::from_loaded(good.as_ptr() as usize, good.len()) };
assert!(
validate(&image).is_ok(),
"a well-formed PE32+ header validates"
);
let bad = vec![0u8; HEADER_AREA];
let image = unsafe { MappedImage::from_loaded(bad.as_ptr() as usize, bad.len()) };
assert!(validate(&image).is_err(), "an all-zero header is rejected");
}
#[test]
fn out_of_range_e_lfanew_is_malformed() {
let mut bytes = Builder::new().finish((0, 0), (0, 0));
bytes[0x3C..0x40].copy_from_slice(&0x00FF_FFFFu32.to_le_bytes());
assert!(matches!(parse(&bytes), Err(Error::Malformed(_))));
}
#[test]
fn pe32_is_unsupported() {
let mut bytes = Builder::new().finish((0, 0), (0, 0));
bytes[OPTIONAL..OPTIONAL + 2].copy_from_slice(&MAGIC_PE32.to_le_bytes());
assert!(matches!(parse(&bytes), Err(Error::Unsupported(_))));
}
#[test]
fn import_directory_past_end_is_malformed() {
let bytes = Builder::new().finish((0x00FF_FFFF, 40), (0, 0));
assert!(matches!(parse(&bytes), Err(Error::Malformed(_))));
}
#[test]
fn truncated_thunk_table_is_malformed() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..10 {
b.u32(0);
}
let name_rva = b.cstr("KERNEL32.dll");
b.align(8);
let iat_rva = b.rva();
b.u64(0x1111);
b.poke(desc_rva as usize + 16, &iat_rva.to_le_bytes());
b.poke(desc_rva as usize + 12, &name_rva.to_le_bytes());
let bytes = b.finish((desc_rva, 40), (0, 0));
assert!(matches!(parse(&bytes), Err(Error::Malformed(_))));
}
#[test]
fn truncated_optional_header_is_rejected() {
let mut bytes = Builder::new().finish((0, 0), (0, 0));
let size_field = E_LFANEW + 4 + 16;
bytes[size_field..size_field + 2].copy_from_slice(&100u16.to_le_bytes());
match parse(&bytes) {
Err(Error::Malformed(msg)) => {
assert!(msg.contains("optional header too small"), "got: {msg}");
}
other => panic!("expected the truncated-optional-header guard to fire, got {other:?}"),
}
}
#[test]
fn misaligned_iat_slot_is_malformed() {
let mut b = Builder::new();
let desc_rva = b.rva();
for _ in 0..10 {
b.u32(0);
}
let name_rva = b.cstr("KERNEL32.dll");
let create = b.hint_name(0, "CreateFileW");
b.align(8);
let int_rva = b.rva();
b.u64(u64::from(create)); b.u64(0); b.align(8);
let iat_rva = b.rva();
b.u64(0x1111); b.u64(0); b.u64(0);
b.poke(desc_rva as usize, &int_rva.to_le_bytes()); b.poke(desc_rva as usize + 12, &name_rva.to_le_bytes()); b.poke(desc_rva as usize + 16, &(iat_rva + 4).to_le_bytes());
let bytes = b.finish((desc_rva, 40), (0, 0));
match parse(&bytes) {
Err(Error::Malformed(msg)) => assert!(msg.contains("aligned"), "got: {msg}"),
other => panic!("expected a pointer-alignment rejection, got {other:?}"),
}
}
#[test]
fn fuzz_never_panics_or_reads_oob() {
let mut state: u64 = 0x9E37_79B9_7F4A_7C15;
let mut next = || {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
state
};
for _ in 0..4000 {
let len = (next() as usize % 4096) + 1;
let mut buf = vec![0u8; len];
for byte in &mut buf {
*byte = next() as u8;
}
let _ = parse(&buf);
}
let mut base = Builder::new();
let desc_rva = base.rva();
for _ in 0..10 {
base.u32(0);
}
let name_rva = base.cstr("KERNEL32.dll");
let create = base.hint_name(0, "CreateFileW");
base.align(8);
let int_rva = base.rva();
base.u64(u64::from(create));
base.u64(0);
let iat_rva = base.rva();
base.u64(0x1111);
base.u64(0);
base.poke(desc_rva as usize, &int_rva.to_le_bytes());
base.poke(desc_rva as usize + 12, &name_rva.to_le_bytes());
base.poke(desc_rva as usize + 16, &iat_rva.to_le_bytes());
let valid = base.finish((desc_rva, 40), (0, 0));
parse(&valid).expect("baseline valid image parses");
for _ in 0..8000 {
let mut corrupt = valid.clone();
let idx = next() as usize % corrupt.len();
corrupt[idx] ^= next() as u8;
let _ = parse(&corrupt);
}
}
}