libwz 0.1.0

package/include/wz/Util/WzDataSource.h

@@ -0,0 +1,49 @@
+#ifndef WZ_UTIL_WZDATASOURCE_H_
+#define WZ_UTIL_WZDATASOURCE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <span>
+#include <vector>
+
+#include "wz/Result.h"
+#include "wz/Util/WzStream.h"
+
+namespace wz {
+
+class WzDataSource {
+ public:
+  virtual ~WzDataSource() = default;
+  virtual Result<size_t> ReadAt(uint64_t offset,
+                                std::span<uint8_t> destination) = 0;
+  virtual uint64_t Size() const = 0;
+};
+
+class WzFileDataSource final : public WzDataSource {
+ public:
+  explicit WzFileDataSource(WzFileStream* input);
+
+  Result<size_t> ReadAt(uint64_t offset,
+                        std::span<uint8_t> destination) override;
+  uint64_t Size() const override;
+
+ private:
+  WzFileStream* input_ = nullptr;
+  uint64_t size_;
+};
+
+class WzMemoryDataSource final : public WzDataSource {
+ public:
+  explicit WzMemoryDataSource(std::vector<uint8_t> data);
+
+  Result<size_t> ReadAt(uint64_t offset,
+                        std::span<uint8_t> destination) override;
+  uint64_t Size() const override;
+
+ private:
+  std::vector<uint8_t> data_;
+};
+
+}  // namespace wz
+
+#endif  // WZ_UTIL_WZDATASOURCE_H_

package/include/wz/Util/WzKeyGenerator.h

@@ -0,0 +1,28 @@
+#ifndef WZ_UTIL_WZKEYGENERATOR_H_
+#define WZ_UTIL_WZKEYGENERATOR_H_
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "wz/Util/WzMutableKey.h"
+
+namespace wz {
+
+// MapleCryptoConstants - default user key (128 bytes as 32 DWORDs)
+extern const std::array<uint8_t, 128> MAPLESTORY_USERKEY_DEFAULT;
+
+// Trimmed user key: takes 128-byte key, extracts 32 bytes (every 16th byte =
+// first byte of each DWORD)
+std::array<uint8_t, 32> GetTrimmedUserKey(
+    const std::array<uint8_t, 128>& userKey);
+
+class WzKeyGenerator {
+ public:
+  static WzMutableKey GenerateWzKey(const std::array<uint8_t, 4>& WzIv);
+  static WzMutableKey GenerateLuaWzKey();
+  static WzMutableKey GenerateWzKey(const std::array<uint8_t, 4>& WzIv,
+                                    const std::array<uint8_t, 128>& AesUserKey);
+};
+
+}  // namespace wz
+#endif  // WZ_UTIL_WZKEYGENERATOR_H_

package/include/wz/Util/WzMutableKey.h

@@ -0,0 +1,39 @@
+#ifndef WZ_UTIL_WZMUTABLEKEY_H_
+#define WZ_UTIL_WZMUTABLEKEY_H_
+#include <array>
+#include <cstdint>
+#include <vector>
+#include "wz/Util/Defines.h"
+
+namespace wz {
+
+class WzMutableKey {
+ public:
+  static constexpr int BatchSize = 4096;
+
+  WzMutableKey(const std::array<uint8_t, 4>& iv,
+               const std::array<uint8_t, 32>& aesKey);
+  WZ_DISALLOW_COPY(WzMutableKey)
+  WzMutableKey(WzMutableKey&&) = default;
+  WzMutableKey& operator=(WzMutableKey&&) = default;
+
+  uint8_t operator[](size_t index) const;
+  std::vector<uint8_t> GetKeys()
+      const;  // returns a copy of the first 4 bytes of the key (the IV key)
+
+  void EnsureKeySize(size_t size);
+
+  const std::array<uint8_t, 4>& Iv() const { return iv_; }
+  const std::array<uint8_t, 32>& AesKey() const { return aesKey_; }
+
+  bool operator==(const WzMutableKey& other) const;
+  bool operator!=(const WzMutableKey& other) const { return !(*this == other); }
+
+ private:
+  std::array<uint8_t, 4> iv_;
+  std::array<uint8_t, 32> aesKey_;
+  mutable std::vector<uint8_t> keys_;
+};
+
+}  // namespace wz
+#endif  // WZ_UTIL_WZMUTABLEKEY_H_

