use std::path::Path;
use rustc_hash::FxHashMap;
use crate::{
coff::{
CoffFile, CoffSymbolTable,
basereloc::RelocPlan,
comdat::ComdatPlan,
commons::CommonsPlan,
constants::{
FILE_ALIGNMENT, IMAGE_BASE_DLL_X86_64, IMAGE_BASE_X86_64,
IMAGE_DIRECTORY_ENTRY_BASERELOC, IMAGE_DIRECTORY_ENTRY_EXPORT,
IMAGE_DIRECTORY_ENTRY_IAT, IMAGE_DIRECTORY_ENTRY_IMPORT,
IMAGE_DIRECTORY_ENTRY_RESOURCE, IMAGE_DIRECTORY_ENTRY_TLS,
IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE,
IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA,
IMAGE_DLLCHARACTERISTICS_NX_COMPAT, IMAGE_FILE_DLL,
IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LARGE_ADDRESS_AWARE,
IMAGE_FILE_LINE_NUMS_STRIPPED, IMAGE_FILE_LOCAL_SYMS_STRIPPED,
IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_I386,
IMAGE_NT_OPTIONAL_HDR64_MAGIC, IMAGE_NT_SIGNATURE,
IMAGE_NUMBEROF_DIRECTORY_ENTRIES, IMAGE_SIZEOF_DOS_HEADER,
IMAGE_SIZEOF_OPTIONAL_HEADER64, IMAGE_SUBSYSTEM_WINDOWS_CUI,
IMAGE_SYM_ABSOLUTE, IMAGE_SYM_CLASS_EXTERNAL, IMAGE_SYM_UNDEFINED,
SECTION_ALIGNMENT,
},
dllmap,
exports::{ExportPlan, collect_directives},
imports::{IMP_PREFIX, ImportEntry, ImportPlan},
layout::{self, ENTRY_STUB_SIZE, OutSection, PeLayout, TLS_DIR_SIZE},
pe::{
DataDirectory, DosHeader, NtFileHeader, OptionalHeader64,
SectionHeader,
},
reloc::{CoffTarget, global_symbol_addr},
sections,
tls::{self, TlsPlan},
},
endian::{U16, U32, U64},
error::{Error, Result},
input::{Input, InputBytes},
pool,
util::{open_all, show, trim_nul, write_output, write_pod},
};
const TLS_INDEX_NAME: &[u8] = b"_tls_index";
const IMAGE_BASE_NAME: &[u8] = b"__ImageBase";
pub fn link_coff(
inputs: &[Input<'_>],
output: &Path,
entry: &[u8],
shared: bool,
) -> Result<()> {
let opened = open_all(inputs)?;
let bytes: Vec<&[u8]> = opened.iter().map(InputBytes::bytes).collect();
pool::run(&bytes, || {
let inputs = parse_all(&bytes)?;
let dll_name = if shared {
output_basename(output)
} else {
Vec::new()
};
let image = write_executable(&inputs, entry, &dll_name, shared)?;
crate::util::check_truncated_write()?;
write_output(output, &image)
})
}
fn output_basename(output: &Path) -> Vec<u8> {
output
.file_name()
.and_then(|n| n.to_str())
.map_or(&b"xold.dll"[..], str::as_bytes)
.to_vec()
}
fn parse_all<'d>(bytes: &'d [&'d [u8]]) -> Result<Vec<CoffFile<'d>>> {
use rayon::prelude::*;
bytes.par_iter().map(|b| CoffFile::parse(b)).collect()
}
fn write_executable(
inputs: &[CoffFile<'_>],
entry: &[u8],
dll_name: &[u8],
shared: bool,
) -> Result<Vec<u8>> {
let target = derive_target(inputs)?;
let (mut imports, import_size) = plan_imports(inputs, shared)?;
let (mut exports, export_size) = plan_exports(inputs, dll_name, shared)?;
let entry_stub_size = if shared { 0 } else { ENTRY_STUB_SIZE };
let image_base = if shared {
IMAGE_BASE_DLL_X86_64
} else {
IMAGE_BASE_X86_64
};
let needs_tls = tls::has_tls(inputs);
let tls_meta_size = if needs_tls { TLS_DIR_SIZE } else { 0 };
let commons = CommonsPlan::new(inputs);
let comdats = ComdatPlan::new(inputs)?;
let (layout, reloc) = build_layout(
inputs,
entry_stub_size,
import_size,
export_size,
tls_meta_size,
commons.size(),
&comdats,
image_base,
shared,
target,
)?;
let (tls, (sym_addr, sym_sec_rva)) = finalize_link(
inputs,
&layout,
&mut imports,
&mut exports,
&commons,
needs_tls,
)?;
let total = raw_image_size(&layout);
let mut image = vec![0u8; usize::try_from(total).unwrap_or(usize::MAX)];
write_headers(
&mut image,
&layout,
target,
&imports,
&exports,
&reloc,
tls.as_ref(),
);
sections::write(
&mut image,
inputs,
target,
&layout,
layout.image_base,
&sym_addr,
&sym_sec_rva,
)?;
write_imports(&mut image, &layout, &imports)?;
if export_size != 0 {
write_section_bytes(&mut image, &layout, b".edata", exports.bytes())?;
}
write_section_bytes(&mut image, &layout, b".reloc", reloc.bytes())?;
if let Some(ref plan) = tls {
write_section_bytes(&mut image, &layout, b".tlsdir", plan.bytes())?;
}
if !shared {
write_entry_stub(
&mut image, &layout, inputs, &sym_addr, entry, &imports,
)?;
}
Ok(image)
}
fn plan_imports(
inputs: &[CoffFile<'_>],
shared: bool,
) -> Result<(ImportPlan, u32)> {
let entries = detect_imports(inputs, shared)?;
let imports = ImportPlan::new(&entries);
let size = if imports.is_empty() {
0
} else {
imports.size()
};
Ok((imports, size))
}
fn plan_exports(
inputs: &[CoffFile<'_>],
dll_name: &[u8],
shared: bool,
) -> Result<(ExportPlan, u32)> {
let entries = if shared {
collect_directives(inputs)?
} else {
Vec::new()
};
let exports = ExportPlan::new(&entries, dll_name);
let size = if entries.is_empty() {
0
} else {
exports.size()
};
Ok((exports, size))
}
fn finalize_link<'data>(
inputs: &[CoffFile<'data>],
layout: &PeLayout,
imports: &mut ImportPlan,
exports: &mut ExportPlan,
commons: &CommonsPlan<'data>,
needs_tls: bool,
) -> Result<(Option<TlsPlan>, SymbolAddrs)> {
let idata_rva = layout::section_rva(layout, b".idata").map(|(rva, _)| rva);
if let Some(base) = idata_rva {
imports.finalize(base);
}
let tls = finalize_tls(inputs, layout, needs_tls)?;
let (sym_addr, sym_sec_rva) =
resolve_symbol_addrs(inputs, layout, imports, tls.as_ref(), commons)?;
let edata_rva = layout::section_rva(layout, b".edata").map(|(rva, _)| rva);
if let Some(base) = edata_rva {
exports
.finalize(base, |name| export_rva(inputs, &sym_addr, name, layout));
verify_exports(exports, &sym_addr, inputs, layout)?;
}
Ok((tls, (sym_addr, sym_sec_rva)))
}
fn raw_image_size(layout: &PeLayout) -> u64 {
layout
.sections
.iter()
.map(|s| {
u64::from(s.pointer_to_raw_data) + u64::from(s.size_of_raw_data)
})
.max()
.unwrap_or_else(|| u64::from(layout.size_of_headers))
}
fn finalize_tls(
inputs: &[CoffFile<'_>],
layout: &PeLayout,
needs_tls: bool,
) -> Result<Option<TlsPlan>> {
if !needs_tls {
return Ok(None);
}
let (template_rva, template_size) = layout::section_rva(layout, b".tls")
.ok_or(Error::Format("TLS inputs present but no .tls section"))?;
let meta_rva = layout::section_rva(layout, b".tlsdir")
.map(|(rva, _)| rva)
.ok_or(Error::Format(".tlsdir section missing for TLS directory"))?;
let mut plan = TlsPlan::new(inputs, template_size, 0);
plan.finalize(template_rva, meta_rva, layout.image_base);
Ok(Some(plan))
}
#[allow(clippy::too_many_arguments)]
fn build_layout(
inputs: &[CoffFile<'_>],
entry_stub_size: u32,
import_size: u32,
export_size: u32,
tls_meta_size: u32,
commons_size: u32,
comdats: &ComdatPlan,
image_base: u64,
shared: bool,
target: CoffTarget,
) -> Result<(PeLayout, RelocPlan)> {
let prov = layout::build(
inputs,
entry_stub_size,
import_size,
export_size,
0,
tls_meta_size,
commons_size,
comdats,
image_base,
shared,
)?;
if !shared {
return Ok((prov, RelocPlan::new(&[])));
}
let mut sites = collect_reloc_sites(inputs, &prov, target);
if tls_meta_size != 0
&& let Some((meta_rva, _)) = layout::section_rva(&prov, b".tlsdir")
{
sites.extend_from_slice(&tls::directory_fixup_rvas(meta_rva));
}
let reloc = RelocPlan::new(&sites);
let layout = layout::build(
inputs,
entry_stub_size,
import_size,
export_size,
reloc.size(),
tls_meta_size,
commons_size,
comdats,
image_base,
shared,
)?;
Ok((layout, reloc))
}
fn write_section_bytes(
image: &mut [u8],
layout: &PeLayout,
name: &[u8],
bytes: &[u8],
) -> Result<()> {
if bytes.is_empty() {
return Ok(());
}
let section = layout
.sections
.iter()
.find(|s| trim_nul(&s.name) == name)
.ok_or(Error::Format("synthetic section missing"))?;
let slot = section_slot(
image,
section,
bytes.len(),
"synthetic section copy",
"synthetic section slot",
)?;
slot.copy_from_slice(bytes);
Ok(())
}
fn section_slot<'a>(
image: &'a mut [u8],
section: &OutSection,
len: usize,
copy: &'static str,
slot: &'static str,
) -> Result<&'a mut [u8]> {
let off = usize::try_from(section.pointer_to_raw_data).unwrap_or(0);
let end = off.checked_add(len).ok_or(Error::OutOfRange(copy))?;
image.get_mut(off..end).ok_or(Error::OutOfRange(slot))
}
fn export_rva(
inputs: &[CoffFile<'_>],
sym_addr: &[Vec<u64>],
name: &[u8],
layout: &PeLayout,
) -> Option<u32> {
let va = global_symbol_addr(inputs, sym_addr, name)?;
va.checked_sub(layout.image_base)
.and_then(|r| u32::try_from(r).ok())
}
fn verify_exports(
exports: &ExportPlan,
sym_addr: &[Vec<u64>],
inputs: &[CoffFile<'_>],
layout: &PeLayout,
) -> Result<()> {
for (name, internal) in exports.resolved_pairs() {
if export_rva(inputs, sym_addr, internal, layout).is_some() {
continue;
}
if internal == name {
return Err(Error::UndefinedReference(format!(
"export `{}` is not defined in any input",
String::from_utf8_lossy(name)
)));
}
return Err(Error::UndefinedReference(format!(
"export `{}` names `{}`, which is not defined in any input",
String::from_utf8_lossy(name),
String::from_utf8_lossy(internal)
)));
}
Ok(())
}
fn collect_reloc_sites(
inputs: &[CoffFile<'_>],
layout: &PeLayout,
target: CoffTarget,
) -> Vec<u32> {
use crate::reloc::coff_x86_64::IMAGE_REL_AMD64_ADDR64;
if target != CoffTarget::X86_64 {
return Vec::new();
}
let mut sites = Vec::new();
for (file, section_ordinal, section_rva, member_off) in
build_section_map(layout)
{
let Some(input) = inputs.get(file) else {
continue;
};
let Some(section) = input.section_at(section_ordinal) else {
continue;
};
for reloc in §ion.relocations {
if u32::from(reloc.typ) == IMAGE_REL_AMD64_ADDR64 {
let rva = section_rva
.wrapping_add(u32::try_from(member_off).unwrap_or(0))
.wrapping_add(reloc.virtual_address);
sites.push(rva);
}
}
}
sites
}
const EXIT_PROCESS_DLL: &[u8] = b"kernel32.dll";
const EXIT_PROCESS_FUNC: &[u8] = b"ExitProcess";
fn detect_imports(
inputs: &[CoffFile<'_>],
shared: bool,
) -> Result<Vec<ImportEntry>> {
let mut entries = if shared {
Vec::new()
} else {
vec![ImportEntry {
dll: EXIT_PROCESS_DLL.to_vec(),
func: EXIT_PROCESS_FUNC.to_vec(),
}]
};
for input in inputs {
for sym in input.symbols().iter() {
if sym.storage_class != IMAGE_SYM_CLASS_EXTERNAL
|| sym.section_number != IMAGE_SYM_UNDEFINED
|| sym.value != 0
{
continue;
}
let Some(func) = sym.name.strip_prefix(IMP_PREFIX) else {
continue;
};
if func.is_empty() || entries.iter().any(|e| e.func == func) {
continue;
}
let dll = dllmap::resolve(func)
.ok_or_else(|| Error::UndefinedReference(import_error(func)))?;
entries.push(ImportEntry {
dll: dll.to_vec(),
func: func.to_vec(),
});
}
}
Ok(entries)
}
fn import_error(func: &[u8]) -> String {
let name = String::from_utf8_lossy(func);
format!(
"__imp_{name}: no known source DLL \
(not in the well-known table; supply an import library)"
)
}
fn derive_target(inputs: &[CoffFile<'_>]) -> Result<CoffTarget> {
let mut target: Option<CoffTarget> = None;
for input in inputs {
let current = CoffTarget::from_machine(input.machine())?;
match target {
None => target = Some(current),
Some(existing) if existing == current => {}
Some(_) => {
return Err(Error::Format("inputs disagree on machine type"));
}
}
}
let target =
target.ok_or(Error::Format("no COFF inputs to derive a target"))?;
if !target.is_writable() {
return Err(Error::Format(
"only x86-64 COFF objects can be linked: this linker has no PE32 \
writer",
));
}
Ok(target)
}
type SymbolAddrs = (Vec<Vec<u64>>, Vec<Vec<u32>>);
fn resolve_symbol_addrs<'data>(
inputs: &[CoffFile<'data>],
layout: &PeLayout,
imports: &ImportPlan,
tls: Option<&TlsPlan>,
commons: &CommonsPlan<'data>,
) -> Result<SymbolAddrs> {
let sec_map = build_section_map(layout);
let base = layout.image_base;
let commons_va = commons_base(layout);
let globals = collect_globals(inputs, &sec_map, commons, commons_va, base)?;
let tls_index_va = tls.map_or(0, |p| p.index_va(base));
let mut addrs_out = Vec::with_capacity(inputs.len());
let mut rvas_out = Vec::with_capacity(inputs.len());
for (file, input) in inputs.iter().enumerate() {
let syms = input.symbols();
let len = syms
.iter()
.map(|s| s.index)
.max()
.map_or(0, |i| i as usize + 1);
let mut addrs = vec![0u64; len];
let mut rvas = vec![0u32; len];
for sym in syms.iter() {
let pos = sym.index as usize;
if pos >= addrs.len() {
continue;
}
if sym.section_number > 0 {
let (addr, rva) = section_symbol_addr(
&sec_map,
file,
sym.section_number,
sym.value,
base,
)
.unwrap_or_else(|| {
(resolve_undefined(&globals, sym.name, base, imports), 0)
});
addrs[pos] = addr;
rvas[pos] = rva;
} else if sym.section_number == IMAGE_SYM_ABSOLUTE {
addrs[pos] = u64::from(sym.value);
} else if sym.is_common() {
addrs[pos] = commons
.offset_of(sym.name)
.map_or(0, |off| commons_va.wrapping_add(u64::from(off)));
} else if sym.section_number == IMAGE_SYM_UNDEFINED
&& sym.value == 0
{
if sym.name == TLS_INDEX_NAME {
addrs[pos] = tls_index_va;
} else if sym.name == IMAGE_BASE_NAME {
addrs[pos] = base;
} else {
let mut addr =
resolve_undefined(&globals, sym.name, base, imports);
if addr == 0
&& let Some(tag) = sym.weak_tag_index()
{
addr = weak_fallback(
&sec_map, syms, file, tag, base, &globals, imports,
);
}
addrs[pos] = addr;
}
}
}
addrs_out.push(addrs);
rvas_out.push(rvas);
}
Ok((addrs_out, rvas_out))
}
fn collect_globals<'data>(
inputs: &[CoffFile<'data>],
sec_map: &[(usize, u32, u32, u64)],
commons: &CommonsPlan<'data>,
commons_va: u64,
base: u64,
) -> Result<FxHashMap<&'data [u8], (u64, usize)>> {
let mut globals: FxHashMap<&'data [u8], (u64, usize)> =
FxHashMap::default();
for (file, input) in inputs.iter().enumerate() {
for sym in input.symbols().iter() {
if sym.storage_class != IMAGE_SYM_CLASS_EXTERNAL
|| sym.section_number <= 0
{
continue;
}
let Some((addr, _rva)) = section_symbol_addr(
sec_map,
file,
sym.section_number,
sym.value,
base,
) else {
continue;
};
if let Some(&(_, first)) = globals.get(sym.name) {
return Err(duplicate(sym.name, first, file));
}
globals.insert(sym.name, (addr, file));
}
}
for (name, off) in commons.iter() {
globals
.entry(name)
.or_insert_with(|| (commons_va.wrapping_add(u64::from(off)), 0));
}
Ok(globals)
}
fn duplicate(name: &[u8], first: usize, second: usize) -> Error {
Error::duplicate_symbol(
String::from_utf8_lossy(name).into_owned(),
format!("input {first}"),
format!("input {second}"),
)
}
fn commons_base(layout: &PeLayout) -> u64 {
layout::section_rva(layout, b".bss").map_or(0, |(rva, _)| {
layout
.image_base
.wrapping_add(u64::from(rva))
.wrapping_add(u64::from(layout.commons_off))
})
}
fn weak_fallback(
sec_map: &[(usize, u32, u32, u64)],
syms: &CoffSymbolTable<'_>,
file: usize,
mut tag: u32,
base: u64,
globals: &FxHashMap<&[u8], (u64, usize)>,
imports: &ImportPlan,
) -> u64 {
for _ in 0..syms.len() {
let Some(def) = syms.iter().find(|s| s.index == tag) else {
return 0;
};
if def.section_number > 0 {
return section_symbol_addr(
sec_map,
file,
def.section_number,
def.value,
base,
)
.map_or(0, |(addr, _)| addr);
}
if def.is_weak()
&& let Some(next) = def.weak_tag_index()
{
tag = next;
continue;
}
return resolve_undefined(globals, def.name, base, imports);
}
0
}
fn resolve_undefined(
globals: &FxHashMap<&[u8], (u64, usize)>,
name: &[u8],
base: u64,
imports: &ImportPlan,
) -> u64 {
if let Some(&(addr, _)) = globals.get(name) {
return addr;
}
let Some(func) = name.strip_prefix(IMP_PREFIX) else {
return 0;
};
imports
.iat_slot_rva(func)
.map_or(0, |rva| base.wrapping_add(u64::from(rva)))
}
fn build_section_map(layout: &PeLayout) -> Vec<(usize, u32, u32, u64)> {
let mut out = Vec::new();
for section in &layout.sections {
for m in §ion.members {
out.push((m.file, m.section, section.virtual_address, m.offset));
}
}
out.sort_unstable_by_key(|&(file, sec, _, _)| (file, sec));
out
}
fn section_symbol_addr(
sec_map: &[(usize, u32, u32, u64)],
file: usize,
section_number: i32,
value: u32,
base: u64,
) -> Option<(u64, u32)> {
let ord = u32::try_from(section_number).ok()?;
let at = sec_map
.binary_search_by(|(f, s, _, _)| (*f, *s).cmp(&(file, ord)))
.ok()?;
sec_map.get(at).map(|(_, _, rva, off)| {
(base + u64::from(*rva) + off + u64::from(value), *rva)
})
}
fn write_headers(
image: &mut [u8],
layout: &PeLayout,
target: CoffTarget,
imports: &ImportPlan,
exports: &ExportPlan,
reloc: &RelocPlan,
tls: Option<&TlsPlan>,
) {
let reloc_dir = layout::section_rva(layout, b".reloc")
.map(|(rva, _)| reloc.directory(rva));
let resource_dir =
layout::section_rva(layout, b".rsrc").map(|(rva, size)| {
DataDirectory {
virtual_address: U32::new(rva),
size: U32::new(size),
}
});
let tls_dir = tls.map(TlsPlan::directory);
let pe_off = u32::try_from(IMAGE_SIZEOF_DOS_HEADER).unwrap_or(0x40);
write_pod(image, 0, &DosHeader::minimal(pe_off));
let mut off = write_pod(
image,
u64::from(pe_off),
&NtFileHeader {
signature: U32::new(IMAGE_NT_SIGNATURE),
machine: U16::new(machine(target)),
number_of_sections: U16::new(
u16::try_from(layout.sections.len()).unwrap_or(0),
),
time_date_stamp: U32::new(0),
pointer_to_symbol_table: U32::new(0),
number_of_symbols: U32::new(0),
size_of_optional_header: U16::new(
u16::try_from(
IMAGE_SIZEOF_OPTIONAL_HEADER64
+ IMAGE_NUMBEROF_DIRECTORY_ENTRIES * 8,
)
.unwrap_or(240),
),
characteristics: U16::new(file_characteristics(layout.is_dll)),
},
);
off = write_optional_header(image, off, layout);
off = write_data_directory(
image,
off,
imports,
exports,
reloc_dir,
resource_dir,
tls_dir,
);
let _ = write_section_table(image, off, layout);
}
fn file_characteristics(is_dll: bool) -> u16 {
let mode = if is_dll {
IMAGE_FILE_DLL
} else {
IMAGE_FILE_EXECUTABLE_IMAGE
};
mode | IMAGE_FILE_LARGE_ADDRESS_AWARE
| IMAGE_FILE_LINE_NUMS_STRIPPED
| IMAGE_FILE_LOCAL_SYMS_STRIPPED
}
fn machine(target: CoffTarget) -> u16 {
match target {
CoffTarget::X86_64 => IMAGE_FILE_MACHINE_AMD64,
CoffTarget::I386 => IMAGE_FILE_MACHINE_I386,
}
}
fn write_optional_header(image: &mut [u8], off: u64, layout: &PeLayout) -> u64 {
let (size_of_code, size_of_init) = section_sizes(layout);
let opt = OptionalHeader64 {
magic: U16::new(IMAGE_NT_OPTIONAL_HDR64_MAGIC),
major_linker_version: 14,
minor_linker_version: 0,
size_of_code: U32::new(size_of_code),
size_of_initialized_data: U32::new(size_of_init),
size_of_uninitialized_data: U32::new(0),
address_of_entry_point: U32::new(layout.address_of_entry_point),
base_of_code: U32::new(layout.base_of_code),
image_base: U64::new(layout.image_base),
section_alignment: U32::new(SECTION_ALIGNMENT),
file_alignment: U32::new(FILE_ALIGNMENT),
major_operating_system_version: U16::new(6),
minor_operating_system_version: U16::new(0),
major_image_version: U16::new(0),
minor_image_version: U16::new(0),
major_subsystem_version: U16::new(6),
minor_subsystem_version: U16::new(0),
win32_version_value: U32::new(0),
size_of_image: U32::new(layout.size_of_image),
size_of_headers: U32::new(layout.size_of_headers),
check_sum: U32::new(0),
subsystem: U16::new(IMAGE_SUBSYSTEM_WINDOWS_CUI),
dll_characteristics: U16::new(dll_characteristics(layout.is_dll)),
size_of_stack_reserve: U64::new(0x10_0000),
size_of_stack_commit: U64::new(0x1000),
size_of_heap_reserve: U64::new(0x10_0000),
size_of_heap_commit: U64::new(0x1000),
loader_flags: U32::new(0),
number_of_rva_and_sizes: U32::new(
u32::try_from(IMAGE_NUMBEROF_DIRECTORY_ENTRIES).unwrap_or(16),
),
};
write_pod(image, off, &opt)
}
fn dll_characteristics(is_dll: bool) -> u16 {
if is_dll {
IMAGE_DLLCHARACTERISTICS_NX_COMPAT
| IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
| IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA
} else {
IMAGE_DLLCHARACTERISTICS_NX_COMPAT
}
}
fn write_data_directory(
image: &mut [u8],
off: u64,
imports: &ImportPlan,
exports: &ExportPlan,
reloc_dir: Option<DataDirectory>,
resource_dir: Option<DataDirectory>,
tls_dir: Option<DataDirectory>,
) -> u64 {
let mut dirs = [DataDirectory::default(); IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
let [import_dir, iat_dir] = imports.directories();
dirs[IMAGE_DIRECTORY_ENTRY_IMPORT] = import_dir;
dirs[IMAGE_DIRECTORY_ENTRY_IAT] = iat_dir;
dirs[IMAGE_DIRECTORY_ENTRY_EXPORT] = exports.directory();
if let Some(reloc) = reloc_dir {
dirs[IMAGE_DIRECTORY_ENTRY_BASERELOC] = reloc;
}
if let Some(resource) = resource_dir {
dirs[IMAGE_DIRECTORY_ENTRY_RESOURCE] = resource;
}
if let Some(tls) = tls_dir {
dirs[IMAGE_DIRECTORY_ENTRY_TLS] = tls;
}
let mut cursor = off;
for d in &dirs {
cursor = write_pod(image, cursor, d);
}
cursor
}
fn write_section_table(image: &mut [u8], off: u64, layout: &PeLayout) -> u64 {
let mut cursor = off;
for s in &layout.sections {
let hdr = SectionHeader {
name: s.name,
virtual_size: U32::new(s.virtual_size),
virtual_address: U32::new(s.virtual_address),
size_of_raw_data: U32::new(s.size_of_raw_data),
pointer_to_raw_data: U32::new(s.pointer_to_raw_data),
pointer_to_relocations: U32::new(0),
pointer_to_linenumbers: U32::new(0),
number_of_relocations: U16::new(0),
number_of_linenumbers: U16::new(0),
characteristics: U32::new(s.characteristics),
};
cursor = write_pod(image, cursor, &hdr);
}
cursor
}
fn section_sizes(layout: &PeLayout) -> (u32, u32) {
let mut code = 0u32;
let mut init = 0u32;
for s in &layout.sections {
let raw = s.size_of_raw_data;
if s.name == *b".text\0\0\0" {
code = code.wrapping_add(raw);
} else if !s.zerofill {
init = init.wrapping_add(raw);
}
}
(code, init)
}
fn write_imports(
image: &mut [u8],
layout: &PeLayout,
imports: &ImportPlan,
) -> Result<()> {
if imports.is_empty() {
return Ok(());
}
let section = layout
.sections
.iter()
.find(|s| s.name == *b".idata\0\0")
.ok_or(Error::Format(".idata section missing"))?;
let slot = section_slot(
image,
section,
imports.bytes().len(),
".idata copy",
".idata image slot",
)?;
slot.copy_from_slice(imports.bytes());
Ok(())
}
fn write_entry_stub(
image: &mut [u8],
layout: &PeLayout,
inputs: &[CoffFile<'_>],
sym_addr: &[Vec<u64>],
entry: &[u8],
imports: &ImportPlan,
) -> Result<()> {
let text = layout
.sections
.iter()
.find(|s| s.name == *b".text\0\0\0")
.ok_or(Error::Format(".text section missing"))?;
let entry_va = global_symbol_addr(inputs, sym_addr, entry)
.ok_or_else(|| Error::UndefinedReference(show(entry)))?;
let exit_rva = imports
.iat_slot_rva(EXIT_PROCESS_FUNC)
.ok_or(Error::Format("ExitProcess import missing from the plan"))?;
let stub_base_va = layout.image_base + u64::from(text.virtual_address);
let exit_iat_va = layout.image_base + u64::from(exit_rva);
let mut stub = [
0x48, 0x83, 0xec, 0x28, 0xe8, 0, 0, 0, 0, 0x89, 0xc1, 0xff, 0x15, 0, 0,
0, 0, 0x0f, 0x0b,
];
let call_entry = i32::try_from(entry_va.wrapping_sub(stub_base_va + 9))
.map_err(|_| Error::OutOfRange("entry call displacement"))?;
stub[5..9].copy_from_slice(&call_entry.to_le_bytes());
let call_exit = i32::try_from(exit_iat_va.wrapping_sub(stub_base_va + 17))
.map_err(|_| Error::OutOfRange("ExitProcess call displacement"))?;
stub[13..17].copy_from_slice(&call_exit.to_le_bytes());
let slot = section_slot(
image,
text,
stub.len(),
"entry stub copy",
"entry stub slot",
)?;
slot.copy_from_slice(&stub);
Ok(())
}