the main class responsible for recomposition More...

#include "recomp.hpp"

Public Member Functions
	recomp_t (decomp::decomp_t *dcmp, allocator_t alloc, copier_t copy, resolver_t resolve)
	the explicit constructor for the recomp_t class. More...

void	allocate ()
	when called, this function allocates space for every symbol. More...

void	resolve ()
	when called, this function resolves all relocations in every symbol. More...

void	copy_syms ()
	when called, this function copies symbols into allocations. More...

void	allocator (allocator_t alloc)
	setter for the allocater lambda function. More...

void	copier (copier_t copy)
	setter for the copier lambda function. More...

void	resolver (resolver_t resolve)
	setter for the resolve lambda function. More...

std::uintptr_t	resolve (const std::string &&sym)
	resolves the address of a function given its name. More...

Detailed Description

the main class responsible for recomposition

Definition at line 64 of file recomp.hpp.

Constructor & Destructor Documentation

◆ recomp_t()

theo::recomp::recomp_t::recomp_t	(	decomp::decomp_t *	dcmp,
		allocator_t	alloc,
		copier_t	copy,
		resolver_t	resolve
	)

explicit

the explicit constructor for the recomp_t class.

Parameters

dcmp	pointer to a decomp_t class.
alloc	lambda function which is used to allocate memory for symbols.
copy	lambda function used to copy bytes into allocations.
resolve	lambda function used to resolve external symbols.

Definition at line 34 of file recomp.cpp.

38 : m_dcmp(dcmp), m_allocator(alloc), m_copier(copy), m_resolver(resolve) {}

Member Function Documentation

◆ allocate()

void theo::recomp::recomp_t::allocate ( )

when called, this function allocates space for every symbol.

Definition at line 40 of file recomp.cpp.

                        {
  // map code & data/rdata/bss sections first...
  //
  m_dcmp->syms()->for_each([&](theo::decomp::symbol_t& sym) {
    switch (sym.type()) {
      case decomp::sym_type_t::section:
      case decomp::sym_type_t::function:
      case decomp::sym_type_t::instruction: {
        sym.allocated_at(m_allocator(sym.size(), sym.scn()->characteristics));
        break;
      }
      default:
        break;
    }
  });
 
  // then map data/rdata/bss symbols to the allocated sections...
  //
  m_dcmp->syms()->for_each([&](theo::decomp::symbol_t& sym) {
    if (sym.type() == decomp::sym_type_t::data) {
      // if the symbol has a section then we will refer to the allocation made
      // for that section...
      //
      if (sym.scn()) {
        auto scn_sym =
            m_dcmp->syms()->sym_from_hash(m_dcmp->scn_hash_tbl()[sym.scn()]);
 
        if (!scn_sym.has_value()) {
          spdlog::error("failed to locate section: {} for symbol: {}",
                        sym.scn()->name.to_string(), sym.name());
 
          assert(scn_sym.has_value());
        }
 
        sym.allocated_at(scn_sym.value()->allocated_at() + sym.offset());
      } else {  // else if there is no section then we allocate based upon the
                // size of the symbol... this is only done for symbols that are
                // bss...
                //
 
        // bss is read write...
        //
        coff::section_characteristics_t prot = {};
        prot.mem_read = true;
        prot.mem_write = true;
 
        sym.allocated_at(m_allocator(sym.size(), sym.scn()->characteristics));
      }
    }
  });
}

References theo::recomp::symbol_table_t::for_each(), theo::decomp::decomp_t::syms(), and theo::decomp::symbol_t::type().

Referenced by theo::theo_t::compose().

◆ allocator()

void theo::recomp::recomp_t::allocator ( allocator_t alloc )

setter for the allocater lambda function.

Parameters

alloc lambda function which allocates memory for symbols.

Definition at line 163 of file recomp.cpp.

                                          {
  m_allocator = alloc;
}

◆ copier()

void theo::recomp::recomp_t::copier ( copier_t copy )

setter for the copier lambda function.

Parameters

copy	copier lambda function used to copy bytes into allocations made by the allocator.

Definition at line 167 of file recomp.cpp.

                                   {
  m_copier = copy;
}

◆ copy_syms()

void theo::recomp::recomp_t::copy_syms ( )

when called, this function copies symbols into allocations.

