ELF/Header.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 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 <string_view>
#include <array>
#include <ostream>
#include <vector>
 
#include "LIEF/Object.hpp"
#include "LIEF/visibility.h"
 
#include "LIEF/ELF/ProcessorFlags.hpp"
#include "LIEF/ELF/enums.hpp"
 
 
namespace LIEF::ELF {
class Parser;

class LIEF_API Header : public Object {
  friend class Parser;
 
  public:
  using identity_t = std::array<uint8_t, 16>;
 
  public:
  enum ELF_INDENT {
    ELI_MAG0 = 0,       
    ELI_MAG1 = 1,       
    ELI_MAG2 = 2,       
    ELI_MAG3 = 3,       
    ELI_CLASS = 4,      
    ELI_DATA = 5,       
    ELI_VERSION = 6,    
    ELI_OSABI = 7,      
    ELI_ABIVERSION = 8, 
    ELI_PAD = 9,        
    ELI_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_;
  }

  ARCH machine_type() const {
    return machine_type_;
  }

  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_[ELI_CLASS]);
  }

  ELF_DATA identity_data() const {
    return ELF_DATA(identity_[ELI_DATA]);
  }

  VERSION identity_version() const {
    return VERSION(identity_[ELI_VERSION]);
  }

  OS_ABI identity_os_abi() const {
    return OS_ABI(identity_[ELI_OSABI]);
  }

  uint32_t identity_abi_version() const {
    return identity_[ELI_ABIVERSION];
  }

  bool is_mips_n64() const {
    return machine_type() == ARCH::MIPS && identity_class() == CLASS::ELF64;
  }
 
  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(std::string_view identity);
  void identity(const identity_t& identity);
 
  void identity_class(CLASS cls) {
    identity_[ELI_CLASS] = static_cast<uint8_t>(cls);
  }
 
  void identity_data(ELF_DATA data) {
    identity_[ELI_DATA] = static_cast<uint8_t>(data);
  }
 
  void identity_version(VERSION version) {
    identity_[ELI_VERSION] = static_cast<uint8_t>(version);
  }
 
  void identity_os_abi(OS_ABI osabi) {
    identity_[ELI_OSABI] = static_cast<uint8_t>(osabi);
  }
 
  void identity_abi_version(uint8_t version) {
    identity_[ELI_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