1 // elfcpp_file.h -- file access for elfcpp -*- C++ -*-
2
3 // Copyright (C) 2006-2023 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of elfcpp.
7
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Library General Public License
10 // as published by the Free Software Foundation; either version 2, or
11 // (at your option) any later version.
12
13 // In addition to the permissions in the GNU Library General Public
14 // License, the Free Software Foundation gives you unlimited
15 // permission to link the compiled version of this file into
16 // combinations with other programs, and to distribute those
17 // combinations without any restriction coming from the use of this
18 // file. (The Library Public License restrictions do apply in other
19 // respects; for example, they cover modification of the file, and
20 /// distribution when not linked into a combined executable.)
21
22 // This program is distributed in the hope that it will be useful, but
23 // WITHOUT ANY WARRANTY; without even the implied warranty of
24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 // Library General Public License for more details.
26
27 // You should have received a copy of the GNU Library General Public
28 // License along with this program; if not, write to the Free Software
29 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 // 02110-1301, USA.
31
32 // This header file defines the class Elf_file which can be used to
33 // read useful data from an ELF file. The functions here are all
34 // templates which take a file interface object as a parameter. This
35 // type must have a subtype View. This type must support two methods:
36 // View view(off_t file_offset, off_t data_size)
37 // returns a View for the specified part of the file.
38 // void error(const char* printf_format, ...)
39 // prints an error message and does not return. The subtype View must
40 // support a method
41 // const unsigned char* data()
42 // which returns a pointer to a buffer containing the requested data.
43 // This general interface is used to read data from the file. Objects
44 // of type View will never survive longer than the elfcpp function.
45
46 // Some of these functions must return a reference to part of the
47 // file. To use these, the file interface must support a subtype
48 // Location:
49 // Location(off_t file_offset, off_t data_size)
50 // To use this in conjunction with the accessors types Shdr, etc., the
51 // file interface should support an overload of view:
52 // View view(Location)
53 // This permits writing
54 // elfcpp::Shdr shdr(file, ef.section_header(n));
55
56 #ifndef ELFCPP_FILE_H
57 #define ELFCPP_FILE_H
58
59 #include <string>
60 #include <cstdio>
61 #include <cstring>
62
63 #include "elfcpp.h"
64
65 namespace elfcpp
66 {
67
68 // A simple helper class to recognize if a file has an ELF header.
69
70 class Elf_recognizer
71 {
72 public:
73 // Maximum header size. The user should try to read this much of
74 // the file when using this class.
75
76 static const int max_header_size = Elf_sizes<64>::ehdr_size;
77
78 // Checks if the file contains the ELF magic. Other header fields
79 // are not checked.
80
81 static bool
82 is_elf_file(const unsigned char* ehdr_buf, int size);
83
84 // Check if EHDR_BUF/BUFSIZE is a valid header of a 32-bit or
85 // 64-bit, little-endian or big-endian ELF file. Assumes
86 // is_elf_file() has been checked to be true. If the header is not
87 // valid, *ERROR contains a human-readable error message. If is is,
88 // *SIZE is set to either 32 or 64, *BIG_ENDIAN is set to indicate
89 // whether the file is big-endian.
90
91 static bool
92 is_valid_header(const unsigned char* ehdr_buf, off_t bufsize,
93 int* size, bool* big_endian,
94 std::string* error);
95 };
96
97 // This object is used to read an ELF file.
98 // SIZE: The size of file, 32 or 64.
99 // BIG_ENDIAN: Whether the file is in big-endian format.
100 // FILE: A file reading type as described above.
101
102 template<int size, bool big_endian, typename File>
103 class Elf_file
104 {
105 private:
106 typedef Elf_file<size, big_endian, File> This;
107
108 public:
109 static const int ehdr_size = Elf_sizes<size>::ehdr_size;
110 static const int phdr_size = Elf_sizes<size>::phdr_size;
111 static const int shdr_size = Elf_sizes<size>::shdr_size;
112 static const int sym_size = Elf_sizes<size>::sym_size;
113 static const int rel_size = Elf_sizes<size>::rel_size;
114 static const int rela_size = Elf_sizes<size>::rela_size;
115
116 typedef Ehdr<size, big_endian> Ef_ehdr;
117 typedef Phdr<size, big_endian> Ef_phdr;
118 typedef Shdr<size, big_endian> Ef_shdr;
119 typedef Sym<size, big_endian> Ef_sym;
120
121 // Construct an Elf_file given an ELF file header.
122 Elf_file(File* file, const Ef_ehdr& ehdr)
123 { this->construct(file, ehdr); }
124
125 // Construct an ELF file.
126 inline
127 Elf_file(File* file);
128
129 // Return the file offset to the section headers.
130 off_t
131 shoff() const
132 { return this->shoff_; }
133
134 // Find the first section with an sh_type field equal to TYPE and
135 // return its index. Returns SHN_UNDEF if there is no such section.
136 unsigned int
137 find_section_by_type(unsigned int type);
138
139 // Return the number of sections.
140 unsigned int
141 shnum()
142 {
143 this->initialize_shnum();
144 return this->shnum_;
145 }
146
147 unsigned int
148 shnum() const
149 {
150 if (this->shnum_ == 0 && this->shoff_ != 0)
151 this->file_->error(_("ELF file has not been initialized yet"
152 " (internal error)"));
153 return this->shnum_;
154 }
155
156 // Return the section index of the section name string table.
157 unsigned int
158 shstrndx()
159 {
160 this->initialize_shnum();
161 return this->shstrndx_;
162 }
163
164 unsigned int
165 shstrndx() const
166 {
167 if (this->shstrndx_ == SHN_XINDEX && this->shoff_ != 0)
168 {
169 this->file_->error(_("ELF file has not been initialized yet"
170 " (internal error)"));
171 return 0;
172 }
173 return this->shstrndx_;
174 }
175
176 // Return the value to subtract from section indexes >=
177 // SHN_LORESERVE. See the comment in initialize_shnum.
178 int
179 large_shndx_offset()
180 {
181 this->initialize_shnum();
182 return this->large_shndx_offset_;
183 }
184
185 int
186 large_shndx_offset() const
187 {
188 if (this->shstrndx_ == SHN_XINDEX && this->shoff_ != 0)
189 this->file_->error(_("ELF file has not been initialized yet"
190 " (internal error)"));
191 return this->large_shndx_offset_;
192 }
193
194 // Return the location of the header of section SHNDX.
195 typename File::Location
196 section_header(unsigned int shndx)
197 {
198 return typename File::Location(this->section_header_offset(shndx),
199 shdr_size);
200 }
201
202 // Return the name of section SHNDX.
203 std::string
204 section_name(unsigned int shndx) const;
205
206 // Return the location of the contents of section SHNDX.
207 typename File::Location
208 section_contents(unsigned int shndx);
209
210 // Return the size of section SHNDX.
211 typename Elf_types<size>::Elf_WXword
212 section_size(unsigned int shndx);
213
214 // Return the flags of section SHNDX.
215 typename Elf_types<size>::Elf_WXword
216 section_flags(unsigned int shndx);
217
218 // Return the address of section SHNDX.
219 typename Elf_types<size>::Elf_Addr
220 section_addr(unsigned int shndx);
221
222 // Return the type of section SHNDX.
223 Elf_Word
224 section_type(unsigned int shndx);
225
226 // Return the link field of section SHNDX.
227 Elf_Word
228 section_link(unsigned int shndx);
229
230 // Return the info field of section SHNDX.
231 Elf_Word
232 section_info(unsigned int shndx);
233
234 // Return the addralign field of section SHNDX.
235 typename Elf_types<size>::Elf_WXword
236 section_addralign(unsigned int shndx);
237
238 private:
239 // Shared constructor code.
240 void
241 construct(File* file, const Ef_ehdr& ehdr);
242
243 // Initialize shnum_ and shstrndx_.
244 void
245 initialize_shnum();
246
247 // Return the file offset of the header of section SHNDX.
248 off_t
249 section_header_offset(unsigned int shndx) const;
250
251 // The file we are reading.
252 File* file_;
253 // The file offset to the section headers.
254 off_t shoff_;
255 // The number of sections.
256 unsigned int shnum_;
257 // The section index of the section name string table.
258 unsigned int shstrndx_;
259 // Offset to add to sections larger than SHN_LORESERVE.
260 int large_shndx_offset_;
261 };
262
263 // A small wrapper around SHT_STRTAB data mapped to memory. It checks that the
264 // index is not out of bounds and the string is NULL-terminated.
265
266 class Elf_strtab
267 {
268 public:
269 // Construct an Elf_strtab for a section with contents *P and size SIZE.
270 Elf_strtab(const unsigned char* p, size_t size);
271
272 // Return the file offset to the section headers.
273 bool
274 get_c_string(size_t offset, const char** cstring) const
275 {
276 if (offset >= this->usable_size_)
277 return false;
278 *cstring = this->base_ + offset;
279 return true;
280 }
281
282 private:
283 // Contents of the section mapped to memory.
284 const char* base_;
285 // One larger that the position of the last NULL character in the section.
286 // For valid SHT_STRTAB sections, this is the size of the section.
287 size_t usable_size_;
288 };
289
290 // Inline function definitions.
291
292 // Check for presence of the ELF magic number.
293
294 inline bool
295 Elf_recognizer::is_elf_file(const unsigned char* ehdr_buf, int size)
296 {
297 if (size < 4)
298 return false;
299
300 static unsigned char elfmagic[4] =
301 {
302 elfcpp::ELFMAG0, elfcpp::ELFMAG1,
303 elfcpp::ELFMAG2, elfcpp::ELFMAG3
304 };
305 return memcmp(ehdr_buf, elfmagic, 4) == 0;
306 }
307
308 namespace
309 {
310
311 // Print a number to a string.
312
313 inline std::string
314 internal_printf_int(const char* format, int arg)
315 {
316 char buf[256];
317 snprintf(buf, sizeof(buf), format, arg);
318 return std::string(buf);
319 }
320
321 } // End anonymous namespace.
322
323 // Check the validity of the ELF header.
324
325 inline bool
326 Elf_recognizer::is_valid_header(
327 const unsigned char* ehdr_buf,
328 off_t bufsize,
329 int* size,
330 bool* big_endian,
331 std::string* error)
332 {
333 if (bufsize < elfcpp::EI_NIDENT)
334 {
335 *error = _("ELF file too short");
336 return false;
337 }
338
339 int v = ehdr_buf[elfcpp::EI_VERSION];
340 if (v != elfcpp::EV_CURRENT)
341 {
342 if (v == elfcpp::EV_NONE)
343 *error = _("invalid ELF version 0");
344 else
345 *error = internal_printf_int(_("unsupported ELF version %d"), v);
346 return false;
347 }
348
349 int c = ehdr_buf[elfcpp::EI_CLASS];
350 if (c == elfcpp::ELFCLASSNONE)
351 {
352 *error = _("invalid ELF class 0");
353 return false;
354 }
355 else if (c != elfcpp::ELFCLASS32
356 && c != elfcpp::ELFCLASS64)
357 {
358 *error = internal_printf_int(_("unsupported ELF class %d"), c);
359 return false;
360 }
361
362 int d = ehdr_buf[elfcpp::EI_DATA];
363 if (d == elfcpp::ELFDATANONE)
364 {
365 *error = _("invalid ELF data encoding");
366 return false;
367 }
368 else if (d != elfcpp::ELFDATA2LSB
369 && d != elfcpp::ELFDATA2MSB)
370 {
371 *error = internal_printf_int(_("unsupported ELF data encoding %d"), d);
372 return false;
373 }
374
375 *big_endian = (d == elfcpp::ELFDATA2MSB);
376
377 if (c == elfcpp::ELFCLASS32)
378 {
379 if (bufsize < elfcpp::Elf_sizes<32>::ehdr_size)
380 {
381 *error = _("ELF file too short");
382 return false;
383 }
384 *size = 32;
385 }
386 else
387 {
388 if (bufsize < elfcpp::Elf_sizes<64>::ehdr_size)
389 {
390 *error = _("ELF file too short");
391 return false;
392 }
393 *size = 64;
394 }
395
396 return true;
397 }
398
399 // Template function definitions.
400
401 // Construct an Elf_file given an ELF file header.
402
403 template<int size, bool big_endian, typename File>
404 void
405 Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr)
406 {
407 this->file_ = file;
408 this->shoff_ = ehdr.get_e_shoff();
409 this->shnum_ = ehdr.get_e_shnum();
410 this->shstrndx_ = ehdr.get_e_shstrndx();
411 this->large_shndx_offset_ = 0;
412 if (ehdr.get_e_ehsize() != This::ehdr_size)
413 file->error(_("bad e_ehsize (%d != %d)"),
414 ehdr.get_e_ehsize(), This::ehdr_size);
415 if (ehdr.get_e_shentsize() != This::shdr_size)
416 file->error(_("bad e_shentsize (%d != %d)"),
417 ehdr.get_e_shentsize(), This::shdr_size);
418 }
419
420 // Construct an ELF file.
421
422 template<int size, bool big_endian, typename File>
423 inline
424 Elf_file<size, big_endian, File>::Elf_file(File* file)
425 {
426 typename File::View v(file->view(file_header_offset, This::ehdr_size));
427 this->construct(file, Ef_ehdr(v.data()));
428 }
429
430 // Initialize the shnum_ and shstrndx_ fields, handling overflow.
431
432 template<int size, bool big_endian, typename File>
433 void
434 Elf_file<size, big_endian, File>::initialize_shnum()
435 {
436 if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX)
437 && this->shoff_ != 0)
438 {
439 typename File::View v(this->file_->view(this->shoff_, This::shdr_size));
440 Ef_shdr shdr(v.data());
441
442 if (this->shnum_ == 0)
443 this->shnum_ = shdr.get_sh_size();
444
445 if (this->shstrndx_ == SHN_XINDEX)
446 {
447 this->shstrndx_ = shdr.get_sh_link();
448
449 // Versions of the GNU binutils between 2.12 and 2.18 did
450 // not handle objects with more than SHN_LORESERVE sections
451 // correctly. All large section indexes were offset by
452 // 0x100. Some information can be found here:
453 // http://sourceware.org/bugzilla/show_bug.cgi?id=5900 .
454 // Fortunately these object files are easy to detect, as the
455 // GNU binutils always put the section header string table
456 // near the end of the list of sections. Thus if the
457 // section header string table index is larger than the
458 // number of sections, then we know we have to subtract
459 // 0x100 to get the real section index.
460 if (this->shstrndx_ >= this->shnum_)
461 {
462 if (this->shstrndx_ >= elfcpp::SHN_LORESERVE + 0x100)
463 {
464 this->large_shndx_offset_ = - 0x100;
465 this->shstrndx_ -= 0x100;
466 }
467 if (this->shstrndx_ >= this->shnum_)
468 this->file_->error(_("bad shstrndx: %u >= %u"),
469 this->shstrndx_, this->shnum_);
470 }
471 }
472 }
473 }
474
475 // Find section with sh_type equal to TYPE and return its index.
476 // Returns SHN_UNDEF if not found.
477
478 template<int size, bool big_endian, typename File>
479 unsigned int
480 Elf_file<size, big_endian, File>::find_section_by_type(unsigned int type)
481 {
482 unsigned int shnum = this->shnum();
483 typename File::View v(this->file_->view(this->shoff_,
484 This::shdr_size * shnum));
485 for (unsigned int i = 0; i < shnum; i++)
486 {
487 Ef_shdr shdr(v.data() + This::shdr_size * i);
488 if (shdr.get_sh_type() == type)
489 return i;
490 }
491 return SHN_UNDEF;
492 }
493
494 // Return the file offset of the section header of section SHNDX.
495
496 template<int size, bool big_endian, typename File>
497 off_t
498 Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx) const
499 {
500 if (shndx >= this->shnum())
501 this->file_->error(_("section_header_offset: bad shndx %u >= %u"),
502 shndx, this->shnum());
503 return this->shoff_ + This::shdr_size * shndx;
504 }
505
506 // Return the name of section SHNDX.
507
508 template<int size, bool big_endian, typename File>
509 std::string
510 Elf_file<size, big_endian, File>::section_name(unsigned int shndx) const
511 {
512 File* const file = this->file_;
513
514 // Get the section name offset.
515 unsigned int sh_name;
516 {
517 typename File::View v(file->view(this->section_header_offset(shndx),
518 This::shdr_size));
519 Ef_shdr shdr(v.data());
520 sh_name = shdr.get_sh_name();
521 }
522
523 // Get the file offset for the section name string table data.
524 off_t shstr_off;
525 typename Elf_types<size>::Elf_WXword shstr_size;
526 {
527 const unsigned int shstrndx = this->shstrndx_;
528 typename File::View v(file->view(this->section_header_offset(shstrndx),
529 This::shdr_size));
530 Ef_shdr shstr_shdr(v.data());
531 shstr_off = shstr_shdr.get_sh_offset();
532 shstr_size = shstr_shdr.get_sh_size();
533 }
534
535 if (sh_name >= shstr_size)
536 file->error(_("bad section name offset for section %u: %u"),
537 shndx, sh_name);
538
539 typename File::View v(file->view(shstr_off, shstr_size));
540
541 const unsigned char* datau = v.data();
542 const char* data = reinterpret_cast<const char*>(datau);
543 const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name);
544 if (p == NULL)
545 file->error(_("missing null terminator for name of section %u"),
546 shndx);
547
548 size_t len = static_cast<const char*>(p) - (data + sh_name);
549
550 return std::string(data + sh_name, len);
551 }
552
553 // Return the contents of section SHNDX.
554
555 template<int size, bool big_endian, typename File>
556 typename File::Location
557 Elf_file<size, big_endian, File>::section_contents(unsigned int shndx)
558 {
559 File* const file = this->file_;
560
561 if (shndx >= this->shnum())
562 file->error(_("section_contents: bad shndx %u >= %u"),
563 shndx, this->shnum());
564
565 typename File::View v(file->view(this->section_header_offset(shndx),
566 This::shdr_size));
567 Ef_shdr shdr(v.data());
568 return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size());
569 }
570
571 // Get the size of section SHNDX.
572
573 template<int size, bool big_endian, typename File>
574 typename Elf_types<size>::Elf_WXword
575 Elf_file<size, big_endian, File>::section_size(unsigned int shndx)
576 {
577 File* const file = this->file_;
578
579 if (shndx >= this->shnum())
580 file->error(_("section_size: bad shndx %u >= %u"),
581 shndx, this->shnum());
582
583 typename File::View v(file->view(this->section_header_offset(shndx),
584 This::shdr_size));
585
586 Ef_shdr shdr(v.data());
587 return shdr.get_sh_size();
588 }
589
590 // Return the section flags of section SHNDX.
591
592 template<int size, bool big_endian, typename File>
593 typename Elf_types<size>::Elf_WXword
594 Elf_file<size, big_endian, File>::section_flags(unsigned int shndx)
595 {
596 File* const file = this->file_;
597
598 if (shndx >= this->shnum())
599 file->error(_("section_flags: bad shndx %u >= %u"),
600 shndx, this->shnum());
601
602 typename File::View v(file->view(this->section_header_offset(shndx),
603 This::shdr_size));
604
605 Ef_shdr shdr(v.data());
606 return shdr.get_sh_flags();
607 }
608
609 // Return the address of section SHNDX.
610
611 template<int size, bool big_endian, typename File>
612 typename Elf_types<size>::Elf_Addr
613 Elf_file<size, big_endian, File>::section_addr(unsigned int shndx)
614 {
615 File* const file = this->file_;
616
617 if (shndx >= this->shnum())
618 file->error(_("section_flags: bad shndx %u >= %u"),
619 shndx, this->shnum());
620
621 typename File::View v(file->view(this->section_header_offset(shndx),
622 This::shdr_size));
623
624 Ef_shdr shdr(v.data());
625 return shdr.get_sh_addr();
626 }
627
628 // Return the type of section SHNDX.
629
630 template<int size, bool big_endian, typename File>
631 Elf_Word
632 Elf_file<size, big_endian, File>::section_type(unsigned int shndx)
633 {
634 File* const file = this->file_;
635
636 if (shndx >= this->shnum())
637 file->error(_("section_type: bad shndx %u >= %u"),
638 shndx, this->shnum());
639
640 typename File::View v(file->view(this->section_header_offset(shndx),
641 This::shdr_size));
642
643 Ef_shdr shdr(v.data());
644 return shdr.get_sh_type();
645 }
646
647 // Return the sh_link field of section SHNDX.
648
649 template<int size, bool big_endian, typename File>
650 Elf_Word
651 Elf_file<size, big_endian, File>::section_link(unsigned int shndx)
652 {
653 File* const file = this->file_;
654
655 if (shndx >= this->shnum())
656 file->error(_("section_link: bad shndx %u >= %u"),
657 shndx, this->shnum());
658
659 typename File::View v(file->view(this->section_header_offset(shndx),
660 This::shdr_size));
661
662 Ef_shdr shdr(v.data());
663 return shdr.get_sh_link();
664 }
665
666 // Return the sh_info field of section SHNDX.
667
668 template<int size, bool big_endian, typename File>
669 Elf_Word
670 Elf_file<size, big_endian, File>::section_info(unsigned int shndx)
671 {
672 File* const file = this->file_;
673
674 if (shndx >= this->shnum())
675 file->error(_("section_info: bad shndx %u >= %u"),
676 shndx, this->shnum());
677
678 typename File::View v(file->view(this->section_header_offset(shndx),
679 This::shdr_size));
680
681 Ef_shdr shdr(v.data());
682 return shdr.get_sh_info();
683 }
684
685 // Return the sh_addralign field of section SHNDX.
686
687 template<int size, bool big_endian, typename File>
688 typename Elf_types<size>::Elf_WXword
689 Elf_file<size, big_endian, File>::section_addralign(unsigned int shndx)
690 {
691 File* const file = this->file_;
692
693 if (shndx >= this->shnum())
694 file->error(_("section_addralign: bad shndx %u >= %u"),
695 shndx, this->shnum());
696
697 typename File::View v(file->view(this->section_header_offset(shndx),
698 This::shdr_size));
699
700 Ef_shdr shdr(v.data());
701 return shdr.get_sh_addralign();
702 }
703
704 inline
705 Elf_strtab::Elf_strtab(const unsigned char* p, size_t size)
706 {
707 // Check if the section is NUL-terminated. If it isn't, we ignore
708 // the last part to make sure we don't return non-NUL-terminated
709 // strings.
710 while (size > 0 && p[size - 1] != 0)
711 size--;
712 this->base_ = reinterpret_cast<const char*>(p);
713 this->usable_size_ = size;
714 }
715
716 } // End namespace elfcpp.
717
718 #endif // !defined(ELFCPP_FILE_H)