Note.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_NOTE_H
#define LIEF_ELF_NOTE_H
 
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/Object.hpp"
#include "LIEF/compiler_attributes.hpp"
#include "LIEF/visibility.h"
#include "LIEF/errors.hpp"
#include "LIEF/span.hpp"
 
#include "LIEF/ELF/Header.hpp"
 
namespace LIEF {
class BinaryStream;
namespace ELF {
class Binary;
class Parser;
class Builder;

class LIEF_API Note : public Object {
  friend class Parser;
  friend class Builder;
  friend class Binary;
 
  public:
  using description_t = std::vector<uint8_t>;

  enum class TYPE {
    UNKNOWN = 0,
    GNU_ABI_TAG,

    GNU_HWCAP,

    GNU_BUILD_ID,

    GNU_GOLD_VERSION,

    GNU_PROPERTY_TYPE_0,
 
    GNU_BUILD_ATTRIBUTE_OPEN,
    GNU_BUILD_ATTRIBUTE_FUNC,

    CRASHPAD,

    CORE_PRSTATUS,
    CORE_FPREGSET,

    CORE_PRPSINFO,
    CORE_TASKSTRUCT,

    CORE_AUXV,
    CORE_PSTATUS,
    CORE_FPREGS,
    CORE_PSINFO,
    CORE_LWPSTATUS,
    CORE_LWPSINFO,
    CORE_WIN32PSTATUS,
    CORE_FILE,
    CORE_PRXFPREG,
    CORE_SIGINFO,
 
    CORE_ARM_VFP,
    CORE_ARM_TLS,
    CORE_ARM_HW_BREAK,
    CORE_ARM_HW_WATCH,
    CORE_ARM_SYSTEM_CALL,
    CORE_ARM_SVE,
    CORE_ARM_PAC_MASK,
    CORE_ARM_PACA_KEYS,
    CORE_ARM_PACG_KEYS,
    CORE_TAGGED_ADDR_CTRL,
    CORE_PAC_ENABLED_KEYS,
 
    CORE_X86_TLS,
    CORE_X86_IOPERM,
    CORE_X86_XSTATE,
    CORE_X86_CET,

    ANDROID_IDENT,
    ANDROID_MEMTAG,
    ANDROID_KUSER,

    GO_BUILDID,

    STAPSDT,

    QNX_STACK,
  };
 
  public:
  static result<TYPE> convert_type(Header::FILE_TYPE ftype, uint32_t type,
                                   const std::string& name);

  static result<const char*> type_to_section(TYPE type);
 
  static result<std::string> note_to_section(const Note& note) {
    const std::string& sec_name = note.section_name();
    if (sec_name.empty()) {
      return type_to_section(note.type());
    }
    return sec_name;
  }

  static result<const char*> type_owner(TYPE type);

  static std::unique_ptr<Note>
      create(const std::string& name, uint32_t type, description_t description,
             std::string section_name,
             Header::FILE_TYPE ftype = Header::FILE_TYPE::NONE,
             ARCH arch = ARCH::NONE, Header::CLASS cls = Header::CLASS::NONE);

  static std::unique_ptr<Note> create(const std::string& name, TYPE type,
                                      description_t description,
                                      std::string section_name,
                                      ARCH arch = ARCH::NONE,
                                      Header::CLASS cls = Header::CLASS::NONE);

  static std::unique_ptr<Note>
      create(BinaryStream& stream, std::string section_name,
             Header::FILE_TYPE ftype = Header::FILE_TYPE::NONE,
             ARCH arch = ARCH::NONE, Header::CLASS cls = Header::CLASS::NONE);
 
  Note& operator=(const Note& copy) = default;
  Note(const Note& copy) = default;
 
  ~Note() override = default;

  virtual std::unique_ptr<Note> clone() const {
    return std::unique_ptr<Note>(new Note(*this));
  }

  const std::string& name() const {
    return name_;
  }

  const std::string& section_name() const {
    return section_name_;
  }

  TYPE type() const {
    return type_;
  }

  uint32_t original_type() const {
    return original_type_;
  }

  span<const uint8_t> description() const LIEF_LIFETIMEBOUND {
    return description_;
  }
 
  span<uint8_t> description() LIEF_LIFETIMEBOUND {
    return description_;
  }
 
  void name(std::string name) {
    name_ = std::move(name);
  }

  void description(description_t description) {
    description_ = std::move(description);
  }

  uint64_t size() const;
 
  virtual void dump(std::ostream& os) const;
 
  void accept(Visitor& visitor) const override;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os, const Note& note) {
    note.dump(os);
    return os;
  }
 
  template<class T>
  const T* cast() const {
    static_assert(std::is_base_of<Note, T>::value, "Require Note inheritance");
    if (T::classof(this)) {
      return static_cast<const T*>(this);
    }
    return nullptr;
  }
 
  template<class T>
  T* cast() {
    return const_cast<T*>(static_cast<const Note*>(this)->cast<T>());
  }
 
  protected:
  Note() = default;
  Note(std::string name, TYPE type, uint32_t original_type,
       description_t description, std::string section) :
    name_(std::move(name)),
    type_(type),
    original_type_(original_type),
    description_(std::move(description)),
    section_name_(std::move(section)) {}
 
  template<class T>
  LIEF_LOCAL result<T> read_at(size_t offset) const;
 
  template<class T>
  LIEF_LOCAL ok_error_t write_at(size_t offset, const T& value);
 
  LIEF_LOCAL ok_error_t write_string_at(size_t offset, const std::string& value);
 
  LIEF_LOCAL result<std::string> read_string_at(size_t offset,
                                                size_t maxsize = 0) const;
 
  std::string name_;
  TYPE type_ = TYPE::UNKNOWN;
  uint32_t original_type_ = 0;
  description_t description_;
  std::string section_name_;
};
 
LIEF_API const char* to_string(Note::TYPE type);
 
 
} // namespace ELF
} // namespace LIEF
#endif