theo::recomp::recomp_t Class Reference

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

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.

    : 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.

                        {
  // 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));
      }
    }
  });
}

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.

                                          {
  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.

                                   {
  m_copier = copy;
}

copy_syms()

void theo::recomp::recomp_t::copy_syms

(

)

when called, this function copies symbols into allocations.

                         {
  // 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());
  });
}

resolve() [1/2]

void theo::recomp::recomp_t::resolve

(

)

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

                       {
  // 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;
      }
    });
  });
}

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.

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

resolver()

void theo::recomp::recomp_t::resolver

(

resolver_t

resolve

)

setter for the resolve lambda function.

Parameters

resolve

lambda function to resolve external symbols.

                                          {
  m_resolver = resolve;
}

---

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

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