package/include/wz/Util/WzPath.h

@@ -0,0 +1,37 @@
+#ifndef WZ_UTIL_WZPATH_H_
+#define WZ_UTIL_WZPATH_H_
+
+#include <filesystem>
+#include <string>
+#include "wz/Util/WzTool.h"
+
+namespace wz {
+
+// Converts a UTF-8 path string to std::filesystem::path.
+// On Windows: MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS) first.
+//   - If valid UTF-8 → convert to wstring → fs::path(wstring).
+//   - If not valid UTF-8 (e.g. GBK on CJK Windows) → fall back to
+//     fs::path(string) which uses the system ANSI code page (CP_ACP).
+// On non-Windows: fs::path(string) — natively UTF-8, no conversion needed.
+inline std::filesystem::path to_path(const std::string& utf8_path) {
+#ifdef _WIN32
+  return WzTool::ToPath(utf8_path);
+#else
+  return std::filesystem::path(utf8_path);
+#endif
+}
+
+inline std::filesystem::path to_path(std::string&& utf8_path) {
+#ifdef _WIN32
+  return to_path(static_cast<const std::string&>(utf8_path));
+#else
+  return std::filesystem::path(std::move(utf8_path));
+#endif
+}
+
+inline std::filesystem::path to_path(const char* utf8_path) {
+  return to_path(std::string(utf8_path ? utf8_path : ""));
+}
+
+}  // namespace wz
+#endif  // WZ_UTIL_WZPATH_H_

package/include/wz/Util/WzStream.h

@@ -0,0 +1,86 @@
+#ifndef WZ_UTIL_WZSTREAM_H_
+#define WZ_UTIL_WZSTREAM_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <filesystem>
+#include <vector>
+
+#include "wz/Util/Defines.h"
+
+namespace wz {
+
+enum class WzSeekOrigin {
+  Begin,
+  Current,
+  End,
+};
+
+class WzStream {
+ public:
+  virtual ~WzStream() = default;
+  virtual size_t Read(void* destination, size_t count) = 0;
+  virtual bool Write(const void* data, size_t count) = 0;
+  virtual bool Seek(int64_t offset, WzSeekOrigin origin) = 0;
+  virtual int64_t Position() const = 0;
+  virtual int64_t Size() const = 0;
+  virtual bool Flush() = 0;
+  virtual void Close() = 0;
+  virtual bool IsOpen() const = 0;
+
+  bool WriteByte(uint8_t value);
+};
+
+class WzFileStream final : public WzStream {
+ public:
+  WzFileStream() = default;
+  WzFileStream(const std::filesystem::path& path, const char* mode);
+  ~WzFileStream() override;
+
+  WZ_DISALLOW_COPY(WzFileStream)
+  WzFileStream(WzFileStream&& other) noexcept;
+  WzFileStream& operator=(WzFileStream&& other) noexcept;
+
+  bool Open(const std::filesystem::path& path, const char* mode);
+  void Close() override;
+  bool IsOpen() const override { return file_ != nullptr; }
+
+  size_t Read(void* destination, size_t count) override;
+  bool Write(const void* data, size_t count) override;
+  bool Seek(int64_t offset, WzSeekOrigin origin) override;
+  int64_t Position() const override;
+  int64_t Size() const override { return size_; }
+  bool Flush() override;
+
+ private:
+  FILE* file_ = nullptr;
+  int64_t size_ = 0;
+
+  bool RefreshSize();
+};
+
+class WzMemoryStream final : public WzStream {
+ public:
+  WzMemoryStream() = default;
+  explicit WzMemoryStream(std::vector<uint8_t> data);
+
+  size_t Read(void* destination, size_t count) override;
+  bool Write(const void* data, size_t count) override;
+  bool Seek(int64_t offset, WzSeekOrigin origin) override;
+  int64_t Position() const override { return position_; }
+  int64_t Size() const override { return static_cast<int64_t>(buffer_.size()); }
+  bool Flush() override { return true; }
+  void Close() override;
+  bool IsOpen() const override { return true; }
+  const std::vector<uint8_t>& Buffer() const { return buffer_; }
+  std::vector<uint8_t>& Buffer() { return buffer_; }
+
+ private:
+  std::vector<uint8_t> buffer_;
+  int64_t position_ = 0;
+};
+
+}  // namespace wz
+
+#endif  // WZ_UTIL_WZSTREAM_H_

