deps/LIEF/src/PE/Factory.cpp - main - githubmirror/node

deps/LIEF/src/PE/Factory.cpp
132 строки4 KB
Joyee Cheung
deps: add LIEF as a dependency
23 янв 2026, 01:32
23 янв 2026, 01:32d82ae9e
/* Copyright 2017 - 2025 R. Thomas
 * Copyright 2017 - 2025 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.
 */
#include "LIEF/PE/Factory.hpp"
#include "LIEF/PE/Parser.hpp"
#include "LIEF/PE/LoadConfigurations.hpp"
#include "LIEF/PE/TLS.hpp"
#include "LIEF/PE/RichHeader.hpp"
#include "LIEF/PE/ResourceNode.hpp"
#include "LIEF/PE/Export.hpp"
#include "LIEF/PE/Debug.hpp"
#include "LIEF/PE/Relocation.hpp"
#include "LIEF/PE/RelocationEntry.hpp"
#include "LIEF/PE/Section.hpp"

#include "PE/Structures.hpp"

#include <sstream>

namespace LIEF::PE {

Factory::Factory(Factory&&) = default;
Factory& Factory::operator=(Factory&&) = default;

Factory::~Factory() = default;

std::unique_ptr<Factory> Factory::create(PE_TYPE type) {
  auto factory = std::unique_ptr<Factory>(new Factory());
  Binary& pe = *factory->pe_;
  pe.type_ = type;
  pe.dos_header_ = DosHeader::create(type);
  pe.header_ = Header::create(type);
  pe.optional_header_ = OptionalHeader::create(type);

  pe.dos_stub_ = {
    0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c,
    0xcd, 0x21, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,
    0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65,
    0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
    0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x24, 0x00, 0x00
  };

  pe.data_directories_.reserve(DataDirectory::DEFAULT_NB);
  for (size_t i = 0; i < DataDirectory::DEFAULT_NB; ++i) {
    pe.data_directories_.push_back(std::make_unique<DataDirectory>(DataDirectory::TYPES(i)));
  }

  return factory;
}

std::unique_ptr<Binary> Factory::process() {
  update_headers();
  assign_locations();
  move_sections();
  check_overlapping();

  Builder::config_t config;
  std::ostringstream oss;
  pe_->write(oss, config);

  std::string buffer = oss.str();
  return Parser::parse((const uint8_t*)buffer.data(), buffer.size());
}

ok_error_t Factory::assign_locations() {
  uint64_t last_offset = sizeof_headers();
  uint64_t last_rva = section_align();
  for (std::unique_ptr<Section>& section : sections_) {
    last_offset = std::max<uint64_t>(section->offset() + section->size(), last_offset);
    last_rva = std::max<uint64_t>(section->virtual_address() + section->virtual_size(), last_rva);
  }

  last_offset = align(last_offset, file_align());
  last_rva = align(last_offset, section_align());
  for (std::unique_ptr<Section>& section : sections_) {
    if (section->virtual_size() == 0) {
      section->virtual_size(section->sizeof_raw_data());
    }

    if (section->offset() == 0) {
      section->offset(last_offset);
      last_offset = align(last_offset + section->size(), file_align());
    }

    if (section->virtual_address() == 0) {
      section->virtual_address(last_rva);
      last_rva = align(last_rva + section->virtual_size(), section_align());
    }
  }
  return ok();
}

uint32_t Factory::sizeof_headers() const {
  return align(
    pe_->dos_header().addressof_new_exeheader() +
    sizeof(details::pe_header) +
    (is_32bit() ? sizeof(details::pe32_optional_header) :
                  sizeof(details::pe64_optional_header)) +
    sizeof(details::pe_data_directory) * pe_->data_directories_.size() +
    sizeof(details::pe_section) * sections_.size(),
    file_align());
}


ok_error_t Factory::update_headers() {
  pe_->header().numberof_sections(sections_.size());
  return ok();
}


ok_error_t Factory::move_sections() {
  pe_->sections_ = std::move(sections_);
  return ok();
}

ok_error_t Factory::check_overlapping() const {
  // check that no section are overlapping
  return ok();
}
}