object/read/elf/
file.rs

Help
1use alloc::vec::Vec;
2use core::convert::TryInto;
3use core::fmt::Debug;
4use core::mem;
5
6use crate::elf;
7use crate::endian::{self, Endian, Endianness, U32};
8use crate::pod::Pod;
9use crate::read::{
10    self, util, Architecture, ByteString, Bytes, Error, Export, FileFlags, Import, Object,
11    ObjectKind, ReadError, ReadRef, SectionIndex, StringTable, SymbolIndex,
12};
13
14use super::{
15    CompressionHeader, Dyn, ElfComdat, ElfComdatIterator, ElfDynamicRelocationIterator, ElfSection,
16    ElfSectionIterator, ElfSegment, ElfSegmentIterator, ElfSymbol, ElfSymbolIterator,
17    ElfSymbolTable, NoteHeader, ProgramHeader, Rel, Rela, RelocationSections, Relr, SectionHeader,
18    SectionTable, Sym, SymbolTable,
19};
20
21/// A 32-bit ELF object file.
22///
23/// This is a file that starts with [`elf::FileHeader32`], and corresponds
24/// to [`crate::FileKind::Elf32`].
25pub type ElfFile32<'data, Endian = Endianness, R = &'data [u8]> =
26    ElfFile<'data, elf::FileHeader32<Endian>, R>;
27/// A 64-bit ELF object file.
28///
29/// This is a file that starts with [`elf::FileHeader64`], and corresponds
30/// to [`crate::FileKind::Elf64`].
31pub type ElfFile64<'data, Endian = Endianness, R = &'data [u8]> =
32    ElfFile<'data, elf::FileHeader64<Endian>, R>;
33
34/// A partially parsed ELF file.
35///
36/// Most functionality is provided by the [`Object`] trait implementation.
37#[derive(Debug)]
38pub struct ElfFile<'data, Elf, R = &'data [u8]>
39where
40    Elf: FileHeader,
41    R: ReadRef<'data>,
42{
43    pub(super) endian: Elf::Endian,
44    pub(super) data: R,
45    pub(super) header: &'data Elf,
46    pub(super) segments: &'data [Elf::ProgramHeader],
47    pub(super) sections: SectionTable<'data, Elf, R>,
48    pub(super) relocations: RelocationSections,
49    pub(super) symbols: SymbolTable<'data, Elf, R>,
50    pub(super) dynamic_symbols: SymbolTable<'data, Elf, R>,
51}
52
53impl<'data, Elf, R> ElfFile<'data, Elf, R>
54where
55    Elf: FileHeader,
56    R: ReadRef<'data>,
57{
58    /// Parse the raw ELF file data.
59    pub fn parse(data: R) -> read::Result<Self> {
60        let header = Elf::parse(data)?;
61        let endian = header.endian()?;
62        let segments = header.program_headers(endian, data)?;
63        let sections = header.sections(endian, data)?;
64        let symbols = sections.symbols(endian, data, elf::SHT_SYMTAB)?;
65        // TODO: get dynamic symbols from DT_SYMTAB if there are no sections
66        let dynamic_symbols = sections.symbols(endian, data, elf::SHT_DYNSYM)?;
67        // The API we provide requires a mapping from section to relocations, so build it now.
68        let relocations = sections.relocation_sections(endian, symbols.section())?;
69
70        Ok(ElfFile {
71            endian,
72            data,
73            header,
74            segments,
75            sections,
76            relocations,
77            symbols,
78            dynamic_symbols,
79        })
80    }
81
82    /// Returns the endianness.
83    pub fn endian(&self) -> Elf::Endian {
84        self.endian
85    }
86
87    /// Returns the raw data.
88    pub fn data(&self) -> R {
89        self.data
90    }
91
92    /// Returns the raw ELF file header.
93    #[deprecated(note = "Use `elf_header` instead")]
94    pub fn raw_header(&self) -> &'data Elf {
95        self.header
96    }
97
98    /// Returns the raw ELF segments.
99    #[deprecated(note = "Use `elf_program_headers` instead")]
100    pub fn raw_segments(&self) -> &'data [Elf::ProgramHeader] {
101        self.segments
102    }
103
104    /// Get the raw ELF file header.
105    pub fn elf_header(&self) -> &'data Elf {
106        self.header
107    }
108
109    /// Get the raw ELF program headers.
110    ///
111    /// Returns an empty slice if the file has no program headers.
112    pub fn elf_program_headers(&self) -> &'data [Elf::ProgramHeader] {
113        self.segments
114    }
115
116    /// Get the ELF section table.
117    ///
118    /// Returns an empty section table if the file has no section headers.
119    pub fn elf_section_table(&self) -> &SectionTable<'data, Elf, R> {
120        &self.sections
121    }
122
123    /// Get the ELF symbol table.
124    ///
125    /// Returns an empty symbol table if the file has no symbol table.
126    pub fn elf_symbol_table(&self) -> &SymbolTable<'data, Elf, R> {
127        &self.symbols
128    }
129
130    /// Get the ELF dynamic symbol table.
131    ///
132    /// Returns an empty symbol table if the file has no dynamic symbol table.
133    pub fn elf_dynamic_symbol_table(&self) -> &SymbolTable<'data, Elf, R> {
134        &self.dynamic_symbols
135    }
136
137    /// Get a mapping for linked relocation sections.
138    pub fn elf_relocation_sections(&self) -> &RelocationSections {
139        &self.relocations
140    }
141
142    fn raw_section_by_name<'file>(
143        &'file self,
144        section_name: &[u8],
145    ) -> Option<ElfSection<'data, 'file, Elf, R>> {
146        self.sections
147            .section_by_name(self.endian, section_name)
148            .map(|(index, section)| ElfSection {
149                file: self,
150                index,
151                section,
152            })
153    }
154
155    #[cfg(feature = "compression")]
156    fn zdebug_section_by_name<'file>(
157        &'file self,
158        section_name: &[u8],
159    ) -> Option<ElfSection<'data, 'file, Elf, R>> {
160        if !section_name.starts_with(b".debug_") {
161            return None;
162        }
163        let mut name = Vec::with_capacity(section_name.len() + 1);
164        name.extend_from_slice(b".zdebug_");
165        name.extend_from_slice(&section_name[7..]);
166        self.raw_section_by_name(&name)
167    }
168
169    #[cfg(not(feature = "compression"))]
170    fn zdebug_section_by_name<'file>(
171        &'file self,
172        _section_name: &[u8],
173    ) -> Option<ElfSection<'data, 'file, Elf, R>> {
174        None
175    }
176}
177
178impl<'data, Elf, R> read::private::Sealed for ElfFile<'data, Elf, R>
179where
180    Elf: FileHeader,
181    R: ReadRef<'data>,
182{
183}
184
185impl<'data, Elf, R> Object<'data> for ElfFile<'data, Elf, R>
186where
187    Elf: FileHeader,
188    R: ReadRef<'data>,
189{
190    type Segment<'file>
191        = ElfSegment<'data, 'file, Elf, R>
192    where
193        Self: 'file,
194        'data: 'file;
195    type SegmentIterator<'file>
196        = ElfSegmentIterator<'data, 'file, Elf, R>
197    where
198        Self: 'file,
199        'data: 'file;
200    type Section<'file>
201        = ElfSection<'data, 'file, Elf, R>
202    where
203        Self: 'file,
204        'data: 'file;
205    type SectionIterator<'file>
206        = ElfSectionIterator<'data, 'file, Elf, R>
207    where
208        Self: 'file,
209        'data: 'file;
210    type Comdat<'file>
211        = ElfComdat<'data, 'file, Elf, R>
212    where
213        Self: 'file,
214        'data: 'file;
215    type ComdatIterator<'file>
216        = ElfComdatIterator<'data, 'file, Elf, R>
217    where
218        Self: 'file,
219        'data: 'file;
220    type Symbol<'file>
221        = ElfSymbol<'data, 'file, Elf, R>
222    where
223        Self: 'file,
224        'data: 'file;
225    type SymbolIterator<'file>
226        = ElfSymbolIterator<'data, 'file, Elf, R>
227    where
228        Self: 'file,
229        'data: 'file;
230    type SymbolTable<'file>
231        = ElfSymbolTable<'data, 'file, Elf, R>
232    where
233        Self: 'file,
234        'data: 'file;
235    type DynamicRelocationIterator<'file>
236        = ElfDynamicRelocationIterator<'data, 'file, Elf, R>
237    where
238        Self: 'file,
239        'data: 'file;
240
241    fn architecture(&self) -> Architecture {
242        match (
243            self.header.e_machine(self.endian),
244            self.header.is_class_64(),
245        ) {
246            (elf::EM_AARCH64, true) => Architecture::Aarch64,
247            (elf::EM_AARCH64, false) => Architecture::Aarch64_Ilp32,
248            (elf::EM_ARM, _) => Architecture::Arm,
249            (elf::EM_AVR, _) => Architecture::Avr,
250            (elf::EM_BPF, _) => Architecture::Bpf,
251            (elf::EM_CSKY, _) => Architecture::Csky,
252            (elf::EM_MCST_ELBRUS, false) => Architecture::E2K32,
253            (elf::EM_MCST_ELBRUS, true) => Architecture::E2K64,
254            (elf::EM_386, _) => Architecture::I386,
255            (elf::EM_X86_64, false) => Architecture::X86_64_X32,
256            (elf::EM_X86_64, true) => Architecture::X86_64,
257            (elf::EM_HEXAGON, _) => Architecture::Hexagon,
258            (elf::EM_LOONGARCH, true) => Architecture::LoongArch64,
259            (elf::EM_68K, false) => Architecture::M68k,
260            (elf::EM_MIPS, false) => {
261                if (self.header.e_flags(self.endian) & elf::EF_MIPS_ABI2) != 0 {
262                    Architecture::Mips64_N32
263                } else {
264                    Architecture::Mips
265                }
266            }
267            (elf::EM_MIPS, true) => Architecture::Mips64,
268            (elf::EM_MSP430, _) => Architecture::Msp430,
269            (elf::EM_PPC, _) => Architecture::PowerPc,
270            (elf::EM_PPC64, _) => Architecture::PowerPc64,
271            (elf::EM_RISCV, false) => Architecture::Riscv32,
272            (elf::EM_RISCV, true) => Architecture::Riscv64,
273            // This is either s390 or s390x, depending on the ELF class.
274            // We only support the 64-bit variant s390x here.
275            (elf::EM_S390, true) => Architecture::S390x,
276            (elf::EM_SBF, _) => Architecture::Sbf,
277            (elf::EM_SHARC, false) => Architecture::Sharc,
278            (elf::EM_SPARC, false) => Architecture::Sparc,
279            (elf::EM_SPARC32PLUS, false) => Architecture::Sparc32Plus,
280            (elf::EM_SPARCV9, true) => Architecture::Sparc64,
281            (elf::EM_XTENSA, false) => Architecture::Xtensa,
282            _ => Architecture::Unknown,
283        }
284    }
285
286    #[inline]
287    fn is_little_endian(&self) -> bool {
288        self.header.is_little_endian()
289    }
290
291    #[inline]
292    fn is_64(&self) -> bool {
293        self.header.is_class_64()
294    }
295
296    fn kind(&self) -> ObjectKind {
297        match self.header.e_type(self.endian) {
298            elf::ET_REL => ObjectKind::Relocatable,
299            elf::ET_EXEC => ObjectKind::Executable,
300            // TODO: check for `DF_1_PIE`?
301            elf::ET_DYN => ObjectKind::Dynamic,
302            elf::ET_CORE => ObjectKind::Core,
303            _ => ObjectKind::Unknown,
304        }
305    }
306
307    fn segments(&self) -> ElfSegmentIterator<'data, '_, Elf, R> {
308        ElfSegmentIterator {
309            file: self,
310            iter: self.segments.iter(),
311        }
312    }
313
314    fn section_by_name_bytes<'file>(
315        &'file self,
316        section_name: &[u8],
317    ) -> Option<ElfSection<'data, 'file, Elf, R>> {
318        self.raw_section_by_name(section_name)
319            .or_else(|| self.zdebug_section_by_name(section_name))
320    }
321
322    fn section_by_index(&self, index: SectionIndex) -> read::Result<ElfSection<'data, '_, Elf, R>> {
323        let section = self.sections.section(index)?;
324        Ok(ElfSection {
325            file: self,
326            index,
327            section,
328        })
329    }
330
331    fn sections(&self) -> ElfSectionIterator<'data, '_, Elf, R> {
332        ElfSectionIterator::new(self)
333    }
334
335    fn comdats(&self) -> ElfComdatIterator<'data, '_, Elf, R> {
336        ElfComdatIterator::new(self)
337    }
338
339    fn symbol_by_index(&self, index: SymbolIndex) -> read::Result<ElfSymbol<'data, '_, Elf, R>> {
340        let symbol = self.symbols.symbol(index)?;
341        Ok(ElfSymbol {
342            endian: self.endian,
343            symbols: &self.symbols,
344            index,
345            symbol,
346        })
347    }
348
349    fn symbols(&self) -> ElfSymbolIterator<'data, '_, Elf, R> {
350        ElfSymbolIterator::new(self.endian, &self.symbols)
351    }
352
353    fn symbol_table(&self) -> Option<ElfSymbolTable<'data, '_, Elf, R>> {
354        if self.symbols.is_empty() {
355            return None;
356        }
357        Some(ElfSymbolTable {
358            endian: self.endian,
359            symbols: &self.symbols,
360        })
361    }
362
363    fn dynamic_symbols(&self) -> ElfSymbolIterator<'data, '_, Elf, R> {
364        ElfSymbolIterator::new(self.endian, &self.dynamic_symbols)
365    }
366
367    fn dynamic_symbol_table(&self) -> Option<ElfSymbolTable<'data, '_, Elf, R>> {
368        if self.dynamic_symbols.is_empty() {
369            return None;
370        }
371        Some(ElfSymbolTable {
372            endian: self.endian,
373            symbols: &self.dynamic_symbols,
374        })
375    }
376
377    fn dynamic_relocations<'file>(
378        &'file self,
379    ) -> Option<ElfDynamicRelocationIterator<'data, 'file, Elf, R>> {
380        Some(ElfDynamicRelocationIterator {
381            section_index: SectionIndex(1),
382            file: self,
383            relocations: None,
384        })
385    }
386
387    fn imports(&self) -> read::Result<Vec<Import<'data>>> {
388        let versions = self.sections.versions(self.endian, self.data)?;
389
390        let mut imports = Vec::new();
391        for (index, symbol) in self.dynamic_symbols.enumerate() {
392            if symbol.is_undefined(self.endian) {
393                let name = symbol.name(self.endian, self.dynamic_symbols.strings())?;
394                if !name.is_empty() {
395                    let library = if let Some(svt) = versions.as_ref() {
396                        let vi = svt.version_index(self.endian, index);
397                        svt.version(vi)?.and_then(|v| v.file())
398                    } else {
399                        None
400                    }
401                    .unwrap_or(&[]);
402                    imports.push(Import {
403                        name: ByteString(name),
404                        library: ByteString(library),
405                    });
406                }
407            }
408        }
409        Ok(imports)
410    }
411
412    fn exports(&self) -> read::Result<Vec<Export<'data>>> {
413        let mut exports = Vec::new();
414        for symbol in self.dynamic_symbols.iter() {
415            if symbol.is_definition(self.endian) {
416                let name = symbol.name(self.endian, self.dynamic_symbols.strings())?;
417                let address = symbol.st_value(self.endian).into();
418                exports.push(Export {
419                    name: ByteString(name),
420                    address,
421                });
422            }
423        }
424        Ok(exports)
425    }
426
427    fn has_debug_symbols(&self) -> bool {
428        for section in self.sections.iter() {
429            if let Ok(name) = self.sections.section_name(self.endian, section) {
430                if name == b".debug_info" || name == b".zdebug_info" {
431                    return true;
432                }
433            }
434        }
435        false
436    }
437
438    fn build_id(&self) -> read::Result<Option<&'data [u8]>> {
439        let endian = self.endian;
440        // Use section headers if present, otherwise use program headers.
441        if !self.sections.is_empty() {
442            for section in self.sections.iter() {
443                if let Some(mut notes) = section.notes(endian, self.data)? {
444                    while let Some(note) = notes.next()? {
445                        if note.name() == elf::ELF_NOTE_GNU
446                            && note.n_type(endian) == elf::NT_GNU_BUILD_ID
447                        {
448                            return Ok(Some(note.desc()));
449                        }
450                    }
451                }
452            }
453        } else {
454            for segment in self.segments {
455                if let Some(mut notes) = segment.notes(endian, self.data)? {
456                    while let Some(note) = notes.next()? {
457                        if note.name() == elf::ELF_NOTE_GNU
458                            && note.n_type(endian) == elf::NT_GNU_BUILD_ID
459                        {
460                            return Ok(Some(note.desc()));
461                        }
462                    }
463                }
464            }
465        }
466        Ok(None)
467    }
468
469    fn gnu_debuglink(&self) -> read::Result<Option<(&'data [u8], u32)>> {
470        let section = match self.raw_section_by_name(b".gnu_debuglink") {
471            Some(section) => section,
472            None => return Ok(None),
473        };
474        let data = section
475            .section
476            .data(self.endian, self.data)
477            .read_error("Invalid ELF .gnu_debuglink section offset or size")
478            .map(Bytes)?;
479        let filename = data
480            .read_string_at(0)
481            .read_error("Missing ELF .gnu_debuglink filename")?;
482        let crc_offset = util::align(filename.len() + 1, 4);
483        let crc = data
484            .read_at::<U32<_>>(crc_offset)
485            .read_error("Missing ELF .gnu_debuglink crc")?
486            .get(self.endian);
487        Ok(Some((filename, crc)))
488    }
489
490    fn gnu_debugaltlink(&self) -> read::Result<Option<(&'data [u8], &'data [u8])>> {
491        let section = match self.raw_section_by_name(b".gnu_debugaltlink") {
492            Some(section) => section,
493            None => return Ok(None),
494        };
495        let mut data = section
496            .section
497            .data(self.endian, self.data)
498            .read_error("Invalid ELF .gnu_debugaltlink section offset or size")
499            .map(Bytes)?;
500        let filename = data
501            .read_string()
502            .read_error("Missing ELF .gnu_debugaltlink filename")?;
503        let build_id = data.0;
504        Ok(Some((filename, build_id)))
505    }
506
507    fn relative_address_base(&self) -> u64 {
508        0
509    }
510
511    fn entry(&self) -> u64 {
512        self.header.e_entry(self.endian).into()
513    }
514
515    fn flags(&self) -> FileFlags {
516        FileFlags::Elf {
517            os_abi: self.header.e_ident().os_abi,
518            abi_version: self.header.e_ident().abi_version,
519            e_flags: self.header.e_flags(self.endian),
520        }
521    }
522}
523
524/// A trait for generic access to [`elf::FileHeader32`] and [`elf::FileHeader64`].
525#[allow(missing_docs)]
526pub trait FileHeader: Debug + Pod {
527    // Ideally this would be a `u64: From<Word>`, but can't express that.
528    type Word: Into<u64> + Default + Copy;
529    type Sword: Into<i64>;
530    type Endian: endian::Endian;
531    type ProgramHeader: ProgramHeader<Elf = Self, Endian = Self::Endian, Word = Self::Word>;
532    type SectionHeader: SectionHeader<Elf = Self, Endian = Self::Endian, Word = Self::Word>;
533    type CompressionHeader: CompressionHeader<Endian = Self::Endian, Word = Self::Word>;
534    type NoteHeader: NoteHeader<Endian = Self::Endian>;
535    type Dyn: Dyn<Endian = Self::Endian, Word = Self::Word>;
536    type Sym: Sym<Endian = Self::Endian, Word = Self::Word>;
537    type Rel: Rel<Endian = Self::Endian, Word = Self::Word>;
538    type Rela: Rela<Endian = Self::Endian, Word = Self::Word> + From<Self::Rel>;
539    type Relr: Relr<Endian = Self::Endian, Word = Self::Word>;
540
541    /// Return true if this type is a 64-bit header.
542    ///
543    /// This is a property of the type, not a value in the header data.
544    fn is_type_64(&self) -> bool;
545
546    /// Return true if this type is a 64-bit header.
547    ///
548    /// This is a property of the type, not a value in the header data.
549    ///
550    /// This is the same as [`Self::is_type_64`], but is non-dispatchable.
551    fn is_type_64_sized() -> bool
552    where
553        Self: Sized;
554
555    fn e_ident(&self) -> &elf::Ident;
556    fn e_type(&self, endian: Self::Endian) -> u16;
557    fn e_machine(&self, endian: Self::Endian) -> u16;
558    fn e_version(&self, endian: Self::Endian) -> u32;
559    fn e_entry(&self, endian: Self::Endian) -> Self::Word;
560    fn e_phoff(&self, endian: Self::Endian) -> Self::Word;
561    fn e_shoff(&self, endian: Self::Endian) -> Self::Word;
562    fn e_flags(&self, endian: Self::Endian) -> u32;
563    fn e_ehsize(&self, endian: Self::Endian) -> u16;
564    fn e_phentsize(&self, endian: Self::Endian) -> u16;
565    fn e_phnum(&self, endian: Self::Endian) -> u16;
566    fn e_shentsize(&self, endian: Self::Endian) -> u16;
567    fn e_shnum(&self, endian: Self::Endian) -> u16;
568    fn e_shstrndx(&self, endian: Self::Endian) -> u16;
569
570    // Provided methods.
571
572    /// Read the file header.
573    ///
574    /// Also checks that the ident field in the file header is a supported format.
575    fn parse<'data, R: ReadRef<'data>>(data: R) -> read::Result<&'data Self> {
576        let header = data
577            .read_at::<Self>(0)
578            .read_error("Invalid ELF header size or alignment")?;
579        if !header.is_supported() {
580            return Err(Error("Unsupported ELF header"));
581        }
582        // TODO: Check self.e_ehsize?
583        Ok(header)
584    }
585
586    /// Check that the ident field in the file header is a supported format.
587    ///
588    /// This checks the magic number, version, class, and endianness.
589    fn is_supported(&self) -> bool {
590        let ident = self.e_ident();
591        // TODO: Check self.e_version too? Requires endian though.
592        ident.magic == elf::ELFMAG
593            && (self.is_type_64() || self.is_class_32())
594            && (!self.is_type_64() || self.is_class_64())
595            && (self.is_little_endian() || self.is_big_endian())
596            && ident.version == elf::EV_CURRENT
597    }
598
599    fn is_class_32(&self) -> bool {
600        self.e_ident().class == elf::ELFCLASS32
601    }
602
603    fn is_class_64(&self) -> bool {
604        self.e_ident().class == elf::ELFCLASS64
605    }
606
607    fn is_little_endian(&self) -> bool {
608        self.e_ident().data == elf::ELFDATA2LSB
609    }
610
611    fn is_big_endian(&self) -> bool {
612        self.e_ident().data == elf::ELFDATA2MSB
613    }
614
615    fn endian(&self) -> read::Result<Self::Endian> {
616        Self::Endian::from_big_endian(self.is_big_endian()).read_error("Unsupported ELF endian")
617    }
618
619    /// Return the first section header, if present.
620    ///
621    /// Section 0 is a special case because getting the section headers normally
622    /// requires `shnum`, but `shnum` may be in the first section header.
623    fn section_0<'data, R: ReadRef<'data>>(
624        &self,
625        endian: Self::Endian,
626        data: R,
627    ) -> read::Result<Option<&'data Self::SectionHeader>> {
628        let shoff: u64 = self.e_shoff(endian).into();
629        if shoff == 0 {
630            // No section headers is ok.
631            return Ok(None);
632        }
633        let shentsize = usize::from(self.e_shentsize(endian));
634        if shentsize != mem::size_of::<Self::SectionHeader>() {
635            // Section header size must match.
636            return Err(Error("Invalid ELF section header entry size"));
637        }
638        data.read_at(shoff)
639            .map(Some)
640            .read_error("Invalid ELF section header offset or size")
641    }
642
643    /// Return the `e_phnum` field of the header. Handles extended values.
644    ///
645    /// Returns `Err` for invalid values.
646    fn phnum<'data, R: ReadRef<'data>>(
647        &self,
648        endian: Self::Endian,
649        data: R,
650    ) -> read::Result<usize> {
651        let e_phnum = self.e_phnum(endian);
652        if e_phnum < elf::PN_XNUM {
653            Ok(e_phnum as usize)
654        } else if let Some(section_0) = self.section_0(endian, data)? {
655            Ok(section_0.sh_info(endian) as usize)
656        } else {
657            // Section 0 must exist if e_phnum overflows.
658            Err(Error("Missing ELF section headers for e_phnum overflow"))
659        }
660    }
661
662    /// Return the `e_shnum` field of the header. Handles extended values.
663    ///
664    /// Returns `Err` for invalid values.
665    fn shnum<'data, R: ReadRef<'data>>(
666        &self,
667        endian: Self::Endian,
668        data: R,
669    ) -> read::Result<usize> {
670        let e_shnum = self.e_shnum(endian);
671        if e_shnum > 0 {
672            Ok(e_shnum as usize)
673        } else if let Some(section_0) = self.section_0(endian, data)? {
674            section_0
675                .sh_size(endian)
676                .into()
677                .try_into()
678                .ok()
679                .read_error("Invalid ELF extended e_shnum")
680        } else {
681            // No section headers is ok.
682            Ok(0)
683        }
684    }
685
686    /// Return the `e_shstrndx` field of the header. Handles extended values.
687    ///
688    /// Returns `Err` for invalid values (including if the index is 0).
689    fn shstrndx<'data, R: ReadRef<'data>>(
690        &self,
691        endian: Self::Endian,
692        data: R,
693    ) -> read::Result<u32> {
694        let e_shstrndx = self.e_shstrndx(endian);
695        let index = if e_shstrndx != elf::SHN_XINDEX {
696            e_shstrndx.into()
697        } else if let Some(section_0) = self.section_0(endian, data)? {
698            section_0.sh_link(endian)
699        } else {
700            // Section 0 must exist if we're trying to read e_shstrndx.
701            return Err(Error("Missing ELF section headers for e_shstrndx overflow"));
702        };
703        if index == 0 {
704            return Err(Error("Missing ELF e_shstrndx"));
705        }
706        Ok(index)
707    }
708
709    /// Return the slice of program headers.
710    ///
711    /// Returns `Ok(&[])` if there are no program headers.
712    /// Returns `Err` for invalid values.
713    fn program_headers<'data, R: ReadRef<'data>>(
714        &self,
715        endian: Self::Endian,
716        data: R,
717    ) -> read::Result<&'data [Self::ProgramHeader]> {
718        let phoff: u64 = self.e_phoff(endian).into();
719        if phoff == 0 {
720            // No program headers is ok.
721            return Ok(&[]);
722        }
723        let phnum = self.phnum(endian, data)?;
724        if phnum == 0 {
725            // No program headers is ok.
726            return Ok(&[]);
727        }
728        let phentsize = self.e_phentsize(endian) as usize;
729        if phentsize != mem::size_of::<Self::ProgramHeader>() {
730            // Program header size must match.
731            return Err(Error("Invalid ELF program header entry size"));
732        }
733        data.read_slice_at(phoff, phnum)
734            .read_error("Invalid ELF program header size or alignment")
735    }
736
737    /// Return the slice of section headers.
738    ///
739    /// Returns `Ok(&[])` if there are no section headers.
740    /// Returns `Err` for invalid values.
741    fn section_headers<'data, R: ReadRef<'data>>(
742        &self,
743        endian: Self::Endian,
744        data: R,
745    ) -> read::Result<&'data [Self::SectionHeader]> {
746        let shoff: u64 = self.e_shoff(endian).into();
747        if shoff == 0 {
748            // No section headers is ok.
749            return Ok(&[]);
750        }
751        let shnum = self.shnum(endian, data)?;
752        if shnum == 0 {
753            // No section headers is ok.
754            return Ok(&[]);
755        }
756        let shentsize = usize::from(self.e_shentsize(endian));
757        if shentsize != mem::size_of::<Self::SectionHeader>() {
758            // Section header size must match.
759            return Err(Error("Invalid ELF section header entry size"));
760        }
761        data.read_slice_at(shoff, shnum)
762            .read_error("Invalid ELF section header offset/size/alignment")
763    }
764
765    /// Get the section index of the section header string table.
766    ///
767    /// Returns `Err` for invalid values (including if the index is 0).
768    fn section_strings_index<'data, R: ReadRef<'data>>(
769        &self,
770        endian: Self::Endian,
771        data: R,
772    ) -> read::Result<SectionIndex> {
773        self.shstrndx(endian, data)
774            .map(|index| SectionIndex(index as usize))
775    }
776
777    /// Return the string table for the section headers.
778    fn section_strings<'data, R: ReadRef<'data>>(
779        &self,
780        endian: Self::Endian,
781        data: R,
782        sections: &[Self::SectionHeader],
783    ) -> read::Result<StringTable<'data, R>> {
784        if sections.is_empty() {
785            return Ok(StringTable::default());
786        }
787        let index = self.section_strings_index(endian, data)?;
788        let shstrtab = sections.get(index.0).read_error("Invalid ELF e_shstrndx")?;
789        let strings = if let Some((shstrtab_offset, shstrtab_size)) = shstrtab.file_range(endian) {
790            let shstrtab_end = shstrtab_offset
791                .checked_add(shstrtab_size)
792                .read_error("Invalid ELF shstrtab size")?;
793            StringTable::new(data, shstrtab_offset, shstrtab_end)
794        } else {
795            StringTable::default()
796        };
797        Ok(strings)
798    }
799
800    /// Return the section table.
801    fn sections<'data, R: ReadRef<'data>>(
802        &self,
803        endian: Self::Endian,
804        data: R,
805    ) -> read::Result<SectionTable<'data, Self, R>> {
806        let sections = self.section_headers(endian, data)?;
807        let strings = self.section_strings(endian, data, sections)?;
808        Ok(SectionTable::new(sections, strings))
809    }
810
811    /// Returns whether this is a mips64el elf file.
812    fn is_mips64el(&self, endian: Self::Endian) -> bool {
813        self.is_class_64() && self.is_little_endian() && self.e_machine(endian) == elf::EM_MIPS
814    }
815}
816
817impl<Endian: endian::Endian> FileHeader for elf::FileHeader32<Endian> {
818    type Word = u32;
819    type Sword = i32;
820    type Endian = Endian;
821    type ProgramHeader = elf::ProgramHeader32<Endian>;
822    type SectionHeader = elf::SectionHeader32<Endian>;
823    type CompressionHeader = elf::CompressionHeader32<Endian>;
824    type NoteHeader = elf::NoteHeader32<Endian>;
825    type Dyn = elf::Dyn32<Endian>;
826    type Sym = elf::Sym32<Endian>;
827    type Rel = elf::Rel32<Endian>;
828    type Rela = elf::Rela32<Endian>;
829    type Relr = elf::Relr32<Endian>;
830
831    #[inline]
832    fn is_type_64(&self) -> bool {
833        false
834    }
835
836    #[inline]
837    fn is_type_64_sized() -> bool
838    where
839        Self: Sized,
840    {
841        false
842    }
843
844    #[inline]
845    fn e_ident(&self) -> &elf::Ident {
846        &self.e_ident
847    }
848
849    #[inline]
850    fn e_type(&self, endian: Self::Endian) -> u16 {
851        self.e_type.get(endian)
852    }
853
854    #[inline]
855    fn e_machine(&self, endian: Self::Endian) -> u16 {
856        self.e_machine.get(endian)
857    }
858
859    #[inline]
860    fn e_version(&self, endian: Self::Endian) -> u32 {
861        self.e_version.get(endian)
862    }
863
864    #[inline]
865    fn e_entry(&self, endian: Self::Endian) -> Self::Word {
866        self.e_entry.get(endian)
867    }
868
869    #[inline]
870    fn e_phoff(&self, endian: Self::Endian) -> Self::Word {
871        self.e_phoff.get(endian)
872    }
873
874    #[inline]
875    fn e_shoff(&self, endian: Self::Endian) -> Self::Word {
876        self.e_shoff.get(endian)
877    }
878
879    #[inline]
880    fn e_flags(&self, endian: Self::Endian) -> u32 {
881        self.e_flags.get(endian)
882    }
883
884    #[inline]
885    fn e_ehsize(&self, endian: Self::Endian) -> u16 {
886        self.e_ehsize.get(endian)
887    }
888
889    #[inline]
890    fn e_phentsize(&self, endian: Self::Endian) -> u16 {
891        self.e_phentsize.get(endian)
892    }
893
894    #[inline]
895    fn e_phnum(&self, endian: Self::Endian) -> u16 {
896        self.e_phnum.get(endian)
897    }
898
899    #[inline]
900    fn e_shentsize(&self, endian: Self::Endian) -> u16 {
901        self.e_shentsize.get(endian)
902    }
903
904    #[inline]
905    fn e_shnum(&self, endian: Self::Endian) -> u16 {
906        self.e_shnum.get(endian)
907    }
908
909    #[inline]
910    fn e_shstrndx(&self, endian: Self::Endian) -> u16 {
911        self.e_shstrndx.get(endian)
912    }
913}
914
915impl<Endian: endian::Endian> FileHeader for elf::FileHeader64<Endian> {
916    type Word = u64;
917    type Sword = i64;
918    type Endian = Endian;
919    type ProgramHeader = elf::ProgramHeader64<Endian>;
920    type SectionHeader = elf::SectionHeader64<Endian>;
921    type CompressionHeader = elf::CompressionHeader64<Endian>;
922    type NoteHeader = elf::NoteHeader32<Endian>;
923    type Dyn = elf::Dyn64<Endian>;
924    type Sym = elf::Sym64<Endian>;
925    type Rel = elf::Rel64<Endian>;
926    type Rela = elf::Rela64<Endian>;
927    type Relr = elf::Relr64<Endian>;
928
929    #[inline]
930    fn is_type_64(&self) -> bool {
931        true
932    }
933
934    #[inline]
935    fn is_type_64_sized() -> bool
936    where
937        Self: Sized,
938    {
939        true
940    }
941
942    #[inline]
943    fn e_ident(&self) -> &elf::Ident {
944        &self.e_ident
945    }
946
947    #[inline]
948    fn e_type(&self, endian: Self::Endian) -> u16 {
949        self.e_type.get(endian)
950    }
951
952    #[inline]
953    fn e_machine(&self, endian: Self::Endian) -> u16 {
954        self.e_machine.get(endian)
955    }
956
957    #[inline]
958    fn e_version(&self, endian: Self::Endian) -> u32 {
959        self.e_version.get(endian)
960    }
961
962    #[inline]
963    fn e_entry(&self, endian: Self::Endian) -> Self::Word {
964        self.e_entry.get(endian)
965    }
966
967    #[inline]
968    fn e_phoff(&self, endian: Self::Endian) -> Self::Word {
969        self.e_phoff.get(endian)
970    }
971
972    #[inline]
973    fn e_shoff(&self, endian: Self::Endian) -> Self::Word {
974        self.e_shoff.get(endian)
975    }
976
977    #[inline]
978    fn e_flags(&self, endian: Self::Endian) -> u32 {
979        self.e_flags.get(endian)
980    }
981
982    #[inline]
983    fn e_ehsize(&self, endian: Self::Endian) -> u16 {
984        self.e_ehsize.get(endian)
985    }
986
987    #[inline]
988    fn e_phentsize(&self, endian: Self::Endian) -> u16 {
989        self.e_phentsize.get(endian)
990    }
991
992    #[inline]
993    fn e_phnum(&self, endian: Self::Endian) -> u16 {
994        self.e_phnum.get(endian)
995    }
996
997    #[inline]
998    fn e_shentsize(&self, endian: Self::Endian) -> u16 {
999        self.e_shentsize.get(endian)
1000    }
1001
1002    #[inline]
1003    fn e_shnum(&self, endian: Self::Endian) -> u16 {
1004        self.e_shnum.get(endian)
1005    }
1006
1007    #[inline]
1008    fn e_shstrndx(&self, endian: Self::Endian) -> u16 {
1009        self.e_shstrndx.get(endian)
1010    }
1011}
object/read/elf/file.rs

object/read/elf/
file.rs
