use crate::{
coff::{
constants::IMAGE_SIZEOF_IMPORT_DESCRIPTOR,
pe::{DataDirectory, ImportDescriptor},
},
endian::U32,
util::align_up_u32,
};
pub const IMP_PREFIX: &[u8] = b"__imp_";
#[derive(Clone)]
pub struct ImportEntry {
pub dll: Vec<u8>,
pub func: Vec<u8>,
}
pub struct ImportPlan {
bytes: Vec<u8>,
slots: Vec<(Vec<u8>, u32)>,
groups: Vec<DllGroup>,
descriptors_off: u32,
iat_off: u32,
iat_len: u32,
import_dir_rva: u32,
import_dir_size: u32,
iat_rva: u32,
iat_size: u32,
}
#[derive(Clone)]
struct DllGroup {
name: Vec<u8>,
name_off: u32,
ilt_off: u32,
iat_off: u32,
funcs: Vec<FuncSlot>,
}
#[derive(Clone)]
struct FuncSlot {
name: Vec<u8>,
hint_off: u32,
iat_slot_off: u32,
}
impl ImportPlan {
pub fn new(entries: &[ImportEntry]) -> Self {
let groups = build_groups(entries);
let (bytes, groups, descriptors_off, iat_off, iat_len) =
layout_bytes(groups);
Self {
bytes,
slots: Vec::new(),
groups,
descriptors_off,
iat_off,
iat_len,
import_dir_rva: 0,
import_dir_size: 0,
iat_rva: 0,
iat_size: 0,
}
}
pub fn size(&self) -> u32 {
u32::try_from(self.bytes.len()).unwrap_or(u32::MAX)
}
pub fn is_empty(&self) -> bool {
self.groups.is_empty()
}
pub fn finalize(&mut self, base_rva: u32) {
self.write_thunks(base_rva);
self.write_descriptors(base_rva);
self.import_dir_rva = base_rva.wrapping_add(self.descriptors_off);
let n = u32::try_from(self.groups.len() + 1).unwrap_or(u32::MAX);
let step = u32::try_from(IMAGE_SIZEOF_IMPORT_DESCRIPTOR).unwrap_or(0);
self.import_dir_size = n.wrapping_mul(step);
self.iat_rva = base_rva.wrapping_add(self.iat_off);
self.iat_size = self.iat_len;
self.slots.clear();
for g in &self.groups {
for f in &g.funcs {
let rva = base_rva.wrapping_add(f.iat_slot_off);
self.slots.push((f.name.clone(), rva));
}
}
}
fn write_thunks(&mut self, base_rva: u32) {
for g in &self.groups {
for (i, f) in g.funcs.iter().enumerate() {
let hint_rva = base_rva.wrapping_add(f.hint_off);
let ilt_slot =
g.ilt_off.wrapping_add(u32::try_from(i).unwrap_or(0) * 8);
write_thunk(&mut self.bytes, ilt_slot, hint_rva);
write_thunk(&mut self.bytes, f.iat_slot_off, hint_rva);
}
}
}
fn write_descriptors(&mut self, base_rva: u32) {
let step = u32::try_from(IMAGE_SIZEOF_IMPORT_DESCRIPTOR).unwrap_or(0);
for (i, g) in self.groups.iter().enumerate() {
let off = self
.descriptors_off
.wrapping_add(u32::try_from(i).unwrap_or(0) * step);
let desc = ImportDescriptor {
original_first_thunk: U32::new(
base_rva.wrapping_add(g.ilt_off),
),
time_date_stamp: U32::new(0),
forwarder_chain: U32::new(0),
name: U32::new(base_rva.wrapping_add(g.name_off)),
first_thunk: U32::new(base_rva.wrapping_add(g.iat_off)),
};
write_bytes(&mut self.bytes, off, bytemuck::bytes_of(&desc));
}
}
pub fn iat_slot_rva(&self, func: &[u8]) -> Option<u32> {
self.slots
.iter()
.find(|(name, _)| name == func)
.map(|(_, rva)| *rva)
}
pub fn bytes(&self) -> &[u8] {
&self.bytes
}
pub fn directories(&self) -> [DataDirectory; 2] {
[
DataDirectory {
virtual_address: U32::new(self.import_dir_rva),
size: U32::new(self.import_dir_size),
},
DataDirectory {
virtual_address: U32::new(self.iat_rva),
size: U32::new(self.iat_size),
},
]
}
}
fn build_groups(entries: &[ImportEntry]) -> Vec<DllGroup> {
let mut pairs: Vec<(&[u8], &[u8])> =
entries.iter().map(|e| (&e.dll[..], &e.func[..])).collect();
pairs.sort();
pairs.dedup();
let mut groups: Vec<DllGroup> = Vec::new();
for (dll, func) in pairs {
if func.is_empty() {
continue;
}
if let Some(g) = groups.last_mut().filter(|g| g.name == dll) {
g.funcs.push(FuncSlot {
name: func.to_vec(),
hint_off: 0,
iat_slot_off: 0,
});
continue;
}
groups.push(DllGroup {
name: dll.to_vec(),
name_off: 0,
ilt_off: 0,
iat_off: 0,
funcs: vec![FuncSlot {
name: func.to_vec(),
hint_off: 0,
iat_slot_off: 0,
}],
});
}
groups
}
#[allow(clippy::similar_names)] fn layout_bytes(
mut groups: Vec<DllGroup>,
) -> (Vec<u8>, Vec<DllGroup>, u32, u32, u32) {
let step = u32::try_from(IMAGE_SIZEOF_IMPORT_DESCRIPTOR).unwrap_or(0);
let n = u32::try_from(groups.len()).unwrap_or(0);
let descriptors_off = 0u32;
let descriptors_len = n.wrapping_add(1).wrapping_mul(step);
let ilt_len = groups
.iter()
.map(|g| u32::try_from(g.funcs.len() + 1).unwrap_or(0) * 8)
.sum::<u32>();
let ilt_off = descriptors_off.wrapping_add(descriptors_len);
let iat_off = ilt_off.wrapping_add(ilt_len);
let iat_len = ilt_len;
let hint_region_len: u32 = groups
.iter()
.flat_map(|g| g.funcs.iter())
.map(|f| hint_name_len(&f.name))
.sum();
let mut hint_cursor = iat_off.wrapping_add(iat_len);
let mut name_cursor = hint_cursor.wrapping_add(hint_region_len);
let mut ilt_cursor = ilt_off;
let mut iat_cursor = iat_off;
for g in &mut groups {
g.ilt_off = ilt_cursor;
g.iat_off = iat_cursor;
for (i, f) in g.funcs.iter_mut().enumerate() {
f.hint_off = hint_cursor;
hint_cursor = hint_cursor.wrapping_add(hint_name_len(&f.name));
f.iat_slot_off =
iat_cursor.wrapping_add(u32::try_from(i).unwrap_or(0) * 8);
}
let advance = u32::try_from(g.funcs.len() + 1).unwrap_or(0) * 8;
ilt_cursor = ilt_cursor.wrapping_add(advance);
iat_cursor = iat_cursor.wrapping_add(advance);
g.name_off = name_cursor;
name_cursor = name_cursor.wrapping_add(name_len(&g.name));
}
let total = name_cursor;
let mut bytes = vec![0u8; usize::try_from(total).unwrap_or(0)];
for g in &groups {
write_name(&mut bytes, g.name_off, &g.name);
for f in &g.funcs {
write_hint_name(&mut bytes, f.hint_off, &f.name);
}
}
(bytes, groups, descriptors_off, iat_off, iat_len)
}
fn hint_name_len(func: &[u8]) -> u32 {
let raw = 2u32
.wrapping_add(u32::try_from(func.len()).unwrap_or(0))
.wrapping_add(1);
align_up_u32(raw, 2)
}
fn name_len(name: &[u8]) -> u32 {
u32::try_from(name.len()).unwrap_or(0).wrapping_add(1)
}
fn write_bytes(bytes: &mut [u8], off: u32, src: &[u8]) {
let start = usize::try_from(off).unwrap_or(usize::MAX);
let end = start.saturating_add(src.len());
if let Some(slot) = bytes.get_mut(start..end) {
slot.copy_from_slice(src);
}
}
fn write_hint_name(bytes: &mut [u8], off: u32, func: &[u8]) {
write_bytes(bytes, off.wrapping_add(2), func);
}
fn write_name(bytes: &mut [u8], off: u32, name: &[u8]) {
write_bytes(bytes, off, name);
}
fn write_thunk(bytes: &mut [u8], off: u32, rva: u32) {
write_bytes(bytes, off, &u64::from(rva).to_le_bytes());
}