727 lines
25 KiB
C++
727 lines
25 KiB
C++
/*************************************************************************/
|
|
/* Copyright (c) 2015 dx, http://kaimi.ru */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person */
|
|
/* obtaining a copy of this software and associated documentation */
|
|
/* files (the "Software"), to deal in the Software without */
|
|
/* restriction, including without limitation the rights to use, */
|
|
/* copy, modify, merge, publish, distribute, sublicense, and/or */
|
|
/* sell copies of the Software, and to permit persons to whom the */
|
|
/* Software is furnished to do so, subject to the following conditions: */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include <algorithm>
|
|
#include <string.h>
|
|
#include "pe_resources.h"
|
|
|
|
namespace pe_bliss
|
|
{
|
|
using namespace pe_win;
|
|
|
|
//RESOURCES
|
|
//Default constructor
|
|
resource_data_entry::resource_data_entry()
|
|
:codepage_(0)
|
|
{}
|
|
|
|
//Constructor from data
|
|
resource_data_entry::resource_data_entry(const std::string& data, uint32_t codepage)
|
|
:codepage_(codepage), data_(data)
|
|
{}
|
|
|
|
//Returns resource data codepage
|
|
uint32_t resource_data_entry::get_codepage() const
|
|
{
|
|
return codepage_;
|
|
}
|
|
|
|
//Returns resource data
|
|
const std::string& resource_data_entry::get_data() const
|
|
{
|
|
return data_;
|
|
}
|
|
|
|
//Sets resource data codepage
|
|
void resource_data_entry::set_codepage(uint32_t codepage)
|
|
{
|
|
codepage_ = codepage;
|
|
}
|
|
|
|
//Sets resource data
|
|
void resource_data_entry::set_data(const std::string& data)
|
|
{
|
|
data_ = data;
|
|
}
|
|
|
|
//Default constructor
|
|
resource_directory_entry::includes::includes()
|
|
:data_(0)
|
|
{}
|
|
|
|
//Default constructor
|
|
resource_directory_entry::resource_directory_entry()
|
|
:id_(0), includes_data_(false), named_(false)
|
|
{}
|
|
|
|
//Copy constructor
|
|
resource_directory_entry::resource_directory_entry(const resource_directory_entry& other)
|
|
:id_(other.id_), name_(other.name_), includes_data_(other.includes_data_), named_(other.named_)
|
|
{
|
|
//If union'ed pointer is not zero
|
|
if(other.ptr_.data_)
|
|
{
|
|
if(other.includes_data())
|
|
ptr_.data_ = new resource_data_entry(*other.ptr_.data_);
|
|
else
|
|
ptr_.dir_ = new resource_directory(*other.ptr_.dir_);
|
|
}
|
|
}
|
|
|
|
//Copy assignment operator
|
|
resource_directory_entry& resource_directory_entry::operator=(const resource_directory_entry& other)
|
|
{
|
|
release();
|
|
|
|
id_ = other.id_;
|
|
name_ = other.name_;
|
|
includes_data_ = other.includes_data_;
|
|
named_ = other.named_;
|
|
|
|
//If other union'ed pointer is not zero
|
|
if(other.ptr_.data_)
|
|
{
|
|
if(other.includes_data())
|
|
ptr_.data_ = new resource_data_entry(*other.ptr_.data_);
|
|
else
|
|
ptr_.dir_ = new resource_directory(*other.ptr_.dir_);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
//Destroys included data
|
|
void resource_directory_entry::release()
|
|
{
|
|
//If union'ed pointer is not zero
|
|
if(ptr_.data_)
|
|
{
|
|
if(includes_data())
|
|
delete ptr_.data_;
|
|
else
|
|
delete ptr_.dir_;
|
|
|
|
ptr_.data_ = 0;
|
|
}
|
|
}
|
|
|
|
//Destructor
|
|
resource_directory_entry::~resource_directory_entry()
|
|
{
|
|
release();
|
|
}
|
|
|
|
//Returns entry ID
|
|
uint32_t resource_directory_entry::get_id() const
|
|
{
|
|
return id_;
|
|
}
|
|
|
|
//Returns entry name
|
|
const std::wstring& resource_directory_entry::get_name() const
|
|
{
|
|
return name_;
|
|
}
|
|
|
|
//Returns true, if entry has name
|
|
//Returns false, if entry has ID
|
|
bool resource_directory_entry::is_named() const
|
|
{
|
|
return named_;
|
|
}
|
|
|
|
//Returns true, if entry includes resource_data_entry
|
|
//Returns false, if entry includes resource_directory
|
|
bool resource_directory_entry::includes_data() const
|
|
{
|
|
return includes_data_;
|
|
}
|
|
|
|
//Returns resource_directory if entry includes it, otherwise throws an exception
|
|
const resource_directory& resource_directory_entry::get_resource_directory() const
|
|
{
|
|
if(!ptr_.dir_ || includes_data_)
|
|
throw pe_exception("Resource directory entry does not contain resource directory", pe_exception::resource_directory_entry_error);
|
|
|
|
return *ptr_.dir_;
|
|
}
|
|
|
|
//Returns resource_data_entry if entry includes it, otherwise throws an exception
|
|
const resource_data_entry& resource_directory_entry::get_data_entry() const
|
|
{
|
|
if(!ptr_.data_ || !includes_data_)
|
|
throw pe_exception("Resource directory entry does not contain resource data entry", pe_exception::resource_directory_entry_error);
|
|
|
|
return *ptr_.data_;
|
|
}
|
|
|
|
//Returns resource_directory if entry includes it, otherwise throws an exception
|
|
resource_directory& resource_directory_entry::get_resource_directory()
|
|
{
|
|
if(!ptr_.dir_ || includes_data_)
|
|
throw pe_exception("Resource directory entry does not contain resource directory", pe_exception::resource_directory_entry_error);
|
|
|
|
return *ptr_.dir_;
|
|
}
|
|
|
|
//Returns resource_data_entry if entry includes it, otherwise throws an exception
|
|
resource_data_entry& resource_directory_entry::get_data_entry()
|
|
{
|
|
if(!ptr_.data_ || !includes_data_)
|
|
throw pe_exception("Resource directory entry does not contain resource data entry", pe_exception::resource_directory_entry_error);
|
|
|
|
return *ptr_.data_;
|
|
}
|
|
|
|
//Sets entry name
|
|
void resource_directory_entry::set_name(const std::wstring& name)
|
|
{
|
|
name_ = name;
|
|
named_ = true;
|
|
id_ = 0;
|
|
}
|
|
|
|
//Sets entry ID
|
|
void resource_directory_entry::set_id(uint32_t id)
|
|
{
|
|
id_ = id;
|
|
named_ = false;
|
|
name_.clear();
|
|
}
|
|
|
|
//Adds resource_data_entry
|
|
void resource_directory_entry::add_data_entry(const resource_data_entry& entry)
|
|
{
|
|
release();
|
|
ptr_.data_ = new resource_data_entry(entry);
|
|
includes_data_ = true;
|
|
}
|
|
|
|
//Adds resource_directory
|
|
void resource_directory_entry::add_resource_directory(const resource_directory& dir)
|
|
{
|
|
release();
|
|
ptr_.dir_ = new resource_directory(dir);
|
|
includes_data_ = false;
|
|
}
|
|
|
|
//Default constructor
|
|
resource_directory::resource_directory()
|
|
:characteristics_(0),
|
|
timestamp_(0),
|
|
major_version_(0), minor_version_(0),
|
|
number_of_named_entries_(0), number_of_id_entries_(0)
|
|
{}
|
|
|
|
//Constructor from data
|
|
resource_directory::resource_directory(const image_resource_directory& dir)
|
|
:characteristics_(dir.Characteristics),
|
|
timestamp_(dir.TimeDateStamp),
|
|
major_version_(dir.MajorVersion), minor_version_(dir.MinorVersion),
|
|
number_of_named_entries_(0), number_of_id_entries_(0) //Set to zero here, calculate on add
|
|
{}
|
|
|
|
//Returns characteristics of directory
|
|
uint32_t resource_directory::get_characteristics() const
|
|
{
|
|
return characteristics_;
|
|
}
|
|
|
|
//Returns date and time stamp of directory
|
|
uint32_t resource_directory::get_timestamp() const
|
|
{
|
|
return timestamp_;
|
|
}
|
|
|
|
//Returns major version of directory
|
|
uint16_t resource_directory::get_major_version() const
|
|
{
|
|
return major_version_;
|
|
}
|
|
|
|
//Returns minor version of directory
|
|
uint16_t resource_directory::get_minor_version() const
|
|
{
|
|
return minor_version_;
|
|
}
|
|
|
|
//Returns number of named entries
|
|
uint32_t resource_directory::get_number_of_named_entries() const
|
|
{
|
|
return number_of_named_entries_;
|
|
}
|
|
|
|
//Returns number of ID entries
|
|
uint32_t resource_directory::get_number_of_id_entries() const
|
|
{
|
|
return number_of_id_entries_;
|
|
}
|
|
|
|
//Returns resource_directory_entry array
|
|
const resource_directory::entry_list& resource_directory::get_entry_list() const
|
|
{
|
|
return entries_;
|
|
}
|
|
|
|
//Returns resource_directory_entry array
|
|
resource_directory::entry_list& resource_directory::get_entry_list()
|
|
{
|
|
return entries_;
|
|
}
|
|
|
|
//Adds resource_directory_entry
|
|
void resource_directory::add_resource_directory_entry(const resource_directory_entry& entry)
|
|
{
|
|
entries_.push_back(entry);
|
|
if(entry.is_named())
|
|
++number_of_named_entries_;
|
|
else
|
|
++number_of_id_entries_;
|
|
}
|
|
|
|
//Clears resource_directory_entry array
|
|
void resource_directory::clear_resource_directory_entry_list()
|
|
{
|
|
entries_.clear();
|
|
number_of_named_entries_ = 0;
|
|
number_of_id_entries_ = 0;
|
|
}
|
|
|
|
//Sets characteristics of directory
|
|
void resource_directory::set_characteristics(uint32_t characteristics)
|
|
{
|
|
characteristics_ = characteristics;
|
|
}
|
|
|
|
//Sets date and time stamp of directory
|
|
void resource_directory::set_timestamp(uint32_t timestamp)
|
|
{
|
|
timestamp_ = timestamp;
|
|
}
|
|
|
|
//Sets number of named entries
|
|
void resource_directory::set_number_of_named_entries(uint32_t number)
|
|
{
|
|
number_of_named_entries_ = number;
|
|
}
|
|
|
|
//Sets number of ID entries
|
|
void resource_directory::set_number_of_id_entries(uint32_t number)
|
|
{
|
|
number_of_id_entries_ = number;
|
|
}
|
|
|
|
//Sets major version of directory
|
|
void resource_directory::set_major_version(uint16_t major_version)
|
|
{
|
|
major_version_ = major_version;
|
|
}
|
|
|
|
//Sets minor version of directory
|
|
void resource_directory::get_minor_version(uint16_t minor_version)
|
|
{
|
|
minor_version_ = minor_version;
|
|
}
|
|
|
|
//Processes resource directory
|
|
const resource_directory process_resource_directory(const pe_base& pe, uint32_t res_rva, uint32_t offset_to_directory, std::set<uint32_t>& processed)
|
|
{
|
|
resource_directory ret;
|
|
|
|
//Check for resource loops
|
|
if(!processed.insert(offset_to_directory).second)
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
if(!pe_utils::is_sum_safe(res_rva, offset_to_directory))
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
//Get root IMAGE_RESOURCE_DIRECTORY
|
|
image_resource_directory directory = pe.section_data_from_rva<image_resource_directory>(res_rva + offset_to_directory, section_data_virtual, true);
|
|
|
|
ret = resource_directory(directory);
|
|
|
|
//Check DWORDs for possible overflows
|
|
if(!pe_utils::is_sum_safe(directory.NumberOfIdEntries, directory.NumberOfNamedEntries)
|
|
|| directory.NumberOfIdEntries + directory.NumberOfNamedEntries >= pe_utils::max_dword / sizeof(image_resource_directory_entry) + sizeof(image_resource_directory))
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
if(!pe_utils::is_sum_safe(offset_to_directory, sizeof(image_resource_directory) + (directory.NumberOfIdEntries + directory.NumberOfNamedEntries) * sizeof(image_resource_directory_entry))
|
|
|| !pe_utils::is_sum_safe(res_rva, offset_to_directory + sizeof(image_resource_directory) + (directory.NumberOfIdEntries + directory.NumberOfNamedEntries) * sizeof(image_resource_directory_entry)))
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
for(unsigned long i = 0; i != static_cast<unsigned long>(directory.NumberOfIdEntries) + directory.NumberOfNamedEntries; ++i)
|
|
{
|
|
//Read directory entries one by one
|
|
image_resource_directory_entry dir_entry = pe.section_data_from_rva<image_resource_directory_entry>(
|
|
res_rva + sizeof(image_resource_directory) + i * sizeof(image_resource_directory_entry) + offset_to_directory, section_data_virtual, true);
|
|
|
|
//Create directory entry structure
|
|
resource_directory_entry entry;
|
|
|
|
//If directory is named
|
|
if(dir_entry.NameIsString)
|
|
{
|
|
if(!pe_utils::is_sum_safe(res_rva + sizeof(uint16_t) /* safe */, dir_entry.NameOffset))
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
//get directory name length
|
|
uint16_t directory_name_length = pe.section_data_from_rva<uint16_t>(res_rva + dir_entry.NameOffset, section_data_virtual, true);
|
|
|
|
//Check name length
|
|
if(pe.section_data_length_from_rva(res_rva + dir_entry.NameOffset + sizeof(uint16_t), res_rva + dir_entry.NameOffset + sizeof(uint16_t), section_data_virtual, true)
|
|
< directory_name_length)
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
#ifdef PE_BLISS_WINDOWS
|
|
//Set entry UNICODE name
|
|
entry.set_name(std::wstring(
|
|
reinterpret_cast<const wchar_t*>(pe.section_data_from_rva(res_rva + dir_entry.NameOffset + sizeof(uint16_t), section_data_virtual, true)),
|
|
directory_name_length));
|
|
#else
|
|
//Set entry UNICODE name
|
|
entry.set_name(pe_utils::from_ucs2(u16string(
|
|
reinterpret_cast<const unicode16_t*>(pe.section_data_from_rva(res_rva + dir_entry.NameOffset + sizeof(uint16_t), section_data_virtual, true)),
|
|
directory_name_length)));
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
//Else - set directory ID
|
|
entry.set_id(dir_entry.Id);
|
|
}
|
|
|
|
//If directory entry has another resource directory
|
|
if(dir_entry.DataIsDirectory)
|
|
{
|
|
entry.add_resource_directory(process_resource_directory(pe, res_rva, dir_entry.OffsetToDirectory, processed));
|
|
}
|
|
else
|
|
{
|
|
//If directory entry has data
|
|
image_resource_data_entry data_entry = pe.section_data_from_rva<image_resource_data_entry>(
|
|
res_rva + dir_entry.OffsetToData, section_data_virtual, true);
|
|
|
|
//Check byte count that stated by data entry
|
|
if(pe.section_data_length_from_rva(data_entry.OffsetToData, data_entry.OffsetToData, section_data_virtual, true) < data_entry.Size)
|
|
throw pe_exception("Incorrect resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
//Add data entry to directory entry
|
|
entry.add_data_entry(resource_data_entry(
|
|
std::string(pe.section_data_from_rva(data_entry.OffsetToData, section_data_virtual, true), data_entry.Size),
|
|
data_entry.CodePage));
|
|
}
|
|
|
|
//Save directory entry
|
|
ret.add_resource_directory_entry(entry);
|
|
}
|
|
|
|
//Return resource directory
|
|
return ret;
|
|
}
|
|
|
|
//Helper function to calculate needed space for resource data
|
|
void calculate_resource_data_space(const resource_directory& root, uint32_t aligned_offset_from_section_start, uint32_t& needed_size_for_structures, uint32_t& needed_size_for_strings)
|
|
{
|
|
needed_size_for_structures += sizeof(image_resource_directory);
|
|
for(resource_directory::entry_list::const_iterator it = root.get_entry_list().begin(); it != root.get_entry_list().end(); ++it)
|
|
{
|
|
needed_size_for_structures += sizeof(image_resource_directory_entry);
|
|
|
|
if((*it).is_named())
|
|
needed_size_for_strings += static_cast<uint32_t>(((*it).get_name().length() + 1) * 2 /* unicode */ + sizeof(uint16_t) /* for string length */);
|
|
|
|
if(!(*it).includes_data())
|
|
calculate_resource_data_space((*it).get_resource_directory(), aligned_offset_from_section_start, needed_size_for_structures, needed_size_for_strings);
|
|
}
|
|
}
|
|
|
|
//Helper function to calculate needed space for resource data
|
|
void calculate_resource_data_space(const resource_directory& root, uint32_t needed_size_for_structures, uint32_t needed_size_for_strings, uint32_t& needed_size_for_data, uint32_t& current_data_pos)
|
|
{
|
|
for(resource_directory::entry_list::const_iterator it = root.get_entry_list().begin(); it != root.get_entry_list().end(); ++it)
|
|
{
|
|
if((*it).includes_data())
|
|
{
|
|
uint32_t data_size = static_cast<uint32_t>((*it).get_data_entry().get_data().length()
|
|
+ sizeof(image_resource_data_entry)
|
|
+ (pe_utils::align_up(current_data_pos, sizeof(uint32_t)) - current_data_pos) /* alignment */);
|
|
needed_size_for_data += data_size;
|
|
current_data_pos += data_size;
|
|
}
|
|
else
|
|
{
|
|
calculate_resource_data_space((*it).get_resource_directory(), needed_size_for_structures, needed_size_for_strings, needed_size_for_data, current_data_pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Helper: sorts resource directory entries
|
|
struct entry_sorter
|
|
{
|
|
public:
|
|
bool operator()(const resource_directory_entry& entry1, const resource_directory_entry& entry2) const;
|
|
};
|
|
|
|
//Helper function to rebuild resource directory
|
|
void rebuild_resource_directory(pe_base& pe, section& resource_section, resource_directory& root, uint32_t& current_structures_pos, uint32_t& current_data_pos, uint32_t& current_strings_pos, uint32_t offset_from_section_start)
|
|
{
|
|
//Create resource directory
|
|
image_resource_directory dir = {0};
|
|
dir.Characteristics = root.get_characteristics();
|
|
dir.MajorVersion = root.get_major_version();
|
|
dir.MinorVersion = root.get_minor_version();
|
|
dir.TimeDateStamp = root.get_timestamp();
|
|
|
|
{
|
|
resource_directory::entry_list& entries = root.get_entry_list();
|
|
std::sort(entries.begin(), entries.end(), entry_sorter());
|
|
}
|
|
|
|
//Calculate number of named and ID entries
|
|
for(resource_directory::entry_list::const_iterator it = root.get_entry_list().begin(); it != root.get_entry_list().end(); ++it)
|
|
{
|
|
if((*it).is_named())
|
|
++dir.NumberOfNamedEntries;
|
|
else
|
|
++dir.NumberOfIdEntries;
|
|
}
|
|
|
|
std::string& raw_data = resource_section.get_raw_data();
|
|
|
|
//Save resource directory
|
|
memcpy(&raw_data[current_structures_pos], &dir, sizeof(dir));
|
|
current_structures_pos += sizeof(dir);
|
|
|
|
uint32_t this_current_structures_pos = current_structures_pos;
|
|
|
|
current_structures_pos += sizeof(image_resource_directory_entry) * (dir.NumberOfNamedEntries + dir.NumberOfIdEntries);
|
|
|
|
//Create all resource directory entries
|
|
for(resource_directory::entry_list::iterator it = root.get_entry_list().begin(); it != root.get_entry_list().end(); ++it)
|
|
{
|
|
image_resource_directory_entry entry;
|
|
if((*it).is_named())
|
|
{
|
|
entry.Name = 0x80000000 | (current_strings_pos - offset_from_section_start);
|
|
uint16_t unicode_length = static_cast<uint16_t>((*it).get_name().length());
|
|
memcpy(&raw_data[current_strings_pos], &unicode_length, sizeof(unicode_length));
|
|
current_strings_pos += sizeof(unicode_length);
|
|
|
|
#ifdef PE_BLISS_WINDOWS
|
|
memcpy(&raw_data[current_strings_pos], (*it).get_name().c_str(), (*it).get_name().length() * sizeof(uint16_t) + sizeof(uint16_t) /* unicode */);
|
|
#else
|
|
{
|
|
u16string str(pe_utils::to_ucs2((*it).get_name()));
|
|
memcpy(&raw_data[current_strings_pos], str.c_str(), (*it).get_name().length() * sizeof(uint16_t) + sizeof(uint16_t) /* unicode */);
|
|
}
|
|
#endif
|
|
|
|
current_strings_pos += static_cast<unsigned long>((*it).get_name().length() * sizeof(uint16_t) + sizeof(uint16_t) /* unicode */);
|
|
}
|
|
else
|
|
{
|
|
entry.Name = (*it).get_id();
|
|
}
|
|
|
|
if((*it).includes_data())
|
|
{
|
|
current_data_pos = pe_utils::align_up(current_data_pos, sizeof(uint32_t));
|
|
image_resource_data_entry data_entry = {0};
|
|
data_entry.CodePage = (*it).get_data_entry().get_codepage();
|
|
data_entry.Size = static_cast<uint32_t>((*it).get_data_entry().get_data().length());
|
|
data_entry.OffsetToData = pe.rva_from_section_offset(resource_section, current_data_pos + sizeof(data_entry));
|
|
|
|
entry.OffsetToData = current_data_pos - offset_from_section_start;
|
|
|
|
memcpy(&raw_data[current_data_pos], &data_entry, sizeof(data_entry));
|
|
current_data_pos += sizeof(data_entry);
|
|
|
|
memcpy(&raw_data[current_data_pos], (*it).get_data_entry().get_data().data(), data_entry.Size);
|
|
current_data_pos += data_entry.Size;
|
|
|
|
memcpy(&raw_data[this_current_structures_pos], &entry, sizeof(entry));
|
|
this_current_structures_pos += sizeof(entry);
|
|
}
|
|
else
|
|
{
|
|
entry.OffsetToData = 0x80000000 | (current_structures_pos - offset_from_section_start);
|
|
|
|
memcpy(&raw_data[this_current_structures_pos], &entry, sizeof(entry));
|
|
this_current_structures_pos += sizeof(entry);
|
|
|
|
rebuild_resource_directory(pe, resource_section, (*it).get_resource_directory(), current_structures_pos, current_data_pos, current_strings_pos, offset_from_section_start);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Helper function to rebuild resource directory
|
|
bool entry_sorter::operator()(const resource_directory_entry& entry1, const resource_directory_entry& entry2) const
|
|
{
|
|
if(entry1.is_named() && entry2.is_named())
|
|
return entry1.get_name() < entry2.get_name();
|
|
else if(!entry1.is_named() && !entry2.is_named())
|
|
return entry1.get_id() < entry2.get_id();
|
|
else
|
|
return entry1.is_named();
|
|
}
|
|
|
|
//Resources rebuilder
|
|
//resource_directory - root resource directory
|
|
//resources_section - section where resource directory will be placed (must be attached to PE image)
|
|
//offset_from_section_start - offset from resources_section raw data start
|
|
//resource_directory is non-constant, because it will be sorted
|
|
//save_to_pe_headers - if true, new resource directory information will be saved to PE image headers
|
|
//auto_strip_last_section - if true and resources are placed in the last section, it will be automatically stripped
|
|
//number_of_id_entries and number_of_named_entries for resource directories are recalculated and not used
|
|
const image_directory rebuild_resources(pe_base& pe, resource_directory& info, section& resources_section, uint32_t offset_from_section_start, bool save_to_pe_header, bool auto_strip_last_section)
|
|
{
|
|
//Check that resources_section is attached to this PE image
|
|
if(!pe.section_attached(resources_section))
|
|
throw pe_exception("Resource section must be attached to PE file", pe_exception::section_is_not_attached);
|
|
|
|
//Check resource directory correctness
|
|
if(info.get_entry_list().empty())
|
|
throw pe_exception("Empty resource directory", pe_exception::incorrect_resource_directory);
|
|
|
|
uint32_t aligned_offset_from_section_start = pe_utils::align_up(offset_from_section_start, sizeof(uint32_t));
|
|
uint32_t needed_size_for_structures = aligned_offset_from_section_start - offset_from_section_start; //Calculate needed size for resource tables and data
|
|
uint32_t needed_size_for_strings = 0;
|
|
uint32_t needed_size_for_data = 0;
|
|
|
|
calculate_resource_data_space(info, aligned_offset_from_section_start, needed_size_for_structures, needed_size_for_strings);
|
|
|
|
{
|
|
uint32_t current_data_pos = aligned_offset_from_section_start + needed_size_for_structures + needed_size_for_strings;
|
|
calculate_resource_data_space(info, needed_size_for_structures, needed_size_for_strings, needed_size_for_data, current_data_pos);
|
|
}
|
|
|
|
uint32_t needed_size = needed_size_for_structures + needed_size_for_strings + needed_size_for_data;
|
|
|
|
//Check if resources_section is last one. If it's not, check if there's enough place for resource data
|
|
if(&resources_section != &*(pe.get_image_sections().end() - 1) &&
|
|
(resources_section.empty() || pe_utils::align_up(resources_section.get_size_of_raw_data(), pe.get_file_alignment())
|
|
< needed_size + aligned_offset_from_section_start))
|
|
throw pe_exception("Insufficient space for resource directory", pe_exception::insufficient_space);
|
|
|
|
std::string& raw_data = resources_section.get_raw_data();
|
|
|
|
//This will be done only if resources_section is the last section of image or for section with unaligned raw length of data
|
|
if(raw_data.length() < needed_size + aligned_offset_from_section_start)
|
|
raw_data.resize(needed_size + aligned_offset_from_section_start); //Expand section raw data
|
|
|
|
uint32_t current_structures_pos = aligned_offset_from_section_start;
|
|
uint32_t current_strings_pos = current_structures_pos + needed_size_for_structures;
|
|
uint32_t current_data_pos = current_strings_pos + needed_size_for_strings;
|
|
rebuild_resource_directory(pe, resources_section, info, current_structures_pos, current_data_pos, current_strings_pos, aligned_offset_from_section_start);
|
|
|
|
//Adjust section raw and virtual sizes
|
|
pe.recalculate_section_sizes(resources_section, auto_strip_last_section);
|
|
|
|
image_directory ret(pe.rva_from_section_offset(resources_section, aligned_offset_from_section_start), needed_size);
|
|
|
|
//If auto-rewrite of PE headers is required
|
|
if(save_to_pe_header)
|
|
{
|
|
pe.set_directory_rva(image_directory_entry_resource, ret.get_rva());
|
|
pe.set_directory_size(image_directory_entry_resource, ret.get_size());
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
//Returns resources from PE file
|
|
const resource_directory get_resources(const pe_base& pe)
|
|
{
|
|
resource_directory ret;
|
|
|
|
if(!pe.has_resources())
|
|
return ret;
|
|
|
|
//Get resource directory RVA
|
|
uint32_t res_rva = pe.get_directory_rva(image_directory_entry_resource);
|
|
|
|
//Store already processed directories to avoid resource loops
|
|
std::set<uint32_t> processed;
|
|
|
|
//Process all directories (recursion)
|
|
ret = process_resource_directory(pe, res_rva, 0, processed);
|
|
|
|
return ret;
|
|
}
|
|
|
|
//Finds resource_directory_entry by ID
|
|
resource_directory::id_entry_finder::id_entry_finder(uint32_t id)
|
|
:id_(id)
|
|
{}
|
|
|
|
bool resource_directory::id_entry_finder::operator()(const resource_directory_entry& entry) const
|
|
{
|
|
return !entry.is_named() && entry.get_id() == id_;
|
|
}
|
|
|
|
//Finds resource_directory_entry by name
|
|
resource_directory::name_entry_finder::name_entry_finder(const std::wstring& name)
|
|
:name_(name)
|
|
{}
|
|
|
|
bool resource_directory::name_entry_finder::operator()(const resource_directory_entry& entry) const
|
|
{
|
|
return entry.is_named() && entry.get_name() == name_;
|
|
}
|
|
|
|
//Finds resource_directory_entry by name or ID (universal)
|
|
resource_directory::entry_finder::entry_finder(const std::wstring& name)
|
|
:name_(name), named_(true)
|
|
{}
|
|
|
|
resource_directory::entry_finder::entry_finder(uint32_t id)
|
|
:id_(id), named_(false)
|
|
{}
|
|
|
|
bool resource_directory::entry_finder::operator()(const resource_directory_entry& entry) const
|
|
{
|
|
if(named_)
|
|
return entry.is_named() && entry.get_name() == name_;
|
|
else
|
|
return !entry.is_named() && entry.get_id() == id_;
|
|
}
|
|
|
|
//Returns resource_directory_entry by ID. If not found - throws an exception
|
|
const resource_directory_entry& resource_directory::entry_by_id(uint32_t id) const
|
|
{
|
|
entry_list::const_iterator i = std::find_if(entries_.begin(), entries_.end(), id_entry_finder(id));
|
|
if(i == entries_.end())
|
|
throw pe_exception("Resource directory entry not found", pe_exception::resource_directory_entry_not_found);
|
|
|
|
return *i;
|
|
}
|
|
|
|
//Returns resource_directory_entry by name. If not found - throws an exception
|
|
const resource_directory_entry& resource_directory::entry_by_name(const std::wstring& name) const
|
|
{
|
|
entry_list::const_iterator i = std::find_if(entries_.begin(), entries_.end(), name_entry_finder(name));
|
|
if(i == entries_.end())
|
|
throw pe_exception("Resource directory entry not found", pe_exception::resource_directory_entry_not_found);
|
|
|
|
return *i;
|
|
}
|
|
}
|