// This file is part of ClassicAPI.
//
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software Foundation, either
// version 3 of the License, or (at your option) any later version.
//
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// ClassicAPI. If not, see .
// `C_EncodingUtil.EncodeBase64` / `DecodeBase64`, with `Base64Variant`
// parity. Modern WoW's enum:
//
// Enum.Base64Variant = { Standard = 0, UrlSafe = 1 }
//
// - Standard (RFC 4648 §4): `+`/`/` alphabet, `=` padding required.
// - UrlSafe (RFC 4648 §5): `-`/`_` alphabet, `=` padding omitted on
// encode but tolerated on decode.
#include "Game.h"
#include
#include
namespace Encoding::Base64 {
namespace {
enum class Variant : int {
Standard = 0,
UrlSafe = 1,
};
constexpr const char kStandardAlphabet[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
constexpr const char kUrlSafeAlphabet[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
const char *AlphabetFor(Variant v) {
return v == Variant::UrlSafe ? kUrlSafeAlphabet : kStandardAlphabet;
}
// Decode a single base64 character to its 6-bit value, or -1 if it's
// not in the requested alphabet (or not in either, when `accept` is
// nullopt). `strict` toggles whether to require the variant's exact
// alphabet vs accept both — used to give the no-variant decode form
// lenient input handling.
int DecodeChar(char c, Variant v, bool strict) {
if (c >= 'A' && c <= 'Z') return c - 'A';
if (c >= 'a' && c <= 'z') return 26 + (c - 'a');
if (c >= '0' && c <= '9') return 52 + (c - '0');
if (c == '+') return (strict && v != Variant::Standard) ? -1 : 62;
if (c == '-') return (strict && v != Variant::UrlSafe) ? -1 : 62;
if (c == '/') return (strict && v != Variant::Standard) ? -1 : 63;
if (c == '_') return (strict && v != Variant::UrlSafe) ? -1 : 63;
return -1;
}
int OptionalVariantArg(void *L, int idx, Variant def, bool &outProvided) {
outProvided = false;
if (Game::Lua::Type(L, idx) != Game::Lua::TYPE_NUMBER)
return static_cast(def);
outProvided = true;
return static_cast(Game::Lua::ToNumber(L, idx));
}
int __fastcall Script_EncodeBase64(void *L) {
if (!Game::Lua::IsString(L, 1)) {
Game::Lua::Error(L,
"Usage: C_EncodingUtil.EncodeBase64(data [, variant])");
return 0;
}
const auto *src = reinterpret_cast(
Game::Lua::ToString(L, 1));
const unsigned int len = Game::Lua::StrLen(L, 1);
if (src == nullptr || len == 0) {
Game::Lua::PushString(L, "");
return 1;
}
bool _;
const int variantInt = OptionalVariantArg(L, 2, Variant::Standard, _);
if (variantInt < 0 || variantInt > 1) {
Game::Lua::Error(L,
"C_EncodingUtil.EncodeBase64: invalid Base64Variant");
return 0;
}
const Variant variant = static_cast(variantInt);
const char *alphabet = AlphabetFor(variant);
const bool padded = (variant == Variant::Standard);
std::vector out;
out.reserve(((len + 2) / 3) * 4);
unsigned int i = 0;
for (; i + 3 <= len; i += 3) {
const uint32_t v = (static_cast(src[i]) << 16) |
(static_cast(src[i + 1]) << 8) |
static_cast(src[i + 2]);
out.push_back(alphabet[(v >> 18) & 0x3F]);
out.push_back(alphabet[(v >> 12) & 0x3F]);
out.push_back(alphabet[(v >> 6) & 0x3F]);
out.push_back(alphabet[v & 0x3F]);
}
const unsigned int rem = len - i;
if (rem == 1) {
const uint32_t v = static_cast(src[i]) << 16;
out.push_back(alphabet[(v >> 18) & 0x3F]);
out.push_back(alphabet[(v >> 12) & 0x3F]);
if (padded) { out.push_back('='); out.push_back('='); }
} else if (rem == 2) {
const uint32_t v = (static_cast(src[i]) << 16) |
(static_cast(src[i + 1]) << 8);
out.push_back(alphabet[(v >> 18) & 0x3F]);
out.push_back(alphabet[(v >> 12) & 0x3F]);
out.push_back(alphabet[(v >> 6) & 0x3F]);
if (padded) out.push_back('=');
}
Game::Lua::PushLString(L, out.data(),
static_cast(out.size()));
return 1;
}
int __fastcall Script_DecodeBase64(void *L) {
if (!Game::Lua::IsString(L, 1)) {
Game::Lua::Error(L,
"Usage: C_EncodingUtil.DecodeBase64(data [, variant])");
return 0;
}
const char *src = Game::Lua::ToString(L, 1);
const unsigned int len = Game::Lua::StrLen(L, 1);
if (src == nullptr || len == 0) {
Game::Lua::PushString(L, "");
return 1;
}
bool variantProvided;
const int variantInt = OptionalVariantArg(L, 2, Variant::Standard,
variantProvided);
if (variantInt < 0 || variantInt > 1) {
Game::Lua::Error(L,
"C_EncodingUtil.DecodeBase64: invalid Base64Variant");
return 0;
}
const Variant variant = static_cast(variantInt);
// Strict when the caller named a variant; lenient (accept both
// alphabets, optional padding) when no variant was passed.
const bool strict = variantProvided;
// Strip a trailing run of `=` to normalize. Standard variant must
// have produced length-multiple-of-4 before strip; UrlSafe is
// allowed unpadded.
unsigned int effective = len;
while (effective > 0 && src[effective - 1] == '=')
--effective;
const unsigned int padCount = len - effective;
if (strict && variant == Variant::Standard) {
if ((len & 3) != 0)
return 0; // Standard requires length multiple of 4
if (padCount > 2)
return 0;
} else {
if (padCount > 2)
return 0;
}
std::vector out;
out.reserve((effective / 4) * 3 + 3);
unsigned int i = 0;
for (; i + 4 <= effective; i += 4) {
const int v0 = DecodeChar(src[i], variant, strict);
const int v1 = DecodeChar(src[i + 1], variant, strict);
const int v2 = DecodeChar(src[i + 2], variant, strict);
const int v3 = DecodeChar(src[i + 3], variant, strict);
if ((v0 | v1 | v2 | v3) < 0)
return 0;
out.push_back(static_cast((v0 << 2) | (v1 >> 4)));
out.push_back(static_cast((v1 << 4) | (v2 >> 2)));
out.push_back(static_cast((v2 << 6) | v3));
}
// Tail: 0, 2, or 3 unpadded characters.
const unsigned int tail = effective - i;
if (tail == 1)
return 0; // never valid
if (tail >= 2) {
const int v0 = DecodeChar(src[i], variant, strict);
const int v1 = DecodeChar(src[i + 1], variant, strict);
if ((v0 | v1) < 0)
return 0;
out.push_back(static_cast((v0 << 2) | (v1 >> 4)));
if (tail == 3) {
const int v2 = DecodeChar(src[i + 2], variant, strict);
if (v2 < 0)
return 0;
out.push_back(static_cast((v1 << 4) | (v2 >> 2)));
}
}
Game::Lua::PushLString(L, out.data(),
static_cast(out.size()));
return 1;
}
void Register() {
Game::Lua::RegisterTableFunction("C_EncodingUtil", "EncodeBase64",
&Script_EncodeBase64);
Game::Lua::RegisterTableFunction("C_EncodingUtil", "DecodeBase64",
&Script_DecodeBase64);
static const Game::Lua::EnumIntegerEntry kBase64Variant[] = {
{"Standard", static_cast(Variant::Standard)},
{"UrlSafe", static_cast(Variant::UrlSafe)},
};
Game::Lua::RegisterIntegerEnum("Enum", "Base64Variant",
kBase64Variant, 2);
}
} // namespace
static const Game::ModuleAutoRegister _autoreg{&Register};
} // namespace Encoding::Base64