Abstract/Binary.hpp

/* 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_ABSTRACT_BINARY_H
#define LIEF_ABSTRACT_BINARY_H
 
#include <vector>
 
#include "LIEF/types.hpp"
#include "LIEF/visibility.h"
#include "LIEF/Object.hpp"
#include "LIEF/iterators.hpp"
#include "LIEF/errors.hpp"
#include "LIEF/span.hpp"
 
#include "LIEF/Abstract/Header.hpp"
#include "LIEF/Abstract/Function.hpp"
 
namespace LIEF {
class Section;
class Relocation;
class Symbol;
 
class LIEF_API Binary : public Object {
  public:
 
  enum class VA_TYPES {
    AUTO = 0, 
    RVA  = 1, 
    VA   = 2, 
  };
 
  enum FORMATS {
    UNKNOWN = 0,
    ELF,
    PE,
    MACHO,
    OAT,
  };
 
  using functions_t = std::vector<Function>;
 
  using sections_t = std::vector<Section*>;
 
  using it_sections = ref_iterator<sections_t>;
 
  using it_const_sections = const_ref_iterator<sections_t>;
 
  using symbols_t = std::vector<Symbol*>;
 
  using it_symbols = ref_iterator<symbols_t>;
 
  using it_const_symbols = const_ref_iterator<symbols_t>;
 
  using relocations_t = std::vector<Relocation*>;
 
  using it_relocations = ref_iterator<relocations_t>;
 
  using it_const_relocations = const_ref_iterator<relocations_t>;
 
  public:
  Binary();
  Binary(FORMATS fmt) :
    format_{fmt}
  {}
 
  ~Binary() override;
 
  Binary& operator=(const Binary&);
  Binary(const Binary&);
 
  FORMATS format() const {
    return format_;
  }
 
  Header header() const;
 
  it_symbols symbols();
 
  it_const_symbols  symbols() const;
 
  bool has_symbol(const std::string& name) const;
 
  const Symbol* get_symbol(const std::string& name) const;
 
  Symbol* get_symbol(const std::string& name);
 
  it_sections sections();
  it_const_sections sections() const;
 
  virtual void remove_section(const std::string& name, bool clear = false) = 0;
 
  it_relocations       relocations();
  it_const_relocations relocations() const;
 
  virtual uint64_t entrypoint() const = 0;
 
  uint64_t original_size() const {
    return original_size_;
  }
 
  functions_t exported_functions() const;
 
  std::vector<std::string> imported_libraries() const;
 
  functions_t imported_functions() const;
 
  virtual result<uint64_t> get_function_address(const std::string& func_name) const;
 
  void accept(Visitor& visitor) const override;
 
  std::vector<uint64_t> xref(uint64_t address) const;
 
  virtual void patch_address(uint64_t address, const std::vector<uint8_t>& patch_value,
                             VA_TYPES addr_type = VA_TYPES::AUTO) = 0;
 
  virtual void patch_address(uint64_t address, uint64_t patch_value, size_t size = sizeof(uint64_t),
                             VA_TYPES addr_type = VA_TYPES::AUTO) = 0;
 
  virtual span<const uint8_t>
    get_content_from_virtual_address(uint64_t virtual_address, uint64_t size,
                                     VA_TYPES addr_type = VA_TYPES::AUTO) const = 0;
 
  void original_size(uint64_t size) {
    original_size_ = size;
  }
 
  virtual bool is_pie() const = 0;
 
  virtual bool has_nx() const = 0;
 
  virtual uint64_t imagebase() const = 0;
 
  virtual functions_t ctor_functions() const = 0;
 
  virtual result<uint64_t> offset_to_virtual_address(uint64_t offset, uint64_t slide = 0) const = 0;
 
  virtual std::ostream& print(std::ostream& os) const;
 
  virtual void write(const std::string& name) = 0;
  virtual void write(std::ostream& os) = 0;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os, const Binary& binary);
 
  protected:
  FORMATS format_ = FORMATS::UNKNOWN;
 
  uint64_t original_size_ = 0;
 
  // These functions need to be overloaded by the object that claims to extend this Abstract Binary
  virtual Header get_abstract_header() const = 0;
  virtual symbols_t get_abstract_symbols() = 0;
  virtual sections_t get_abstract_sections() = 0;
  virtual relocations_t get_abstract_relocations() = 0;
 
  virtual functions_t  get_abstract_exported_functions() const = 0;
  virtual functions_t  get_abstract_imported_functions() const = 0;
  virtual std::vector<std::string>  get_abstract_imported_libraries() const = 0;
};
 
LIEF_API const char* to_string(Binary::VA_TYPES e);
LIEF_API const char* to_string(Binary::FORMATS e);
 
}
 
 
#endif