libwz 0.1.0

package/src/Util/WzDataSource.cpp

@@ -0,0 +1,61 @@
+#include "wz/Util/WzDataSource.h"
+
+#include <algorithm>
+#include <cstring>
+#include <utility>
+
+namespace wz {
+
+WzFileDataSource::WzFileDataSource(WzFileStream* input)
+    : input_(input),
+      size_(input_ && input_->Size() > 0 ? static_cast<uint64_t>(input_->Size())
+                                         : 0) {}
+
+Result<size_t> WzFileDataSource::ReadAt(uint64_t offset,
+                                        std::span<uint8_t> destination) {
+  if (!input_ || !input_->IsOpen()) {
+    return std::unexpected(Error::IoError("Source file is not open"));
+  }
+  if (offset > size_) {
+    return std::unexpected(Error::IoError("Read offset is beyond source size"));
+  }
+
+  const uint64_t available = size_ - offset;
+  const size_t count = static_cast<size_t>(
+      std::min<uint64_t>(available, static_cast<uint64_t>(destination.size())));
+  if (count == 0) return 0;
+
+  if (!input_->Seek(static_cast<int64_t>(offset), WzSeekOrigin::Begin)) {
+    return std::unexpected(Error::IoError("Failed to seek source file"));
+  }
+
+  if (input_->Read(destination.data(), count) != count) {
+    return std::unexpected(Error::IoError("Failed to read source file"));
+  }
+  return count;
+}
+
+uint64_t WzFileDataSource::Size() const {
+  return size_;
+}
+
+WzMemoryDataSource::WzMemoryDataSource(std::vector<uint8_t> data)
+    : data_(std::move(data)) {}
+
+Result<size_t> WzMemoryDataSource::ReadAt(uint64_t offset,
+                                          std::span<uint8_t> destination) {
+  if (offset > data_.size()) {
+    return std::unexpected(Error::IoError("Read offset is beyond source size"));
+  }
+
+  const size_t index = static_cast<size_t>(offset);
+  const size_t count = std::min(destination.size(), data_.size() - index);
+  if (count > 0) std::memcpy(destination.data(), data_.data() + index, count);
+  return count;
+}
+
+uint64_t WzMemoryDataSource::Size() const {
+  return data_.size();
+}
+
+}  // namespace wz

package/src/Util/WzKeyGenerator.cpp

@@ -0,0 +1,43 @@
+#include "wz/Util/WzKeyGenerator.h"
+#include "wz/WzAESConstant.h"
+
+namespace wz {
+
+const std::array<uint8_t, 128> MAPLESTORY_USERKEY_DEFAULT = {
+    0x13, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x5B, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0xB4, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x5F, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0x50, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0xDE, 0x00, 0x00, 0x00,
+    0xC7, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00};
+
+std::array<uint8_t, 32> GetTrimmedUserKey(
+    const std::array<uint8_t, 128>& userKey) {
+  std::array<uint8_t, 32> key{};
+  for (int i = 0; i < 128; i += 16) {
+    key[i / 4] = userKey[i];
+  }
+  return key;
+}
+
+WzMutableKey WzKeyGenerator::GenerateWzKey(const std::array<uint8_t, 4>& WzIv) {
+  return WzMutableKey(WzIv, GetTrimmedUserKey(MAPLESTORY_USERKEY_DEFAULT));
+}
+
+WzMutableKey WzKeyGenerator::GenerateLuaWzKey() {
+  return WzMutableKey(WzAESConstant::WZ_MSEAIV,
+                      GetTrimmedUserKey(MAPLESTORY_USERKEY_DEFAULT));
+}
+
+WzMutableKey WzKeyGenerator::GenerateWzKey(
+    const std::array<uint8_t, 4>& WzIv,
+    const std::array<uint8_t, 128>& AesUserKey) {
+  return WzMutableKey(WzIv, GetTrimmedUserKey(AesUserKey));
+}
+
+}  // namespace wz

package/src/Util/WzMutableKey.cpp

