ELF/Header.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2024 R. Thomas
 * Copyright 2017 - 2024 Quarkslab
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef LIEF_ELF_HEADER_H
#define LIEF_ELF_HEADER_H
 
#include <ostream>
#include <array>
#include <vector>
#include <set>
 
#include "LIEF/Object.hpp"
#include "LIEF/visibility.h"
#include "LIEF/Abstract/enums.hpp"
 
#include "LIEF/ELF/enums.hpp"
#include "LIEF/ELF/ProcessorFlags.hpp"
 
namespace LIEF {
namespace ELF {
class Parser;
 
class LIEF_API Header : public Object {
  friend class Parser;
  public:
  using identity_t = std::array<uint8_t, 16>;
  using abstract_architecture_t = std::pair<ARCHITECTURES, std::set<MODES>>;
 
  public:
  enum {
    EI_MAG0       = 0,  
    EI_MAG1       = 1,  
    EI_MAG2       = 2,  
    EI_MAG3       = 3,  
    EI_CLASS      = 4,  
    EI_DATA       = 5,  
    EI_VERSION    = 6,  
    EI_OSABI      = 7,  
    EI_ABIVERSION = 8,  
    EI_PAD        = 9,  
    EI_NIDENT     = 16  
  };
 
  enum class FILE_TYPE {
    NONE = 0, 
    REL  = 1, 
    EXEC = 2, 
    DYN  = 3, 
    CORE = 4, 
  };
 
  enum class VERSION {
    NONE    = 0, 
    CURRENT = 1, 
  };
 
  enum class CLASS {
    NONE = 0, 
    ELF32,    
    ELF64,    
  };
 
  enum class OS_ABI {
    SYSTEMV      = 0,  
    HPUX         = 1,  
    NETBSD       = 2,  
    GNU          = 3,  
    LINUX        = 3,  
    HURD         = 4,  
    SOLARIS      = 6,  
    AIX          = 7,  
    IRIX         = 8,  
    FREEBSD      = 9,  
    TRU64        = 10, 
    MODESTO      = 11, 
    OPENBSD      = 12, 
    OPENVMS      = 13, 
    NSK          = 14, 
    AROS         = 15, 
    FENIXOS      = 16, 
    CLOUDABI     = 17, 
    C6000_ELFABI = 64, 
    AMDGPU_HSA   = 64, 
    C6000_LINUX  = 65, 
    ARM          = 97, 
    STANDALONE   = 255 
  };
 
  enum class ELF_DATA {
    NONE = 0, 
    LSB  = 1, 
    MSB  = 2  
  };
 
  Header() = default;
 
  Header& operator=(const Header&) = default;
  Header(const Header&) = default;
 
  ~Header() override = default;
 
  FILE_TYPE file_type() const {
    return file_type_;
  }
 
  OBJECT_TYPES abstract_object_type() const;
 
  ARCH machine_type() const {
    return machine_type_;
  }
 
  abstract_architecture_t abstract_architecture() const;
 
  ENDIANNESS abstract_endianness() const;
 
  VERSION object_file_version() const {
    return object_file_version_;
  }
 
  uint64_t entrypoint() const {
    return entrypoint_;
  }
 
  uint64_t program_headers_offset() const {
    return program_headers_offset_;
  }
 
  uint64_t section_headers_offset() const {
    return section_headers_offset_;
  }
 
  uint32_t processor_flag() const {
    return processor_flags_;
  }
 
  uint32_t header_size() const {
    return header_size_;
  }
 
  uint32_t program_header_size() const {
    return program_header_size_;
  }
 
  uint32_t numberof_segments() const {
    return numberof_segments_;
  }
 
  uint32_t section_header_size() const {
    return section_header_size_;
  }
 
  uint32_t numberof_sections() const {
    return numberof_sections_;
  }
 
  uint32_t section_name_table_idx() const {
    return section_string_table_idx_;
  }
 
