LIEF: Library to Instrument Executable Formats Version 0.15.1
Loading...
Searching...
No Matches
ELF/Parser.hpp
Go to the documentation of this file.
1/* Copyright 2017 - 2024 R. Thomas
2 * Copyright 2017 - 2024 Quarkslab
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#ifndef LIEF_ELF_PARSER_H
17#define LIEF_ELF_PARSER_H
18#include <unordered_map>
19
20#include "LIEF/visibility.h"
21#include "LIEF/utils.hpp"
22
24#include "LIEF/errors.hpp"
25#include "LIEF/ELF/enums.hpp"
26
28
29namespace LIEF {
30class BinaryStream;
31
32namespace OAT {
33class Parser;
34}
35namespace ELF {
36
37class Section;
38class Binary;
39class Segment;
40class Symbol;
41class Note;
42class Relocation;
43
46 friend class OAT::Parser;
47 public:
48 static constexpr uint32_t NB_MAX_SYMBOLS = 1000000;
49 static constexpr uint32_t DELTA_NB_SYMBOLS = 3000;
50 static constexpr uint32_t NB_MAX_BUCKETS = NB_MAX_SYMBOLS;
51 static constexpr uint32_t NB_MAX_CHAINS = 1000000;
52 static constexpr uint32_t NB_MAX_SEGMENTS = 10000;
53 static constexpr uint32_t NB_MAX_RELOCATIONS = 3000000;
54 static constexpr uint32_t NB_MAX_DYNAMIC_ENTRIES = 1000;
55 static constexpr uint32_t NB_MAX_MASKWORD = 512;
56 static constexpr uint32_t MAX_SEGMENT_SIZE = 3_GB;
57
62
71 static std::unique_ptr<Binary> parse(const std::string& file,
72 const ParserConfig& conf = ParserConfig::all());
73
82 static std::unique_ptr<Binary> parse(const std::vector<uint8_t>& data,
83 const ParserConfig& conf = ParserConfig::all());
84
93 static std::unique_ptr<Binary> parse(std::unique_ptr<BinaryStream> stream,
94 const ParserConfig& conf = ParserConfig::all());
95
96 Parser& operator=(const Parser&) = delete;
97 Parser(const Parser&) = delete;
98
99 protected:
100 Parser();
101 Parser(std::unique_ptr<BinaryStream> stream, ParserConfig config);
102 Parser(const std::string& file, ParserConfig config);
103 Parser(const std::vector<uint8_t>& data, ParserConfig config);
104
105 ~Parser() override;
106
107 ok_error_t init();
108
109 bool should_swap() const;
110
111 // map, dynamic_symbol.version <----> symbol_version
112 // symbol_version comes from symbol_version table
113 void link_symbol_version();
114
115 ok_error_t link_symbol_section(Symbol& sym);
116
117 template<typename ELF_T>
118 ok_error_t parse_binary();
119
120 template<typename ELF_T>
121 ok_error_t parse_header();
122
123 template<typename ELF_T>
124 ok_error_t parse_sections();
125
126 template<typename ELF_T>
127 ok_error_t parse_segments();
128
129 uint64_t get_dynamic_string_table() const;
130
131 result<uint64_t> get_dynamic_string_table_from_segments() const;
132
133 uint64_t get_dynamic_string_table_from_sections() const;
134
136 template<typename ELF_T>
137 result<uint32_t> get_numberof_dynamic_symbols(ParserConfig::DYNSYM_COUNT mtd) const;
138
140 template<typename ELF_T>
141 result<uint32_t> nb_dynsym_hash() const;
142
144 template<typename ELF_T>
145 result<uint32_t> nb_dynsym_sysv_hash() const;
146
148 template<typename ELF_T>
149 result<uint32_t> nb_dynsym_gnu_hash() const;
150
152 template<typename ELF_T>
153 result<uint32_t> nb_dynsym_section() const;
154
156 template<typename ELF_T>
157 result<uint32_t> nb_dynsym_relocations() const;
158
159 template<typename ELF_T>
160 ok_error_t parse_dynamic_entries(uint64_t offset, uint64_t size);
161
162 template<typename ELF_T>
163 ok_error_t parse_dynamic_symbols(uint64_t offset);
164
173 template<typename ELF_T>
174 ok_error_t parse_symtab_symbols(uint64_t offset, uint32_t nb_symbols,
175 const Section& string_section);
176
180 template<typename ELF_T, typename REL_T>
181 ok_error_t parse_dynamic_relocations(uint64_t relocations_offset, uint64_t size);
182
188 template<typename ELF_T, typename REL_T>
189 ok_error_t parse_pltgot_relocations(uint64_t offset, uint64_t size);
190
191
193 template<typename ELF_T>
194 ok_error_t parse_relative_relocations(uint64_t offset, uint64_t size);
195
197 template<typename ELF_T>
198 ok_error_t parse_packed_relocations(uint64_t offset, uint64_t size);
199
200 template<typename ELF_T>
201 ok_error_t process_dynamic_table();
202
205 template<typename ELF_T, typename REL_T>
206 ok_error_t parse_section_relocations(const Section& section);
207
213 template<typename ELF_T>
214 ok_error_t parse_symbol_version_requirement(uint64_t offset, uint32_t nb_entries);
215
216
222 template<typename ELF_T>
223 ok_error_t parse_symbol_version_definition(uint64_t offset, uint32_t nb_entries);
224
225
232 ok_error_t parse_symbol_version(uint64_t symbol_version_offset);
233
237 template<typename ELF_T>
238 ok_error_t parse_symbol_gnu_hash(uint64_t offset);
239
241 ok_error_t parse_notes(uint64_t offset, uint64_t size);
242
243 std::unique_ptr<Note> get_note(uint32_t type, std::string name, std::vector<uint8_t> desc_bytes);
244
246 ok_error_t parse_symbol_sysv_hash(uint64_t offset);
247
248 ok_error_t parse_overlay();
249
250 template<typename ELF_T, typename REL_T>
251 uint32_t max_relocation_index(uint64_t relocations_offset, uint64_t size) const;
252
254 static bool check_section_in_segment(const Section& section, const Segment& segment);
255
256 bool bind_symbol(Relocation& R);
257
258 std::unique_ptr<BinaryStream> stream_;
259 std::unique_ptr<Binary> binary_;
260 ParserConfig config_;
261 /*
262 * parse_sections() may skip some sections so that
263 * binary_->sections_ is not contiguous based on the index of the sections.
264 *
265 * On the other hand, we need these indexes to bind symbols that
266 * reference sections. That's why we have this unordered_map.
267 */
268 std::unordered_map<size_t, Section*> sections_idx_;
269};
270
271} // namespace ELF
272} // namespace LIEF
273#endif
Abstract binary that exposes an uniform API for the different executable file formats.
Definition Abstract/Binary.hpp:41
Class which parses and transforms an ELF file into a ELF::Binary object.
Definition ELF/Parser.hpp:45
static std::unique_ptr< Binary > parse(std::unique_ptr< BinaryStream > stream, const ParserConfig &conf=ParserConfig::all())
Parse the ELF binary from the given stream and return a LIEF::ELF::Binary object.
static std::unique_ptr< Binary > parse(const std::vector< uint8_t > &data, const ParserConfig &conf=ParserConfig::all())
Parse the given raw data as an ELF binary and return a LIEF::ELF::Binary object.
static std::unique_ptr< Binary > parse(const std::string &file, const ParserConfig &conf=ParserConfig::all())
Parse an ELF file and return a LIEF::ELF::Binary object.
ELF_TYPE
Definition ELF/Parser.hpp:58
@ ELF_UNKNOWN
Definition ELF/Parser.hpp:59
@ ELF32
Definition ELF/Parser.hpp:60
Parser(const Parser &)=delete
Parser & operator=(const Parser &)=delete
Class that represents an ELF relocation.
Definition ELF/Relocation.hpp:40
Class wich represents an ELF Section.
Definition ELF/Section.hpp:46
Class which represents the ELF segments.
Definition Segment.hpp:44
Class which represents an ELF symbol.
Definition ELF/Symbol.hpp:35
Class to parse an OAT file to produce an OAT::Binary.
Definition OAT/Parser.hpp:38
Main interface to parse an executable regardless of its format.
Definition Abstract/Parser.hpp:30
Class which represents an abstracted Relocation.
Definition Abstract/Relocation.hpp:27
Class which represents an abstracted section.
Definition Abstract/Section.hpp:29
This class represents a symbol in an executable format.
Definition Abstract/Symbol.hpp:28
LIEF namespace.
Definition Abstract/Binary.hpp:32
result< ok_t > ok_error_t
Opaque structure that is used by LIEF to avoid writing result<void> f(...). Instead,...
Definition errors.hpp:108
tl::expected< T, lief_errors > result
Wrapper that contains an Object (T) or an error.
Definition errors.hpp:74
This structure is used to tweak the ELF Parser (ELF::Parser)
Definition ELF/ParserConfig.hpp:25
DYNSYM_COUNT
Definition ELF/ParserConfig.hpp:28
#define LIEF_API
Definition visibility.h:41