package/include/wz/Util/WzTool.h

@@ -0,0 +1,42 @@
+#ifndef WZ_UTIL_WZTOOL_H_
+#define WZ_UTIL_WZTOOL_H_
+#include <array>
+#include <cstdint>
+
+#ifdef _WIN32
+#include <filesystem>
+#endif
+
+#include <string>
+#include "wz/WzEnums.h"
+
+namespace wz {
+
+class WzTool {
+ public:
+  static constexpr int32_t WZ_HEADER = 0x31474B50;
+
+#ifdef _WIN32
+  static std::filesystem::path ToPath(const std::string& utf8_path);
+#endif
+  static uint32_t RotateLeft(uint32_t x, uint8_t n);
+  static uint32_t RotateRight(uint32_t x, uint8_t n);
+  static int GetCompressedIntLength(int i);
+  static int GetEncodedStringLength(const std::string& s);
+  static int GetWzObjectValueLength(const std::string& s, uint8_t type);
+  static void ClearWzObjectValueLengthCache();
+  static std::array<uint8_t, 4> GetIvByMapleVersion(WzMapleVersion ver);
+  static WzMapleVersion DetectMapleVersion(const std::string& wzFilePath,
+                                           int16_t* fileVersion);
+  static bool IsListFile(const std::string& path);
+  static bool IsDataWzHotfixFile(const std::string& path);
+
+ private:
+  static int GetRecognizedCharacters(const std::string& source);
+  static double GetDecryptionSuccessRate(const std::string& wzPath,
+                                         WzMapleVersion encVersion,
+                                         int16_t* version);
+};
+
+}  // namespace wz
+#endif  // WZ_UTIL_WZTOOL_H_

package/include/wz/WzAESConstant.h

@@ -0,0 +1,17 @@
+#ifndef WZ_WZAESCONSTANT_H_
+#define WZ_WZAESCONSTANT_H_
+#include <array>
+#include <cstdint>
+
+namespace wz {
+
+class WzAESConstant {
+ public:
+  static const std::array<uint8_t, 4> WZ_GMSIV;
+  static const std::array<uint8_t, 4> WZ_MSEAIV;
+  static const std::array<uint8_t, 4> WZ_BMSCLASSIC;
+  static const uint32_t WZ_OffsetConstant;
+};
+
+}  // namespace wz
+#endif  // WZ_WZAESCONSTANT_H_

package/include/wz/WzDirectory.h