Definition at line 155 of file recomp.cpp.

                         {
  // copy symbols into memory using the copier supplied...
  //
  m_dcmp->syms()->for_each([&](theo::decomp::symbol_t& sym) {
    m_copier(sym.allocated_at(), sym.data().data(), sym.data().size());
  });
}

References theo::decomp::symbol_t::allocated_at(), and theo::decomp::symbol_t::data().

Referenced by theo::theo_t::compose().

◆ resolve() [1/2]

void theo::recomp::recomp_t::resolve ( )

when called, this function resolves all relocations in every symbol.

Definition at line 92 of file recomp.cpp.

                       {
  // resolve relocations in all symbols...
  //
  m_dcmp->syms()->for_each([&](theo::decomp::symbol_t& sym) {
    auto& relocs = sym.relocs();
    std::for_each(relocs.begin(), relocs.end(), [&](reloc_t& reloc) {
      if (reloc.offset() > sym.data().size()) {
        spdlog::error(
            "invalid relocation... writing outside of symbol length... offset: "
            "{} sym size: {}",
            sym.offset(), sym.data().size());
 
        assert(reloc.offset() > sym.data().size());
      }
 
      // try and resolve the symbol by refering to the internal symbol table
      // first... if there is no symbol then refer to the resolver...
      //
      auto reloc_sym = m_dcmp->syms()->sym_from_hash(reloc.hash());
      auto allocated_at = reloc_sym.has_value()
                              ? reloc_sym.value()->allocated_at()
                              : m_resolver(reloc.name());
 
      if (!allocated_at) {
        spdlog::error("failed to resolve reloc from symbol: {} to symbol: {}",
                      sym.name(), reloc.name());
 
        assert(allocated_at);
      }
 
      switch (sym.type()) {
        case decomp::sym_type_t::section: {
          auto scn_sym =
              m_dcmp->syms()->sym_from_hash(m_dcmp->scn_hash_tbl()[sym.scn()]);
 
          *reinterpret_cast<std::uintptr_t*>(scn_sym.value()->data().data() +
                                             reloc.offset()) = allocated_at;
          break;
        }
        case decomp::sym_type_t::function: {
          *reinterpret_cast<std::uintptr_t*>(sym.data().data() +
                                             reloc.offset()) = allocated_at;
          break;
        }
        case decomp::sym_type_t::instruction: {
          auto& transforms = reloc.get_transforms();
          std::for_each(
              transforms.begin(), transforms.end(),
              [&](std::pair<obf::transform::transform_t*, std::uint32_t>& t) {
                allocated_at = (*t.first)(allocated_at, t.second);
              });
 
          *reinterpret_cast<std::uintptr_t*>(sym.data().data() +
                                             reloc.offset()) = allocated_at;
          break;
        }
        default:
          break;
      }
    });
  });
}

References theo::decomp::symbol_t::data(), theo::decomp::function, theo::recomp::reloc_t::get_transforms(), theo::recomp::reloc_t::hash(), theo::decomp::instruction, theo::recomp::reloc_t::name(), theo::decomp::symbol_t::name(), theo::recomp::reloc_t::offset(), theo::decomp::symbol_t::relocs(), theo::decomp::symbol_t::scn(), theo::decomp::section, and theo::decomp::symbol_t::type().

Referenced by theo::theo_t::compose().

◆ resolve() [2/2]

std::uintptr_t theo::recomp::recomp_t::resolve ( const std::string && sym )

resolves the address of a function given its name.

Parameters

sym	the name of the symbol to resolve the location of.

Returns: the address of the symbol.

Definition at line 175 of file recomp.cpp.

                                                    {
  auto res = m_dcmp->syms()->sym_from_hash(decomp::symbol_t::hash(sym));
  return res.has_value() ? res.value()->allocated_at() : 0;
}

References theo::decomp::symbol_t::hash().

◆ resolver()

void theo::recomp::recomp_t::resolver ( resolver_t resolve )

setter for the resolve lambda function.

Parameters

resolve lambda function to resolve external symbols.

Definition at line 171 of file recomp.cpp.

                                          {
  m_resolver = resolve;
}

The documentation for this class was generated from the following files:

include/recomp/recomp.hpp
src/recomp/recomp.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ recomp_t()

Member Function Documentation

◆ allocate()

◆ allocator()

◆ copier()

◆ copy_syms()

◆ resolve() [1/2]

◆ resolve() [2/2]

◆ resolver()