@@ -0,0 +1,59 @@
+#include "wz/Util/WzMutableKey.h"
+#include <cstring>
+#include <aes.hpp>
+
+namespace wz {
+
+WzMutableKey::WzMutableKey(const std::array<uint8_t, 4>& iv,
+                           const std::array<uint8_t, 32>& aesKey)
+    : iv_(iv), aesKey_(aesKey) {}
+
+uint8_t WzMutableKey::operator[](size_t index) const {
+  const_cast<WzMutableKey*>(this)->EnsureKeySize(index + 1);
+  return keys_[index];
+}
+
+std::vector<uint8_t> WzMutableKey::GetKeys() const {
+  if (keys_.empty()) return {};
+  return {keys_.begin(), keys_.begin() + std::min(size_t(4), keys_.size())};
+}
+
+void WzMutableKey::EnsureKeySize(size_t size) {
+  if (!keys_.empty() && keys_.size() >= size) return;
+
+  size = ((size + BatchSize - 1) / BatchSize) * BatchSize;
+  std::vector<uint8_t> newKeys(size, 0);
+
+  if (iv_[0] == 0 && iv_[1] == 0 && iv_[2] == 0 && iv_[3] == 0) {
+    keys_ = std::move(newKeys);
+    return;
+  }
+
+  size_t startIndex = 0;
+  if (!keys_.empty()) {
+    std::copy(keys_.begin(), keys_.end(), newKeys.begin());
+    startIndex = keys_.size();
+  }
+
+  struct AES_ctx ctx;
+  AES_init_ctx(&ctx, aesKey_.data());
+
+  uint8_t block[16];
+  for (size_t i = startIndex; i < size; i += 16) {
+    if (i == 0) {
+      for (int j = 0; j < 16; j++) block[j] = iv_[j % 4];
+    } else {
+      std::memcpy(block, newKeys.data() + i - 16, 16);
+    }
+    AES_ECB_encrypt(&ctx, block);
+    std::memcpy(newKeys.data() + i, block, 16);
+  }
+
+  keys_ = std::move(newKeys);
+}
+
+bool WzMutableKey::operator==(const WzMutableKey& other) const {
+  return iv_ == other.iv_ && aesKey_ == other.aesKey_;
+}
+
+}  // namespace wz

package/src/Util/WzStream.cpp

