objpoke 0.3.1

Minimal in-place objcopy replacement
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::collections::HashMap;

use goblin::{
    container::{Container, Ctx},
    elf::{
        reloc::{reloc32, reloc64},
        section_header::{SHT_REL, SHT_RELA},
        Elf, Reloc, SectionHeader,
    },
};
use scroll::Pread;

use crate::elf::symtab::ElfSymbolTableUpdate;

pub struct ElfRelocationUpdate {
    pub header: SectionHeader,
    pub rels: Vec<Reloc>,
}

pub fn rel_size(ctx: Ctx, section: &SectionHeader) -> usize {
    match ctx.container {
        Container::Little => {
            if section.sh_type == SHT_RELA {
                reloc32::SIZEOF_RELA
            } else {
                reloc32::SIZEOF_REL
            }
        },
        Container::Big => {
            if section.sh_type == SHT_RELA {
                reloc64::SIZEOF_RELA
            } else {
                reloc64::SIZEOF_REL
            }
        },
    }
}

fn process_elf_rel_section(
    ctx: Ctx,
    rel_data: &[u8],
    count: usize,
    rel_size: usize,
    header: &SectionHeader,
    symtab: &ElfSymbolTableUpdate,
) -> ElfRelocationUpdate {
    let mut rels = Vec::<Reloc>::new();

    let is_rela = header.sh_type == SHT_RELA;
    for idx in 0..count {
        rels.push(rel_data.pread_with(idx * rel_size, (is_rela, ctx)).unwrap());
    }

    for rel in rels.iter_mut() {
        if let Some(new_idx) = symtab.sym_idx_map.get(&rel.r_sym) {
            rel.r_sym = *new_idx;
        }
    }

    ElfRelocationUpdate { header: header.clone(), rels }
}

pub fn process_elf_relocations(
    elf: &Elf,
    ctx: Ctx,
    data: &[u8],
    symtab_updates: &HashMap<usize, ElfSymbolTableUpdate>,
) -> HashMap<usize, ElfRelocationUpdate> {
    let mut relocation_updates = HashMap::<usize, ElfRelocationUpdate>::new();
    for (idx, section) in elf.section_headers.iter().enumerate() {
        if section.sh_type != SHT_REL && section.sh_type != SHT_RELA {
            continue;
        }

        // If the sh_link matches one of our re-ordered symtabs, process it
        let symtab_update = match symtab_updates.get(&(section.sh_link as usize)) {
            Some(update) => update,
            None => continue,
        };
        if symtab_update.sym_idx_map.is_empty() {
            continue;
        }

        let rel_size = rel_size(ctx, section);
        let count = section.sh_size as usize / rel_size;

        let range = section.file_range().expect("Relocation without without file range");
        let rel_data = &data[range.start..range.end];
        let update = process_elf_rel_section(ctx, rel_data, count, rel_size, section, symtab_update);
        relocation_updates.insert(idx, update);
    }
    relocation_updates
}