xex.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <optional>
#include <span>
#include <string>
#include <vector>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
 
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
#include <rex/utility.h>
#include <rex/assert.h>
#include <rex/kernel/types/xex.h>
 
namespace rex::filesystem {

enum PESectionFlags : u32 {
  kPESectionContainsCode = 0x00000020,       
  kPESectionContainsDataInit = 0x00000040,   
  kPESectionContainsDataUninit = 0x00000080, 
  kPESectionMemoryExecute = 0x20000000,      
  kPESectionMemoryRead = 0x40000000,         
  kPESectionMemoryWrite = 0x80000000,        
};
 
class PESection {
 public:
  char name[9];    
  u32 raw_address; 
  u32 raw_size;    
  u32 address;     
  u32 size;        
  u32 flags;       
};
 
struct PEExport {
  const char* name;
  u32 ordinal;
 
  u64 addr;
};
 
struct PEInfo {
  std::vector<PESection> sections; 
  u32 exception_directory_rva = 0;
  u32 exception_directory_size = 0;
  u32 time_date_stamp = 0; 
  u32 header_size = 0;     
};
 
}  // namespace rex::filesystem
 
namespace rex::filesystem {

enum class XEXKey : u8 {
  kRetail,
  kDevKit,
  kRetailXEX1, 
  kDevKitXEX1, 
};
 
struct XEXPageRange {
  kernel::XEXSectionType type = kernel::kXEXSectionCode;
  u32 page_count = 0;
};

struct XEXSecurityInfo {
  std::array<u8, 0x100> rsa_signature{};
  std::array<u8, 0x10> aes_key{}; 
  u32 image_size = 0;             
  u32 image_flags = 0;            
  u32 export_table = 0;           
  u32 load_address = 0;
  std::vector<XEXPageRange> pages; 
};
 
struct XEXImportLibrary {
  std::string name; 
  u32 id = 0;
  kernel::XEXVersion version{};
  kernel::XEXVersion min_version{};
  std::vector<u32> records; 
};
 
struct XEXOptHeaderEntry {
  u32 index = 0;
  u32 value = 0; 
};

class IXEXImage {
 public:
  virtual ~IXEXImage() = default;

  virtual const kernel::XEXHeader& GetHeader() const = 0;
 
  virtual std::span<const u8> GetHeaderBytes() const = 0;

  template <typename T>
  const T* GetOptHeader(kernel::XEXHeaderKey key) const {
    return static_cast<const T*>(FindOptHeader(key));
  }

  virtual std::optional<u32> GetOptHeaderValue(kernel::XEXHeaderKey key) const = 0;
 
  virtual const XEXSecurityInfo& GetSecurity() const = 0;
 
  virtual std::span<const XEXImportLibrary> GetImports() const = 0;
 
  virtual std::vector<u32> GetAlternateTitleIDs() const = 0;
 
  virtual bool IsPatch() const = 0;

  virtual XEXKey GetKey() const = 0;

  virtual u32 GetImageSize() const = 0;

  [[nodiscard]] virtual Result<void> Decode(std::span<const u8> file, std::span<u8> image) = 0;

  [[nodiscard]] virtual Result<std::unique_ptr<IXEXImage>> ApplyHeaderDelta(
      const IXEXImage& patch) const = 0;

  [[nodiscard]] virtual Result<void> ApplyImageDelta(const IXEXImage& patch,
                                                     std::span<u8> image) const = 0;
 
 protected:
  virtual const void* FindOptHeader(kernel::XEXHeaderKey key) const = 0;
};
 
}  // namespace rex::filesystem