use crate::{
coff::{
CoffFile,
constants::IMAGE_SIZEOF_EXPORT_DIRECTORY,
pe::{DataDirectory, ExportDirectory},
},
endian::{U16, U32},
error::{Error, Result},
util::trim_nul,
};
pub const EXPORT_ORDINAL_BASE: u32 = 1;
#[derive(Clone)]
pub struct ExportEntry {
pub name: Vec<u8>,
pub internal: Vec<u8>,
}
pub struct ExportPlan {
bytes: Vec<u8>,
names: Vec<Vec<u8>>,
internals: Vec<Vec<u8>>,
directory: DataDirectory,
header_off: u32,
func_table_off: u32,
name_table_off: u32,
ordinal_table_off: u32,
dll_name_off: u32,
name_string_offs: Vec<u32>,
}
impl ExportPlan {
pub fn new(entries: &[ExportEntry], dll_name: &[u8]) -> Self {
let mut rows: Vec<(Vec<u8>, Vec<u8>)> = entries
.iter()
.map(|e| (e.name.clone(), e.internal.clone()))
.collect();
rows.sort();
rows.dedup_by(|a, b| a.0 == b.0);
let (names, internals): (Vec<Vec<u8>>, Vec<Vec<u8>>) =
rows.into_iter().unzip();
let n = u32::try_from(names.len()).unwrap_or(0);
let header_off: u32 = 0;
let header_len =
u32::try_from(IMAGE_SIZEOF_EXPORT_DIRECTORY).unwrap_or(0);
let func_table_off = header_off.wrapping_add(header_len);
let name_table_off = func_table_off.wrapping_add(n.wrapping_mul(4));
let ordinal_table_off = name_table_off.wrapping_add(n.wrapping_mul(4));
let dll_name_off = ordinal_table_off.wrapping_add(n.wrapping_mul(2));
let dll_name_len = string_len(dll_name);
let mut name_string_offs = Vec::with_capacity(names.len());
let mut cursor = dll_name_off.wrapping_add(dll_name_len);
for name in &names {
name_string_offs.push(cursor);
cursor = cursor.wrapping_add(string_len(name));
}
let total = cursor;
let mut bytes = vec![0u8; usize::try_from(total).unwrap_or(0)];
write_bytes(&mut bytes, dll_name_off, dll_name);
for (i, name) in names.iter().enumerate() {
let off = name_string_offs[i];
write_bytes(&mut bytes, off, name);
}
for i in 0..n {
let off = ordinal_table_off.wrapping_add(i.wrapping_mul(2));
write_u16(&mut bytes, off, u16::try_from(i).unwrap_or(u16::MAX));
}
Self {
bytes,
names,
internals,
directory: DataDirectory::default(),
header_off,
func_table_off,
name_table_off,
ordinal_table_off,
dll_name_off,
name_string_offs,
}
}
pub fn size(&self) -> u32 {
u32::try_from(self.bytes.len()).unwrap_or(u32::MAX)
}
pub fn names(&self) -> &[Vec<u8>] {
&self.names
}
pub fn resolved_pairs(&self) -> impl Iterator<Item = (&[u8], &[u8])> {
self.names
.iter()
.zip(&self.internals)
.map(|(n, i)| (n.as_slice(), i.as_slice()))
}
pub fn finalize(
&mut self,
base_rva: u32,
resolve: impl Fn(&[u8]) -> Option<u32>,
) {
let n = u32::try_from(self.names.len()).unwrap_or(0);
let header = ExportDirectory {
characteristics: U32::new(0),
time_date_stamp: U32::new(0),
major_version: U16::new(0),
minor_version: U16::new(0),
name: U32::new(base_rva.wrapping_add(self.dll_name_off)),
base: U32::new(EXPORT_ORDINAL_BASE),
number_of_functions: U32::new(n),
number_of_names: U32::new(n),
address_of_functions: U32::new(
base_rva.wrapping_add(self.func_table_off),
),
address_of_names: U32::new(
base_rva.wrapping_add(self.name_table_off),
),
address_of_name_ordinals: U32::new(
base_rva.wrapping_add(self.ordinal_table_off),
),
};
write_pod(&mut self.bytes, self.header_off, &header);
for (i, name) in self.internals.iter().enumerate() {
let i = u32::try_from(i).unwrap_or(0);
let func_rva = resolve(name).unwrap_or(0);
write_u32(
&mut self.bytes,
self.func_table_off.wrapping_add(i.wrapping_mul(4)),
func_rva,
);
let name_rva = base_rva.wrapping_add(
*self.name_string_offs.get(i as usize).unwrap_or(&0),
);
write_u32(
&mut self.bytes,
self.name_table_off.wrapping_add(i.wrapping_mul(4)),
name_rva,
);
}
let size = u32::try_from(self.bytes.len()).unwrap_or(0);
self.directory = DataDirectory {
virtual_address: U32::new(base_rva.wrapping_add(self.header_off)),
size: U32::new(size),
};
}
pub fn directory(&self) -> DataDirectory {
self.directory
}
pub fn bytes(&self) -> &[u8] {
&self.bytes
}
}
pub fn collect_directives(inputs: &[CoffFile<'_>]) -> Result<Vec<ExportEntry>> {
let mut out = Vec::new();
for input in inputs {
for section in input.sections() {
if !is_drectve(section.name) {
continue;
}
parse_directives(section.data, &mut out)?;
}
}
Ok(out)
}
fn is_drectve(name: &[u8]) -> bool {
trim_nul(name) == b".drectve"
}
pub fn parse_directives(data: &[u8], out: &mut Vec<ExportEntry>) -> Result<()> {
for raw in split_tokens(data)? {
let Some(token) = strip_option_prefix(raw) else {
continue;
};
let Some((key, value)) = split_option_value(token) else {
continue;
};
if !eq_ignore_case(key, b"export") {
continue;
}
let (name, internal) = export_name(value)?;
if name.is_empty() {
return Err(Error::Format("empty name in /EXPORT directive"));
}
out.push(ExportEntry { name, internal });
}
Ok(())
}
fn split_tokens(data: &[u8]) -> Result<Vec<&[u8]>> {
let mut out = Vec::new();
let mut start: Option<usize> = None;
let mut quoted = false;
let mut i = 0;
while i < data.len() {
let b = data[i];
if quoted {
if b == b'"' {
if data.get(i + 1) == Some(&b'"') {
i += 2;
continue;
}
quoted = false;
}
i += 1;
continue;
}
if b == b'"' {
quoted = true;
start = Some(start.unwrap_or(i));
i += 1;
continue;
}
if b.is_ascii_whitespace() {
if let Some(s) = start.take() {
out.push(&data[s..i]);
}
i += 1;
continue;
}
start = Some(start.unwrap_or(i));
i += 1;
}
if quoted {
return Err(Error::Format("unterminated quote in .drectve"));
}
if let Some(s) = start {
out.push(&data[s..]);
}
Ok(out)
}
fn strip_option_prefix(token: &[u8]) -> Option<&[u8]> {
token
.strip_prefix(b"/")
.or_else(|| token.strip_prefix(b"-"))
}
fn split_option_value(token: &[u8]) -> Option<(&[u8], &[u8])> {
let pos = token.iter().position(|&b| b == b':' || b == b'=')?;
Some((&token[..pos], &token[pos + 1..]))
}
fn export_name(value: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {
let mut name = Vec::with_capacity(value.len());
let mut internal: Option<Vec<u8>> = None;
let mut quoted = false;
let mut i = 0;
while i < value.len() {
let b = value[i];
if b == b'"' {
if quoted && value.get(i + 1) == Some(&b'"') {
push_name_byte(&mut name, internal.as_mut(), b'"');
i += 2;
continue;
}
quoted = !quoted;
i += 1;
continue;
}
if !quoted && b == b',' {
check_export_params(&value[i + 1..])?;
break;
}
if !quoted && b == b'=' && internal.is_none() {
internal = Some(Vec::new());
i += 1;
continue;
}
push_name_byte(&mut name, internal.as_mut(), b);
i += 1;
}
if quoted {
return Err(Error::Format("unterminated quoted /EXPORT name"));
}
let Some(internal) = internal else {
let plain = name.clone();
return Ok((name, plain));
};
if internal.contains(&b'.') {
return Err(Error::Format(
"re-export forwarder in /EXPORT directive is not supported",
));
}
if internal.is_empty() {
return Err(Error::Format("empty target in /EXPORT alias"));
}
Ok((name, internal))
}
fn check_export_params(rest: &[u8]) -> Result<()> {
for param in rest.split(|&b| b == b',') {
let param = trim_ascii_space(param);
if param.first() == Some(&b'@') {
return Err(Error::Format(
"an explicit ordinal in /EXPORT is not supported",
));
}
if eq_ignore_case(param, b"noname") {
return Err(Error::Format("NONAME in /EXPORT is not supported"));
}
}
Ok(())
}
fn trim_ascii_space(bytes: &[u8]) -> &[u8] {
let start = bytes
.iter()
.position(|b| !b.is_ascii_whitespace())
.unwrap_or(bytes.len());
let end = bytes
.iter()
.rposition(|b| !b.is_ascii_whitespace())
.map_or(start, |p| p + 1);
&bytes[start..end]
}
fn push_name_byte(name: &mut Vec<u8>, internal: Option<&mut Vec<u8>>, b: u8) {
match internal {
Some(v) => v.push(b),
None => name.push(b),
}
}
fn eq_ignore_case(a: &[u8], b: &[u8]) -> bool {
a.len() == b.len()
&& a.iter().zip(b).all(|(x, y)| x.eq_ignore_ascii_case(y))
}
fn string_len(s: &[u8]) -> u32 {
u32::try_from(s.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_u16(bytes: &mut [u8], off: u32, value: u16) {
write_bytes(bytes, off, &value.to_le_bytes());
}
fn write_u32(bytes: &mut [u8], off: u32, value: u32) {
write_bytes(bytes, off, &value.to_le_bytes());
}
fn write_pod<T: bytemuck::Pod>(bytes: &mut [u8], off: u32, value: &T) {
write_bytes(bytes, off, bytemuck::bytes_of(value));
}