@@ -0,0 +1,196 @@
+#include "wz/Util/WzStream.h"
+
+#include <algorithm>
+#include <cstring>
+#include <limits>
+#include <utility>
+
+namespace wz {
+
+namespace {
+
+FILE* OpenFilePath(const std::filesystem::path& path, const char* mode) {
+#ifdef _WIN32
+  std::wstring wideMode;
+  for (const char* p = mode; *p != '\0'; ++p) {
+    wideMode.push_back(static_cast<wchar_t>(*p));
+  }
+  return _wfopen(path.wstring().c_str(), wideMode.c_str());
+#else
+  return std::fopen(path.string().c_str(), mode);
+#endif
+}
+
+int SeekOriginToC(WzSeekOrigin origin) {
+  switch (origin) {
+    case WzSeekOrigin::Begin:
+      return SEEK_SET;
+    case WzSeekOrigin::Current:
+      return SEEK_CUR;
+    case WzSeekOrigin::End:
+      return SEEK_END;
+  }
+  return SEEK_SET;
+}
+
+bool FileSeek(FILE* file, int64_t offset, WzSeekOrigin origin) {
+#ifdef _WIN32
+  return _fseeki64(file, offset, SeekOriginToC(origin)) == 0;
+#else
+  return fseeko(file, static_cast<off_t>(offset), SeekOriginToC(origin)) == 0;
+#endif
+}
+
+int64_t FileTell(FILE* file) {
+#ifdef _WIN32
+  return static_cast<int64_t>(_ftelli64(file));
+#else
+  return static_cast<int64_t>(ftello(file));
+#endif
+}
+
+}  // namespace
+
+bool WzStream::WriteByte(uint8_t value) {
+  return Write(&value, sizeof(value));
+}
+
+WzFileStream::WzFileStream(const std::filesystem::path& path,
+                           const char* mode) {
+  Open(path, mode);
+}
+
+WzFileStream::~WzFileStream() {
+  Close();
+}
+
+WzFileStream::WzFileStream(WzFileStream&& other) noexcept
+    : file_(other.file_), size_(other.size_) {
+  other.file_ = nullptr;
+  other.size_ = 0;
+}
+
+WzFileStream& WzFileStream::operator=(WzFileStream&& other) noexcept {
+  if (this != &other) {
+    Close();
+    file_ = other.file_;
+    size_ = other.size_;
+    other.file_ = nullptr;
+    other.size_ = 0;
+  }
+  return *this;
+}
+
+bool WzFileStream::Open(const std::filesystem::path& path, const char* mode) {
+  Close();
+  file_ = OpenFilePath(path, mode);
+  if (!file_) {
+    size_ = 0;
+    return false;
+  }
+  return RefreshSize();
+}
+
+void WzFileStream::Close() {
+  if (file_) {
+    std::fclose(file_);
+    file_ = nullptr;
+  }
+  size_ = 0;
+}
+
+size_t WzFileStream::Read(void* destination, size_t count) {
+  if (!file_ || count == 0) return 0;
+  return std::fread(destination, 1, count, file_);
+}
+
+bool WzFileStream::Write(const void* data, size_t count) {
+  if (!file_) return false;
+  if (count == 0) return true;
+  if (std::fwrite(data, 1, count, file_) != count) return false;
+  const int64_t position = Position();
+  if (position > size_) size_ = position;
+  return true;
+}
+
+bool WzFileStream::Seek(int64_t offset, WzSeekOrigin origin) {
+  return file_ && FileSeek(file_, offset, origin);
+}
+
+int64_t WzFileStream::Position() const {
+  if (!file_) return -1;
+  return FileTell(file_);
+}
+
+bool WzFileStream::Flush() {
+  return file_ && std::fflush(file_) == 0;
+}
+
+bool WzFileStream::RefreshSize() {
+  if (!file_) return false;
+  const int64_t original = Position();
+  if (original < 0) return false;
+  if (!Seek(0, WzSeekOrigin::End)) return false;
+  size_ = Position();
+  return Seek(original, WzSeekOrigin::Begin);
+}
+
+WzMemoryStream::WzMemoryStream(std::vector<uint8_t> data)
+    : buffer_(std::move(data)) {}
+
+size_t WzMemoryStream::Read(void* destination, size_t count) {
+  if (count == 0 || position_ < 0) return 0;
+  const int64_t size = Size();
+  if (position_ >= size) return 0;
+  const size_t available = static_cast<size_t>(size - position_);
+  const size_t toRead = std::min(count, available);
+  std::memcpy(destination, buffer_.data() + position_, toRead);
+  position_ += static_cast<int64_t>(toRead);
+  return toRead;
+}
+
+bool WzMemoryStream::Write(const void* data, size_t count) {
+  if (position_ < 0) return false;
+  if (count == 0) return true;
+  if (count >
+      static_cast<size_t>(std::numeric_limits<int64_t>::max() - position_)) {
+    return false;
+  }
+  const int64_t end = position_ + static_cast<int64_t>(count);
+  if (end > Size()) {
+    buffer_.resize(static_cast<size_t>(end));
+  }
+  std::memcpy(buffer_.data() + position_, data, count);
+  position_ = end;
+  return true;
+}
+
+bool WzMemoryStream::Seek(int64_t offset, WzSeekOrigin origin) {
+  int64_t base = 0;
+  switch (origin) {
+    case WzSeekOrigin::Begin:
+      base = 0;
+      break;
+    case WzSeekOrigin::Current:
+      base = position_;
+      break;
+    case WzSeekOrigin::End:
+      base = Size();
+      break;
+  }
+  if ((offset > 0 && base > std::numeric_limits<int64_t>::max() - offset) ||
+      (offset < 0 && base < std::numeric_limits<int64_t>::min() - offset)) {
+    return false;
+  }
+  const int64_t next = base + offset;
+  if (next < 0) return false;
+  position_ = next;
+  return true;
+}
+
+void WzMemoryStream::Close() {
+  buffer_.clear();
+  position_ = 0;
+}
+
+}  // namespace wz

package/src/Util/WzTool.cpp