@@ -0,0 +1,97 @@
+#ifndef WZ_WZDIRECTORY_H_
+#define WZ_WZDIRECTORY_H_
+#include <array>
+#include <memory>
+#include <string>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/Util/Defines.h"
+#include "wz/Util/WzStream.h"
+#include "wz/WzEnums.h"
+#include "wz/WzObject.h"
+
+namespace wz {
+
+class WzBinaryReader;
+class WzBinaryWriter;
+class WzFile;
+class WzImage;
+class WzImageProperty;
+
+class WzDirectory final : public WzObject {
+ public:
+  WzDirectory();
+  explicit WzDirectory(const std::string& dirName);
+  WzDirectory(WzBinaryReader* reader,
+              const std::string& dirName,
+              uint32_t verHash,
+              const std::array<uint8_t, 4>& wzIv,
+              WzFile* wzFile);
+  ~WzDirectory() override;
+
+  WZ_DISALLOW_COPY_AND_MOVE(WzDirectory)
+
+  WzObjectType ObjectType() const override { return WzObjectType::Directory; }
+  WzFile* WzFileParent() const override { return wzFile_; }
+  Result<std::unique_ptr<WzObject>> Remove() override;
+
+  int BlockSize() const { return size_; }
+  void SetBlockSize(int v) { size_ = v; }
+  int Checksum() const { return checksum_; }
+  void SetChecksum(int v) { checksum_ = v; }
+  int64_t Offset() const { return offset_; }
+  void SetOffset(int64_t v) { offset_ = v; }
+
+  std::vector<WzImage*> WzImages() const;
+  std::vector<WzDirectory*> WzDirectories() const;
+
+  WzBinaryReader* Reader() const { return reader_; }
+  void SetWzFile(WzFile* f) { wzFile_ = f; }
+
+  Result<void> ParseDirectory();
+  Result<void> ParseImages();
+
+  Result<void> AddImage(WzImage* img);
+  Result<void> AddImage(std::unique_ptr<WzImage> img);
+  Result<void> AddDirectory(WzDirectory* dir);
+  Result<void> AddDirectory(std::unique_ptr<WzDirectory> dir);
+  Result<WzDirectory*> CreateDirectory(const std::string& name);
+  Result<WzImage*> CreateImage(const std::string& name);
+  Result<std::unique_ptr<WzImage>> RemoveImage(WzImage* image);
+  Result<std::unique_ptr<WzDirectory>> RemoveDirectory(WzDirectory* dir);
+  void ClearImages();
+  void ClearDirectories();
+  WzImage* GetImageByName(const std::string& name);
+  WzDirectory* GetDirectoryByName(const std::string& name);
+  int CountImages() const;
+
+  WzObject* operator[](const std::string& name) const;
+
+  const std::array<uint8_t, 4>& WzIv() const { return wz_iv_; }
+  void SetWzIv(const std::array<uint8_t, 4>& iv);
+  uint32_t Hash() const { return hash_; }
+  void SetHash(uint32_t h);
+
+  Result<int> GenerateDataFile(const std::array<uint8_t, 4>* useIv,
+                               bool isDefaultUserKey,
+                               WzMemoryStream* tempStream);
+  Result<void> SaveDirectory(WzBinaryWriter* writer);
+  Result<void> SaveImages(WzBinaryWriter* writer, WzMemoryStream* tempStream);
+  Result<uint32_t> GetOffsets(uint32_t currentOffset);
+  Result<uint32_t> GetImgOffsets(uint32_t currentOffset);
+
+ private:
+  std::vector<std::unique_ptr<WzImage>> images_;
+  std::vector<std::unique_ptr<WzDirectory>> subDirs_;
+  WzBinaryReader* reader_ = nullptr;
+  int64_t offset_ = 0;
+  uint32_t hash_ = 0;
+  int size_ = 0;
+  int offsetSize_ = 0;
+  int checksum_ = 0;
+  std::array<uint8_t, 4> wz_iv_ = {};
+  WzFile* wzFile_ = nullptr;
+};
+
+}  // namespace wz
+#endif  // WZ_WZDIRECTORY_H_

package/include/wz/WzEnums.h

