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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// #![allow(incomplete_features)]
// #![feature(unsized_locals)]
mod structs;
use crate::structs::{ElfHeader, ElfSectionHeader, ElfSectionType, ElfSymbol};
use std::io::Read;
#[repr(C)]
#[derive(Debug)]
struct Elf {
header: &'static ElfHeader,
sections: &'static [ElfSectionHeader],
// symbols: &'static Vec<ElfSymbol>,
strtab: *const u8,
}
impl Elf {
pub fn new(bytes: &[u8]) -> Elf {
let header = unsafe { &*(bytes.as_ptr() as *const ElfHeader) };
assert_eq!(&header.ident.magic, b"\x7fELF");
let sections = unsafe {
std::slice::from_raw_parts(
bytes.as_ptr().add(header.shoff as usize) as *const ElfSectionHeader,
header.shnum as usize,
)
};
let strtab = unsafe {
bytes
.as_ptr()
.add((§ions[header.shstrndx as usize]).offset as usize)
};
let symtab = sections
.iter()
.find(|&&sec| sec.r#type == ElfSectionType::SymTab)
.expect("No symbol table!");
let symstrtab = unsafe { bytes.as_ptr().add(symtab.link as usize) };
let symbols: Vec<&str> = unsafe {
std::slice::from_raw_parts(
bytes.as_ptr().add(symtab.offset as usize) as *const ElfSymbol,
(symtab.size / symtab.entsize) as usize,
)
}
.iter()
.filter(|sym| sym.shndx != 0)
.map(|sym| unsafe {
std::ffi::CStr::from_ptr(symstrtab.add(sym.name as usize) as *const i8)
.to_str()
.unwrap_or("")
})
.filter(|name| name.len() > 1)
.collect();
dbg!(symbols);
// for sym in symbols {
// dbg!(sym);
// let name = unsafe {
// std::ffi::CStr::from_ptr(symstrtab.add(sym.name as usize) as *const i8)
// .to_str()
// .unwrap_or("")
// };
// dbg!(name);
// }
Elf {
header,
sections,
strtab,
}
}
}
// readelf behavior here
impl std::fmt::Display for Elf {
fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("ELF Header:\n")?;
formatter.write_fmt(format_args!("{}\n", self.header))?;
formatter.write_str("Section Headers:\n")?;
formatter
.write_str(" [Nr] Name Type Address Offset\n")?;
formatter
.write_str(" Size EntSize Flags Link Info Align\n")?;
for (i, section) in self.sections.iter().enumerate() {
let name = unsafe {
std::ffi::CStr::from_ptr(self.strtab.add(section.name as usize) as *const i8)
.to_str()
.expect("Bad section name")
};
formatter.write_fmt(format_args!(" [{: >2}] {: <17.17} {}\n", i, name, section))?;
}
formatter.write_str("Key to Flags:\n")?;
formatter.write_str(
" W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n",
)?;
formatter.write_str(
" L (link order), O (extra OS processing required), G (group), T (TLS),\n",
)?;
formatter.write_str(" C (compressed), x (unknown), o (OS specific), E (exclude),\n")?;
formatter.write_str(" D (mbind), l (large), p (processor specific)\n")?;
Ok(())
}
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let buffer = {
let mut f = std::fs::File::open(&args[1]).expect("no file found");
let metadata = std::fs::metadata(&args[1]).expect("unable to read metadata");
let mut buffer = vec![0; metadata.len() as usize];
f.read(&mut buffer).expect("buffer overflow");
buffer
};
let elf = Elf::new(&buffer[..]);
// println!("{}", elf);
// dbg!(symtab);
}
|