@@ -0,0 +1,266 @@
+#include "wz/Util/WzTool.h"
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include "wz/Util/WzPath.h"
+#include "wz/Util/WzStream.h"
+#include "wz/WzAESConstant.h"
+#include "wz/WzDirectory.h"
+#include "wz/WzFile.h"
+#include "wz/WzImage.h"
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#endif
+
+namespace wz {
+
+namespace {
+
+std::unordered_set<std::string> objectValueLengthCache;
+
+struct EncodedStringInfo {
+  bool needsUnicode = false;
+  int utf16CodeUnits = 0;
+};
+
+EncodedStringInfo GetEncodedStringInfo(const std::string& value) {
+  EncodedStringInfo result;
+  for (size_t i = 0; i < value.size();) {
+    uint8_t ch = static_cast<uint8_t>(value[i]);
+    uint32_t codePoint = 0;
+    size_t extraBytes = 0;
+
+    if ((ch & 0x80) == 0) {
+      codePoint = ch;
+    } else if ((ch & 0xE0) == 0xC0) {
+      codePoint = ch & 0x1F;
+      extraBytes = 1;
+    } else if ((ch & 0xF0) == 0xE0) {
+      codePoint = ch & 0x0F;
+      extraBytes = 2;
+    } else if ((ch & 0xF8) == 0xF0) {
+      codePoint = ch & 0x07;
+      extraBytes = 3;
+    } else {
+      result.needsUnicode = result.needsUnicode || ch > INT8_MAX;
+      ++result.utf16CodeUnits;
+      ++i;
+      continue;
+    }
+
+    if (i + extraBytes >= value.size()) {
+      result.needsUnicode = result.needsUnicode || ch > INT8_MAX;
+      ++result.utf16CodeUnits;
+      ++i;
+      continue;
+    }
+
+    bool valid = true;
+    for (size_t j = 1; j <= extraBytes; ++j) {
+      uint8_t next = static_cast<uint8_t>(value[i + j]);
+      if ((next & 0xC0) != 0x80) {
+        valid = false;
+        break;
+      }
+      codePoint = (codePoint << 6) | (next & 0x3F);
+    }
+
+    if (!valid) {
+      result.needsUnicode = result.needsUnicode || ch > INT8_MAX;
+      ++result.utf16CodeUnits;
+      ++i;
+      continue;
+    }
+
+    result.needsUnicode = result.needsUnicode || codePoint > INT8_MAX;
+    result.utf16CodeUnits += codePoint <= 0xFFFF ? 1 : 2;
+    i += extraBytes + 1;
+  }
+  return result;
+}
+
+}  // namespace
+
+#ifdef _WIN32
+std::filesystem::path WzTool::ToPath(const std::string& utf8_path) {
+  if (utf8_path.empty()) return {};
+  // MB_ERR_INVALID_CHARS: fails if the input is not valid UTF-8.
+  // This lets us detect and fall back to ANSI (GBK etc.) gracefully.
+  int n = MultiByteToWideChar(CP_UTF8,
+                              MB_ERR_INVALID_CHARS,
+                              utf8_path.c_str(),
+                              static_cast<int>(utf8_path.size()),
+                              nullptr,
+                              0);
+  if (n <= 0) {
+    // Not valid UTF-8 — treat as system ANSI code page
+    return std::filesystem::path(utf8_path);
+  }
+  std::wstring w(static_cast<size_t>(n), L'\0');
+  MultiByteToWideChar(CP_UTF8,
+                      0,
+                      utf8_path.c_str(),
+                      static_cast<int>(utf8_path.size()),
+                      &w[0],
+                      n);
+  return std::filesystem::path(w);
+}
+#endif
+
+uint32_t WzTool::RotateLeft(uint32_t x, uint8_t n) {
+  n &= 0x1F;
+  if (n == 0) return x;
+  return static_cast<uint32_t>((x << n) | (x >> (32 - n)));
+}
+
+uint32_t WzTool::RotateRight(uint32_t x, uint8_t n) {
+  n &= 0x1F;
+  if (n == 0) return x;
+  return static_cast<uint32_t>((x >> n) | (x << (32 - n)));
+}
+
+int WzTool::GetCompressedIntLength(int i) {
+  if (i > 127 || i < -127) return 5;
+  return 1;
+}
+
+int WzTool::GetEncodedStringLength(const std::string& s) {
+  if (s.empty()) return 1;
+
+  EncodedStringInfo info = GetEncodedStringInfo(s);
+  int length =
+      info.needsUnicode ? info.utf16CodeUnits : static_cast<int>(s.length());
+  int prefixLength = length > (info.needsUnicode ? 126 : 127) ? 5 : 1;
+  int encodedLength = info.needsUnicode ? info.utf16CodeUnits * 2
+                                        : static_cast<int>(s.length());
+  return prefixLength + encodedLength;
+}
+
+int WzTool::GetWzObjectValueLength(const std::string& s, uint8_t type) {
+  std::string storeName = std::to_string(type) + "_" + s;
+  if (s.length() > 4 && objectValueLengthCache.contains(storeName)) {
+    return 5;
+  }
+  objectValueLengthCache.insert(std::move(storeName));
+  return 1 + GetEncodedStringLength(s);
+}
+
+void WzTool::ClearWzObjectValueLengthCache() {
+  objectValueLengthCache.clear();
+}
+
+std::array<uint8_t, 4> WzTool::GetIvByMapleVersion(WzMapleVersion ver) {
+  switch (ver) {
+    case WzMapleVersion::EMS:
+      return WzAESConstant::WZ_MSEAIV;
+    case WzMapleVersion::GMS:
+      return WzAESConstant::WZ_GMSIV;
+    case WzMapleVersion::GENERATE:
+      return {0, 0, 0, 0};
+    case WzMapleVersion::BMS:
+    case WzMapleVersion::CLASSIC:
+    case WzMapleVersion::CUSTOM:
+    default:
+      return WzAESConstant::WZ_BMSCLASSIC;
+  }
+}
+
+int WzTool::GetRecognizedCharacters(const std::string& source) {
+  int count = 0;
+  for (char c : source) {
+    if (c >= 0x20 && c <= 0x7E) count++;
+  }
+  return count;
+}
+
+double WzTool::GetDecryptionSuccessRate(const std::string& wzPath,
+                                        WzMapleVersion encVersion,
+                                        int16_t* version) {
+  std::unique_ptr<WzFile> wzf;
+  if (version == nullptr || *version == 0) {
+    wzf = std::make_unique<WzFile>(wzPath, encVersion);
+  } else {
+    wzf = std::make_unique<WzFile>(wzPath, *version, encVersion);
+  }
+
+  WzFileParseStatus parseStatus = wzf->ParseWzFile();
+  if (parseStatus != WzFileParseStatus::Success) {
+    return 0.0;
+  }
+
+  if (version) *version = wzf->Version();
+  int recognizedChars = 0;
+  int totalChars = 0;
+  WzDirectory* wzDir = wzf->GetWzDirectory();
+  if (wzDir) {
+    for (WzDirectory* d : wzDir->WzDirectories()) {
+      recognizedChars += GetRecognizedCharacters(d->Name());
+      totalChars += static_cast<int>(d->Name().length());
+    }
+    for (WzImage* img : wzDir->WzImages()) {
+      recognizedChars += GetRecognizedCharacters(img->Name());
+      totalChars += static_cast<int>(img->Name().length());
+    }
+  }
+  if (totalChars == 0) return 0.0;
+  return static_cast<double>(recognizedChars) / static_cast<double>(totalChars);
+}
+
+WzMapleVersion WzTool::DetectMapleVersion(const std::string& wzFilePath,
+                                          int16_t* fileVersion) {
+  int16_t version = 0;
+  double gmsRate =
+      GetDecryptionSuccessRate(wzFilePath, WzMapleVersion::GMS, &version);
+  double emsRate =
+      GetDecryptionSuccessRate(wzFilePath, WzMapleVersion::EMS, &version);
+  double bmsRate =
+      GetDecryptionSuccessRate(wzFilePath, WzMapleVersion::BMS, &version);
+
+  if (fileVersion) *fileVersion = version;
+
+  WzMapleVersion bestVersion = WzMapleVersion::GMS;
+  double maxRate = 0;
+  if (gmsRate > maxRate) {
+    maxRate = gmsRate;
+    bestVersion = WzMapleVersion::GMS;
+  }
+  if (emsRate > maxRate) {
+    maxRate = emsRate;
+    bestVersion = WzMapleVersion::EMS;
+  }
+  if (bmsRate > maxRate) {
+    maxRate = bmsRate;
+    bestVersion = WzMapleVersion::BMS;
+  }
+
+  if (maxRate < 0.7) {
+    std::string zlzPath =
+        (wz::to_path(wzFilePath).parent_path() / "ZLZ.dll").string();
+    if (std::filesystem::exists(wz::to_path(zlzPath)))
+      return WzMapleVersion::GETFROMZLZ;
+  }
+  return bestVersion;
+}
+
+bool WzTool::IsListFile(const std::string& path) {
+  WzFileStream reader;
+  if (!reader.Open(wz::to_path(path), "rb")) return false;
+  int32_t header = 0;
+  if (reader.Read(&header, sizeof(header)) != sizeof(header)) return false;
+  return header != WZ_HEADER;
+}
+
+bool WzTool::IsDataWzHotfixFile(const std::string& path) {
+  WzFileStream reader;
+  if (!reader.Open(wz::to_path(path), "rb")) return false;
+  uint8_t firstByte = 0;
+  if (reader.Read(&firstByte, sizeof(firstByte)) != sizeof(firstByte))
+    return false;
+  return firstByte == WzImage::WzImageHeaderByte_WithoutOffset;
+}
+
+}  // namespace wz

package/src/WzAESConstant.cpp

@@ -0,0 +1,12 @@
+#include "wz/WzAESConstant.h"
+
+namespace wz {
+
+const std::array<uint8_t, 4> WzAESConstant::WZ_GMSIV = {0x4D, 0x23, 0xC7, 0x2B};
+const std::array<uint8_t, 4> WzAESConstant::WZ_MSEAIV = {
+    0xB9, 0x7D, 0x63, 0xE9};
+const std::array<uint8_t, 4> WzAESConstant::WZ_BMSCLASSIC = {
+    0x00, 0x00, 0x00, 0x00};
+const uint32_t WzAESConstant::WZ_OffsetConstant = 0x581C3F6D;
+
+}  // namespace wz