Line data Source code
1 : use std::mem::size_of;
2 : use std::path::Path;
3 : use std::pin::Pin;
4 :
5 : use num_traits::{cast, Num};
6 :
7 : use lief_ffi as ffi;
8 :
9 : use super::builder::Config;
10 : use super::dynamic::{self, DynamicEntries, DynamicEntry, Library};
11 : use super::hash::{Gnu, Sysv};
12 : use super::header::Header;
13 : use super::note::ItNotes;
14 : use super::relocation::{
15 : DynamicRelocations, ObjectRelocations, PltGotRelocations, Relocation, Relocations,
16 : };
17 : use super::section::{Section, Sections};
18 : use super::segment::Segments;
19 : use super::symbol::{DynamicSymbols, ExportedSymbols, ImportedSymbols, SymtabSymbols};
20 : use super::symbol_versioning::{SymbolVersion, SymbolVersionDefinition, SymbolVersionRequirement};
21 : use super::{Segment, Symbol};
22 : use crate::Error;
23 :
24 : use crate::common::{into_optional, FromFFI};
25 : use crate::generic;
26 : use crate::{declare_iterator, to_conv_result, to_result, to_slice};
27 :
28 0 : #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
29 : pub enum ElfClass {
30 : Elf32,
31 : Elf64,
32 : Unknown,
33 : }
34 :
35 : impl ElfClass {
36 : const ELF_CLASS32: u32 = 1;
37 : const ELF_CLASS64: u32 = 2;
38 :
39 0 : pub fn from_value(value: u32) -> Self {
40 0 : match value {
41 0 : Self::ELF_CLASS32 => ElfClass::Elf32,
42 0 : Self::ELF_CLASS64 => ElfClass::Elf64,
43 0 : _ => ElfClass::Unknown,
44 : }
45 0 : }
46 : }
47 :
48 : /// This is the main interface to read and write ELF binary attributes.
49 : ///
50 : /// Note that this structure implements the [`generic::Binary`] trait from which other generic
51 : /// functions are exposed
52 : pub struct Binary {
53 : ptr: cxx::UniquePtr<ffi::ELF_Binary>,
54 : }
55 :
56 : impl std::fmt::Debug for Binary {
57 80 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
58 80 : f.debug_struct("Binary")
59 80 : .field("header", &self.header())
60 80 : .finish()
61 80 : }
62 : }
63 :
64 : impl FromFFI<ffi::ELF_Binary> for Binary {
65 180 : fn from_ffi(ptr: cxx::UniquePtr<ffi::ELF_Binary>) -> Self {
66 180 : Self { ptr }
67 180 : }
68 : }
69 :
70 : impl Binary {
71 : /// Create a [`Binary`] from the given file path
72 100 : pub fn parse(path: &str) -> Option<Self> {
73 100 : let bin = ffi::ELF_Binary::parse(path);
74 100 : if bin.is_null() {
75 0 : return None;
76 100 : }
77 100 : Some(Binary::from_ffi(bin))
78 100 : }
79 :
80 : /// Return the main ELF header
81 80 : pub fn header(&self) -> Header {
82 80 : Header::from_ffi(self.ptr.header())
83 80 : }
84 :
85 : /// Return the size taken by the binary when loaded (virtual size)
86 80 : pub fn virtual_size(&self) -> u64 {
87 80 : self.ptr.virtual_size()
88 80 : }
89 :
90 : /// Return the path to the ELF interpreter that is used to process the ELF information
91 : /// once loaded by the kernel
92 80 : pub fn interpreter(&self) -> String {
93 80 : self.ptr.interpreter().to_string()
94 80 : }
95 :
96 : /// Return sysv-hash information (if present)
97 80 : pub fn sysv_hash(&self) -> Option<Sysv> {
98 80 : into_optional(self.ptr.sysv_hash())
99 80 : }
100 :
101 : /// Return GNU Hash info (if present)
102 80 : pub fn gnu_hash(&self) -> Option<Gnu> {
103 80 : into_optional(self.ptr.gnu_hash())
104 80 : }
105 :
106 : /// Return an iterator over the [`crate::elf::Section`] of the binary
107 80 : pub fn sections(&self) -> Sections {
108 80 : Sections::new(self.ptr.sections())
109 80 : }
110 :
111 : /// Return an iterator over the [`crate::elf::Segment`] of the binary
112 80 : pub fn segments(&self) -> Segments {
113 80 : Segments::new(self.ptr.segments())
114 80 : }
115 :
116 : /// Return an iterator over the [`crate::elf::DynamicEntries`] of the binary
117 80 : pub fn dynamic_entries(&self) -> DynamicEntries {
118 80 : DynamicEntries::new(self.ptr.dynamic_entries())
119 80 : }
120 :
121 : /// Remove **all** dynamic entries with the given tag
122 0 : pub fn remove_dynamic_entries_by_tag(&mut self, tag: dynamic::Tag) {
123 0 : self.ptr.as_mut().unwrap().remove_dynamic_entries_by_tag(tag.into())
124 0 : }
125 :
126 : /// Add the given dynamic entry and return the new entry
127 0 : pub fn add_dynamic_entry(&mut self, entry: &dynamic::Entries) -> dynamic::Entries {
128 0 : dynamic::Entries::from_ffi(self.ptr.as_mut().unwrap().add_dynamic_entry(entry.as_base()))
129 0 : }
130 :
131 : /// Return an iterator over the dynamic [`crate::elf::Symbol`] of the binary
132 80 : pub fn dynamic_symbols(&self) -> DynamicSymbols {
133 80 : DynamicSymbols::new(self.ptr.dynamic_symbols())
134 80 : }
135 :
136 : /// Return an iterator over the **exported** [`crate::elf::Symbol`] of the binary
137 80 : pub fn exported_symbols(&self) -> ExportedSymbols {
138 80 : ExportedSymbols::new(self.ptr.exported_symbols())
139 80 : }
140 :
141 : /// Return an iterator over the **imported** [`crate::elf::Symbol`] of the binary
142 80 : pub fn imported_symbols(&self) -> ImportedSymbols {
143 80 : ImportedSymbols::new(self.ptr.imported_symbols())
144 80 : }
145 :
146 : /// Return an iterator over the symtab-debug [`crate::elf::Symbol`] of the binary
147 80 : pub fn symtab_symbols(&self) -> SymtabSymbols {
148 80 : SymtabSymbols::new(self.ptr.symtab_symbols())
149 80 : }
150 :
151 : /// Return an iterator over the [`crate::elf::SymbolVersion`] of the binary
152 160 : pub fn symbols_version(&self) -> SymbolsVersion {
153 160 : SymbolsVersion::new(self.ptr.symbols_version())
154 160 : }
155 :
156 : /// Return an iterator over the [`crate::elf::SymbolVersionRequirement`] of the binary
157 80 : pub fn symbols_version_requirement(&self) -> SymbolsVersionRequirement {
158 80 : SymbolsVersionRequirement::new(self.ptr.symbols_version_requirement())
159 80 : }
160 :
161 : /// Return an iterator over the [`crate::elf::SymbolVersionDefinition`] of the binary
162 80 : pub fn symbols_version_definition(&self) -> SymbolsVersionDefinition {
163 80 : SymbolsVersionDefinition::new(self.ptr.symbols_version_definition())
164 80 : }
165 :
166 : /// Return an iterator over the [`crate::elf::Notes`] of the binary
167 80 : pub fn notes(&self) -> ItNotes {
168 80 : ItNotes::new(self.ptr.notes())
169 80 : }
170 :
171 : /// Return an iterator over the `.plt.got` [`crate::elf::Relocation`] of the binary
172 80 : pub fn pltgot_relocations(&self) -> PltGotRelocations {
173 80 : PltGotRelocations::new(self.ptr.pltgot_relocations())
174 80 : }
175 :
176 : /// Return an iterator over the regular [`crate::elf::Relocation`] of the binary
177 80 : pub fn dynamic_relocations(&self) -> DynamicRelocations {
178 80 : DynamicRelocations::new(self.ptr.dynamic_relocations())
179 80 : }
180 :
181 : /// Return an iterator over the object-file (`.o`) [`crate::elf::Relocation`]
182 80 : pub fn object_relocations(&self) -> ObjectRelocations {
183 80 : ObjectRelocations::new(self.ptr.object_relocations())
184 80 : }
185 :
186 : /// Return an iterator over **all** [`crate::elf::Relocation`] of the binary
187 80 : pub fn relocations(&self) -> Relocations {
188 80 : Relocations::new(self.ptr.relocations())
189 80 : }
190 :
191 : /// Try to find the ELF section with the given name
192 80 : pub fn section_by_name(&self, name: &str) -> Option<Section> {
193 80 : into_optional(self.ptr.section_by_name(name))
194 80 : }
195 :
196 : /// Try to find the ELF relocation that takes place at the given address
197 20 : pub fn relocation_by_addr(&self, address: u64) -> Option<Relocation> {
198 20 : into_optional(self.ptr.relocation_by_addr(address))
199 20 : }
200 :
201 : /// Try to find the `.plt.got` relocation for the given symbol name
202 20 : pub fn relocation_for_symbol(&self, sym_name: &str) -> Option<Relocation> {
203 20 : into_optional(self.ptr.relocation_for_symbol(sym_name))
204 20 : }
205 :
206 : /// Try to find the symbol with the given name in the dynamic `.dynsym` table
207 10 : pub fn dynamic_symbol_by_name(&self, sym_name: &str) -> Option<Symbol> {
208 10 : into_optional(self.ptr.get_dynamic_symbol(sym_name))
209 10 : }
210 :
211 : /// Try to find the symbol with the given name in the debug `.symtab` table
212 10 : pub fn symtab_symbol_by_name(&self, sym_name: &str) -> Option<Symbol> {
213 10 : into_optional(self.ptr.get_symtab_symbol(sym_name))
214 10 : }
215 :
216 : /// Try to find the library (`DT_NEEDED`) with the given name
217 20 : pub fn get_library(&self, name: &str) -> Option<dynamic::Library> {
218 20 : into_optional(self.ptr.get_library(name))
219 20 : }
220 :
221 : /// Try to find the section that encompasses the given offset. `skip_nobits` can be used
222 : /// to include (or not) the `SHT_NOTBIT` sections
223 20 : pub fn section_from_offset(&self, offset: u64, skip_nobits: bool) -> Option<Section> {
224 20 : into_optional(self.ptr.section_from_offset(offset, skip_nobits))
225 20 : }
226 :
227 : /// Try to find the section that encompasses the given virtual address. `skip_nobits` can be used
228 : /// to include (or not) the `SHT_NOTBIT` sections
229 20 : pub fn section_from_virtual_address(&self, address: u64, skip_nobits: bool) -> Option<Section> {
230 20 : into_optional(self.ptr.section_from_virtual_address(address, skip_nobits))
231 20 : }
232 :
233 : /// Try to find the segment that encompasses the given virtual address
234 20 : pub fn segment_from_virtual_address(&self, address: u64) -> Option<Segment> {
235 20 : into_optional(self.ptr.segment_from_virtual_address(address))
236 20 : }
237 :
238 : /// Try to find the segment that encompasses the given offset
239 20 : pub fn segment_from_offset(&self, offset: u64) -> Option<Segment> {
240 20 : into_optional(self.ptr.segment_from_offset(offset))
241 20 : }
242 :
243 : /// Get a slice of the content at the given address.
244 10 : pub fn content_from_virtual_address(&self, address: u64, size: u64) -> &[u8] {
245 10 : to_slice!(self.ptr.get_content_from_virtual_address(address, size));
246 10 : }
247 :
248 : /// Convert the given virtual address into an offset
249 20 : pub fn virtual_address_to_offset(&self, address: u64) -> Result<u64, Error> {
250 20 : to_result!(ffi::ELF_Binary::virtual_address_to_offset, &self, address);
251 20 : }
252 :
253 : /// Return the array defined by the given tag (e.g.
254 : /// [`dynamic::Tag::INIT_ARRAY`]) with relocations applied (if any)
255 240 : pub fn get_relocated_dynamic_array(&self, tag: dynamic::Tag) -> Vec<u64> {
256 240 : Vec::from(
257 240 : self.ptr
258 240 : .get_relocated_dynamic_array(u64::from(tag))
259 240 : .as_slice(),
260 240 : )
261 240 : }
262 :
263 : /// True if the current binary is targeting Android
264 0 : pub fn is_targeting_android(&self) -> bool {
265 0 : self.ptr.is_targeting_android()
266 0 : }
267 :
268 : /// Get the integer value at the given virtual address
269 4 : pub fn get_int_from_virtual_address<T>(&self, addr: u64) -> Result<T, Error>
270 4 : where
271 4 : T: Num + cast::FromPrimitive + cast::ToPrimitive,
272 4 : {
273 4 : // Can't be in the generic trait because of:
274 4 : // > for a trait to be "object safe" it needs to allow building a vtable to allow the call
275 4 : // > to be resolvable dynamically; for more information visit
276 4 : // > https://doc.rust-lang.org/reference/items/traits.html#object-safety
277 4 : if size_of::<T>() == size_of::<u8>() {
278 1 : to_conv_result!(
279 1 : ffi::AbstractBinary::get_u8,
280 1 : self.ptr.as_ref().unwrap().as_ref(),
281 1 : |value| {
282 1 : T::from_u8(value).expect(format!("Can't cast value: {}", value).as_str())
283 1 : },
284 1 : addr
285 : );
286 3 : }
287 3 :
288 3 : if size_of::<T>() == size_of::<u16>() {
289 1 : to_conv_result!(
290 1 : ffi::AbstractBinary::get_u16,
291 1 : self.ptr.as_ref().unwrap().as_ref(),
292 1 : |value| {
293 1 : T::from_u16(value).expect(format!("Can't cast value: {}", value).as_str())
294 1 : },
295 1 : addr
296 : );
297 2 : }
298 2 :
299 2 : if size_of::<T>() == size_of::<u32>() {
300 1 : to_conv_result!(
301 1 : ffi::AbstractBinary::get_u32,
302 1 : self.ptr.as_ref().unwrap().as_ref(),
303 1 : |value| {
304 1 : T::from_u32(value).expect(format!("Can't cast value: {}", value).as_str())
305 1 : },
306 1 : addr
307 : );
308 1 : }
309 1 :
310 1 : if size_of::<T>() == size_of::<u64>() {
311 1 : to_conv_result!(
312 1 : ffi::AbstractBinary::get_u64,
313 1 : self.ptr.as_ref().unwrap().as_ref(),
314 1 : |value| {
315 1 : T::from_u64(value).expect(format!("Can't cast value: {}", value).as_str())
316 1 : },
317 1 : addr
318 : );
319 0 : }
320 0 :
321 0 : Err(Error::NotSupported)
322 4 : }
323 :
324 : /// Write back the current ELF binary into the file specified in parameter
325 10 : pub fn write(&mut self, output: &Path) {
326 10 : self.ptr.as_mut().unwrap().write(output.to_str().unwrap());
327 10 : }
328 :
329 : /// Write back the current ELF binary into the file specified in parameter with the
330 : /// configuration provided in the second parameter.
331 10 : pub fn write_with_config(&mut self, output: &Path, config: Config) {
332 10 : self.ptr
333 10 : .as_mut()
334 10 : .unwrap()
335 10 : .write_with_config(output.to_str().unwrap(), config.to_ffi());
336 10 : }
337 :
338 : /// Add a library as dependency
339 10 : pub fn add_library<'a>(&'a mut self, library: &str) -> Library<'a> {
340 10 : Library::from_ffi(self.ptr.as_mut().unwrap().add_library(library))
341 10 : }
342 :
343 80 : pub fn functions(&self) -> generic::Functions {
344 80 : generic::Functions::new(self.ptr.functions())
345 80 : }
346 : }
347 :
348 : impl generic::Binary for Binary {
349 400 : fn as_generic(&self) -> &ffi::AbstractBinary {
350 400 : self.ptr.as_ref().unwrap().as_ref()
351 400 : }
352 :
353 0 : fn as_pin_mut_generic(&mut self) -> Pin<&mut ffi::AbstractBinary> {
354 0 : unsafe {
355 0 : Pin::new_unchecked({
356 0 : (self.ptr.as_ref().unwrap().as_ref() as *const ffi::AbstractBinary
357 0 : as *mut ffi::AbstractBinary)
358 0 : .as_mut()
359 0 : .unwrap()
360 0 : })
361 0 : }
362 0 : }
363 : }
364 :
365 15540 : declare_iterator!(
366 15540 : SymbolsVersion,
367 15540 : SymbolVersion<'a>,
368 15540 : ffi::ELF_SymbolVersion,
369 15540 : ffi::ELF_Binary,
370 15540 : ffi::ELF_Binary_it_symbols_version
371 15540 : );
372 150 : declare_iterator!(
373 150 : SymbolsVersionRequirement,
374 150 : SymbolVersionRequirement<'a>,
375 150 : ffi::ELF_SymbolVersionRequirement,
376 150 : ffi::ELF_Binary,
377 150 : ffi::ELF_Binary_it_symbols_version_requirement
378 150 : );
379 30 : declare_iterator!(
380 30 : SymbolsVersionDefinition,
381 30 : SymbolVersionDefinition<'a>,
382 30 : ffi::ELF_SymbolVersionDefinition,
383 30 : ffi::ELF_Binary,
384 30 : ffi::ELF_Binary_it_symbols_version_definition
385 30 : );
|