@@ -0,0 +1,76 @@
+#ifndef WZ_WZENUMS_H_
+#define WZ_WZENUMS_H_
+#include <cstdint>
+#include <string>
+
+namespace wz {
+
+enum class WzObjectType : int {
+  File = 0,
+  Image = 1,
+  Directory = 2,
+  Property = 3,
+  List = 4
+};
+
+enum class WzPropertyType : int {
+  Null = 0,
+  Short = 1,
+  Int = 2,
+  Long = 3,
+  Float = 4,
+  Double = 5,
+  String = 6,
+  SubProperty = 7,
+  Canvas = 8,
+  Vector = 9,
+  Convex = 10,
+  Sound = 11,
+  Raw = 12,
+  UOL = 13,
+  Lua = 14,
+  PNG = 15
+};
+
+enum class WzMapleVersion : int {
+  GMS = 0,
+  EMS = 1,
+  BMS = 2,
+  CLASSIC = 3,
+  GENERATE = 4,
+  GETFROMZLZ = 5,
+  CUSTOM = 6,
+  UNKNOWN = 99
+};
+
+enum class WzPngFormat : int {
+  Format1 = 1,
+  Format2 = 2,
+  Format3 = 3,
+  Format257 = 257,
+  Format513 = 513,
+  Format517 = 517,
+  Format1026 = 1026,
+  Format2050 = 2050
+};
+
+enum class WzDirectoryType : uint8_t {
+  UnknownType_1 = 1,
+  RetrieveStringFromOffset_2 = 2,
+  WzDirectory_3 = 3,
+  WzImage_4 = 4
+};
+
+enum class WzFileParseStatus : int {
+  Path_Is_Null = -1,
+  Error_Game_Ver_Hash = -2,
+  Failed_Unknown = 0,
+  Success = 1
+};
+
+enum class WzBinaryPropertyType : int { Raw = 0, MP3 = 1, WAV = 2 };
+
+std::string GetErrorDescription(WzFileParseStatus status);
+
+}  // namespace wz
+#endif  // WZ_WZENUMS_H_

package/include/wz/WzFile.h