  identity_t& identity() {
    return identity_;
  }
 
  const identity_t& identity() const {
    return identity_;
  }
 
  CLASS identity_class() const {
    return CLASS(identity_[EI_CLASS]);
  }
 
  ELF_DATA identity_data() const {
    return ELF_DATA(identity_[EI_DATA]);
  }
 
  VERSION identity_version() const {
    return VERSION(identity_[EI_VERSION]);
  }
 
  OS_ABI identity_os_abi() const {
    return OS_ABI(identity_[EI_OSABI]);
  }
 
  uint32_t identity_abi_version() const {
    return identity_[EI_ABIVERSION];
  }
 
  bool has(PROCESSOR_FLAGS flag) const;
 
  std::vector<PROCESSOR_FLAGS> flags_list() const;
 
  void file_type(FILE_TYPE type) {
    file_type_ = type;
  }
 
  void machine_type(ARCH arch) {
    machine_type_ = arch;
  }
 
  void object_file_version(VERSION version) {
    object_file_version_ = version;
  }
 
  void entrypoint(uint64_t entry) {
    entrypoint_ = entry;
  }
 
  void program_headers_offset(uint64_t offset) {
    program_headers_offset_ = offset;
  }
 
  void section_headers_offset(uint64_t offset) {
    section_headers_offset_ = offset;
  }
 
  void processor_flag(uint32_t flags) {
    processor_flags_ = flags;
  }
 
  void header_size(uint32_t size) {
    header_size_ = size;
  }
 
  void program_header_size(uint32_t size) {
    program_header_size_ = size;
  }
 
  void numberof_segments(uint32_t n) {
    numberof_segments_ = n;
  }
  void section_header_size(uint32_t size) {
    section_header_size_ = size;
  }
 
  void numberof_sections(uint32_t n) {
    numberof_sections_ = n;
  }
  void section_name_table_idx(uint32_t idx) {
    section_string_table_idx_ = idx;
  }
 
  void identity(const std::string& identity);
  void identity(const identity_t& identity);
 
  void identity_class(CLASS cls) {
    identity_[EI_CLASS] = static_cast<uint8_t>(cls);
  }
 
  void identity_data(ELF_DATA data) {
    identity_[EI_DATA] = static_cast<uint8_t>(data);
  }
 
  void identity_version(VERSION version) {
    identity_[EI_VERSION] = static_cast<uint8_t>(version);
  }
 
  void identity_os_abi(OS_ABI osabi) {
    identity_[EI_OSABI] = static_cast<uint8_t>(osabi);
  }
 
  void identity_abi_version(uint8_t version) {
    identity_[EI_ABIVERSION] = version;
  }
 
  void accept(Visitor& visitor) const override;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os, const Header& hdr);
 
  private:
  template<class T>
  LIEF_LOCAL Header(const T& header);
 
  identity_t identity_;
  FILE_TYPE file_type_ = FILE_TYPE::NONE;
  ARCH machine_type_ = ARCH::NONE;
  VERSION object_file_version_ = VERSION::NONE;
  uint64_t entrypoint_ = 0;
  uint64_t program_headers_offset_ = 0;
  uint64_t section_headers_offset_ = 0;
  uint32_t processor_flags_ = 0;
  uint32_t header_size_ = 0;
  uint32_t program_header_size_ = 0;
  uint32_t numberof_segments_ = 0;
  uint32_t section_header_size_ = 0;
  uint32_t numberof_sections_ = 0;
  uint32_t section_string_table_idx_ = 0;
};
 
LIEF_API const char* to_string(Header::FILE_TYPE type);
LIEF_API const char* to_string(Header::VERSION version);
LIEF_API const char* to_string(Header::CLASS version);
LIEF_API const char* to_string(Header::OS_ABI abi);
LIEF_API const char* to_string(Header::ELF_DATA abi);
 
}
}
#endif