@@ -0,0 +1,99 @@
+#ifndef WZ_WZFILE_H_
+#define WZ_WZFILE_H_
+#include <array>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "wz/Util/Defines.h"
+#include "wz/Util/WzBinaryReader.h"
+#include "wz/Util/WzDataSource.h"
+#include "wz/Util/WzStream.h"
+#include "wz/WzDirectory.h"
+#include "wz/WzEnums.h"
+#include "wz/WzHeader.h"
+#include "wz/WzObject.h"
+
+namespace wz {
+
+class IPropertyContainer;
+
+class WzFile final : public WzObject {
+ public:
+  WzFile(short gameVersion, WzMapleVersion version);
+  WzFile(const std::string& filePath, WzMapleVersion version);
+  WzFile(const std::string& filePath,
+         short gameVersion,
+         WzMapleVersion version);
+  WzFile(const std::string& fileName,
+         std::shared_ptr<WzDataSource> source,
+         short gameVersion,
+         WzMapleVersion version);
+  WzFile(const std::string& filePath, const std::array<uint8_t, 4>& wzIv);
+  WzFile(const std::string& fileName,
+         std::shared_ptr<WzDataSource> source,
+         const std::array<uint8_t, 4>& wzIv);
+  ~WzFile() override;
+
+  WZ_DISALLOW_COPY_AND_MOVE(WzFile)
+
+  WzObjectType ObjectType() const override { return WzObjectType::File; }
+  WzObject* Parent() const override { return nullptr; }
+  void SetParent(WzObject*) override {}
+  WzFile* WzFileParent() const override { return const_cast<WzFile*>(this); }
+
+  WzDirectory* GetWzDirectory() const { return wzDir_.get(); }
+  void SetWzDirectory(std::unique_ptr<WzDirectory> dir) {
+    wzDir_ = std::move(dir);
+  }
+
+  WzHeader* Header() { return &header_; }
+  short Version() const { return mapleStoryPatchVersion_; }
+  std::string FilePath() const { return path_; }
+  WzMapleVersion MapleVersion() const { return maplepLocalVersion_; }
+  bool Is64BitWzFile() const { return !wz_withEncryptVersionHeader_; }
+  bool IsUnloaded() const { return isUnloaded_; }
+
+  const std::array<uint8_t, 4>& WzIv() const { return wz_iv_; }
+  uint32_t VersionHash() const { return versionHash_; }
+
+  WzFileParseStatus ParseWzFile();
+  WzObject* GetObjectFromPath(const std::string& path,
+                              bool checkFirstDirectoryName = true);
+  Result<void> SaveToDisk(
+      const std::string& path,
+      std::optional<bool> saveAs64Bit = std::nullopt,
+      WzMapleVersion preferredVersion = WzMapleVersion::UNKNOWN);
+
+ private:
+  static WzObject* TraverseComponent(WzObject* curObj,
+                                     const std::string& component);
+  static constexpr uint16_t wzVersionHeader64bit_start = 770;
+  void CreateWZVersionHash();
+
+  std::string path_;
+  std::shared_ptr<WzDataSource> source_;
+  std::unique_ptr<WzDirectory> wzDir_;
+  WzFileStream fileStream_;
+  std::optional<WzBinaryReader> fileReader_;
+  WzHeader header_;
+  uint16_t wzVersionHeader_ = 0;
+  uint32_t versionHash_ = 0;
+  short mapleStoryPatchVersion_ = 0;
+  WzMapleVersion maplepLocalVersion_ = WzMapleVersion::UNKNOWN;
+  bool wz_withEncryptVersionHeader_ = true;
+  std::array<uint8_t, 4> wz_iv_ = {};
+  bool isUnloaded_ = false;
+
+  WzFileParseStatus ParseMainWzDirectory();
+  void Check64BitClient(WzBinaryReader* reader);
+  bool TryDecodeWithWZVersionNumber(WzBinaryReader* reader,
+                                    int useWzVersionHeader,
+                                    int useMapleStoryPatchVersion);
+  static uint32_t CheckAndGetVersionHash(int wzVersionHeader,
+                                         int maplestoryPatchVersion);
+};
+
+}  // namespace wz
+#endif  // WZ_WZFILE_H_

package/include/wz/WzHeader.h

@@ -0,0 +1,47 @@
+#ifndef WZ_WZHEADER_H_
+#define WZ_WZHEADER_H_
+#include <cstdint>
+#include <string>
+
+namespace wz {
+
+class WzHeader {
+ public:
+  static constexpr const char* DEFAULT_WZ_HEADER_COPYRIGHT =
+      "Package file v1.0 Copyright 2002 Wizet, ZMS";
+
+  std::string Ident() const { return ident_; }
+  void SetIdent(const std::string& v) { ident_ = v; }
+
+  std::string Copyright() const { return copyright_; }
+  void SetCopyright(const std::string& v) { copyright_ = v; }
+
+  uint64_t FSize() const { return fsize_; }
+  void SetFSize(uint64_t v) { fsize_ = v; }
+
+  uint32_t FStart() const { return fstart_; }
+  void SetFStart(uint32_t v) { fstart_ = v; }
+
+  void RecalculateFileStart() {
+    fstart_ = static_cast<uint32_t>(ident_.length() + sizeof(uint64_t) +
+                                    sizeof(uint32_t) + copyright_.length() + 1);
+  }
+
+  static WzHeader GetDefault() {
+    WzHeader h;
+    h.ident_ = "PKG1";
+    h.copyright_ = DEFAULT_WZ_HEADER_COPYRIGHT;
+    h.fstart_ = 60;
+    h.fsize_ = 0;
+    return h;
+  }
+
+ private:
+  std::string ident_ = "PKG1";
+  std::string copyright_ = DEFAULT_WZ_HEADER_COPYRIGHT;
+  uint64_t fsize_ = 0;
+  uint32_t fstart_ = 60;
+};
+
+}  // namespace wz
+#endif  // WZ_WZHEADER_H_