mirror of
https://github.com/MihailRis/voxelcore.git
synced 2026-11-21 09:59:44 +00:00
Merge branch 'MihailRis:main' into main
This commit is contained in:
commit
2c3c217fef
71 changed files with 3978 additions and 786 deletions
|
|
@ -25,6 +25,7 @@ extern const luaL_Reg byteutillib[];
|
|||
extern const luaL_Reg cameralib[];
|
||||
extern const luaL_Reg consolelib[];
|
||||
extern const luaL_Reg corelib[];
|
||||
extern const luaL_Reg cryptolib[];
|
||||
extern const luaL_Reg entitylib[];
|
||||
extern const luaL_Reg filelib[];
|
||||
extern const luaL_Reg generationlib[];
|
||||
|
|
@ -93,3 +94,4 @@ namespace lua {
|
|||
}
|
||||
|
||||
void initialize_libs_extends(lua::State* L);
|
||||
void initialize_cryptolib(lua::State* L);
|
||||
|
|
|
|||
|
|
@ -147,8 +147,19 @@ static int l_set_visible(lua::State* L) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static glm::vec4 to_color(lua::State* L, int idx) {
|
||||
if (lua::objlen(L, idx) > 3) {
|
||||
return lua::tovec4(L, idx);
|
||||
}
|
||||
return glm::vec4(lua::tovec3(L, idx), 1.0f);
|
||||
}
|
||||
|
||||
static int l_get_color(lua::State* L) {
|
||||
if (auto skeleton = get_skeleton(L)) {
|
||||
if (lua::isnumber(L, 2)) {
|
||||
auto index = index_range_check(*skeleton, lua::tointeger(L, 2));
|
||||
return lua::pushvec(L, skeleton->boneTints[index]);
|
||||
}
|
||||
return lua::pushvec(L, skeleton->tint);
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -156,7 +167,13 @@ static int l_get_color(lua::State* L) {
|
|||
|
||||
static int l_set_color(lua::State* L) {
|
||||
if (auto skeleton = get_skeleton(L)) {
|
||||
skeleton->tint = lua::tovec3(L, 2);
|
||||
auto color = to_color(L, 2);
|
||||
if (lua::isnumber(L, 3)) {
|
||||
auto index = index_range_check(*skeleton, lua::tointeger(L, 3));
|
||||
skeleton->boneTints[index] = color;
|
||||
} else {
|
||||
skeleton->tint = color;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,11 @@ static int l_wrap(lua::State* L) {
|
|||
auto position = lua::tovec3(L, 1);
|
||||
std::string texture = lua::require_string(L, 2);
|
||||
float emission = lua::isnumber(L, 3) ? lua::tonumber(L, 3) : 1.0f;
|
||||
glm::vec3 tint = lua::istable(L, 4) ? lua::tovec3(L, 4) : glm::vec3(1.0f);
|
||||
glm::vec4 tint =
|
||||
lua::istable(L, 4)
|
||||
? (lua::objlen(L, 4) > 3 ? lua::tovec4(L, 4)
|
||||
: glm::vec4(lua::tovec3(L, 4), 1.0f))
|
||||
: glm::vec4(1.0f);
|
||||
|
||||
return lua::pushinteger(
|
||||
L,
|
||||
|
|
@ -72,9 +76,12 @@ static int l_set_tints(lua::State* L) {
|
|||
if (auto wrapper = renderer->blockWraps->get(lua::tointeger(L, 1))) {
|
||||
for (int i = 0; i < wrapper->textureFaces.size(); i++) {
|
||||
if (lua::isnil(L, 2 + i)) {
|
||||
wrapper->tints[i] = glm::vec3(1.0f);
|
||||
wrapper->tints[i] = glm::vec4(1.0f);
|
||||
} else {
|
||||
wrapper->tints[i] = lua::tovec3(L, 2 + i);
|
||||
wrapper->tints[i] =
|
||||
lua::objlen(L, 2 + i) > 3
|
||||
? lua::tovec4(L, 2 + i)
|
||||
: glm::vec4(lua::tovec3(L, 2 + i), 1.0f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
540
src/logic/scripting/lua/libs/libcrypto.cpp
Normal file
540
src/logic/scripting/lua/libs/libcrypto.cpp
Normal file
|
|
@ -0,0 +1,540 @@
|
|||
#include <climits>
|
||||
#include <cstdint>
|
||||
#include <new>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
|
||||
#include "api_lua.hpp"
|
||||
#include "crypto/Crypto.hpp"
|
||||
|
||||
namespace {
|
||||
using HashContext = crypto::HashContext;
|
||||
|
||||
constexpr const char* HASH_CONTEXT_METATABLE =
|
||||
"voxelcore.crypto.HashContext";
|
||||
|
||||
int pushBytes(lua::State* L, const crypto::Bytes& value) {
|
||||
return lua::pushlstring(L, value.data(), value.size());
|
||||
}
|
||||
|
||||
int pushFailure(lua::State* L, bool nil, const char* error) {
|
||||
nil ? lua::pushnil(L) : lua::pushboolean(L, false);
|
||||
lua::pushstring(L, error);
|
||||
return 2;
|
||||
}
|
||||
|
||||
int pushKeyPair(lua::State* L, const crypto::KeyPair& keyPair) {
|
||||
pushBytes(L, keyPair.privateKey);
|
||||
pushBytes(L, keyPair.publicKey);
|
||||
return 2;
|
||||
}
|
||||
|
||||
template <typename Operation>
|
||||
int verify(lua::State* L, Operation operation) {
|
||||
try {
|
||||
if (operation()) return lua::pushboolean(L, true);
|
||||
return pushFailure(L, false, "invalid_signature");
|
||||
} catch (const crypto::Error& error) {
|
||||
return pushFailure(L, false, error.codeName());
|
||||
} catch (const std::exception& error) {
|
||||
return pushFailure(L, false, "backend_error");
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Operation>
|
||||
int decrypt(lua::State* L, Operation operation) {
|
||||
try {
|
||||
return pushBytes(L, operation());
|
||||
} catch (const crypto::Error& error) {
|
||||
return pushFailure(L, true, error.codeName());
|
||||
} catch (const std::exception& error) {
|
||||
return pushFailure(L, true, "backend_error");
|
||||
}
|
||||
}
|
||||
|
||||
std::size_t requireSize(lua::State* L, int index, const char* name) {
|
||||
if (lua::type(L, index) != LUA_TNUMBER) {
|
||||
throw std::runtime_error(std::string(name) + " must be a number");
|
||||
}
|
||||
const lua::Number number = lua::tonumber(L, index);
|
||||
const lua::Integer value = lua::tointeger(L, index);
|
||||
if (number != static_cast<lua::Number>(value)) {
|
||||
throw std::runtime_error(std::string(name) + " must be an integer");
|
||||
}
|
||||
if (value < 0) {
|
||||
throw std::runtime_error(
|
||||
std::string(name) + " must be non-negative"
|
||||
);
|
||||
}
|
||||
return static_cast<std::size_t>(value);
|
||||
}
|
||||
|
||||
int requireInt(lua::State* L, int index, const char* name) {
|
||||
if (lua::type(L, index) != LUA_TNUMBER) {
|
||||
throw std::runtime_error(std::string(name) + " must be a number");
|
||||
}
|
||||
const lua::Number number = lua::tonumber(L, index);
|
||||
const lua::Integer value = lua::tointeger(L, index);
|
||||
if (number != static_cast<lua::Number>(value)) {
|
||||
throw std::runtime_error(std::string(name) + " must be an integer");
|
||||
}
|
||||
if (value < INT_MIN || value > INT_MAX) {
|
||||
throw std::runtime_error(std::string(name) + " is out of range");
|
||||
}
|
||||
return static_cast<int>(value);
|
||||
}
|
||||
|
||||
int hash(lua::State* L, std::string_view name) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushBytes(L, crypto::digest(name, lua::require_lstring(L, 1)));
|
||||
}
|
||||
|
||||
int l_sha256(lua::State* L) {
|
||||
return hash(L, "SHA256");
|
||||
}
|
||||
int l_sha384(lua::State* L) {
|
||||
return hash(L, "SHA384");
|
||||
}
|
||||
int l_sha512(lua::State* L) {
|
||||
return hash(L, "SHA512");
|
||||
}
|
||||
int l_md5(lua::State* L) {
|
||||
return hash(L, "MD5");
|
||||
}
|
||||
|
||||
int l_hash(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::digest(
|
||||
lua::require_lstring(L, 1), lua::require_lstring(L, 2)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
crypto::HashContext* requireHashContext(lua::State* L) {
|
||||
return static_cast<crypto::HashContext*>(
|
||||
luaL_checkudata(L, 1, HASH_CONTEXT_METATABLE)
|
||||
);
|
||||
}
|
||||
|
||||
int l_hash_context_gc(lua::State* L) {
|
||||
requireHashContext(L)->~HashContext();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int l_hash_context_update(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
requireHashContext(L)->update(lua::require_lstring(L, 2));
|
||||
lua::pushvalue(L, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int l_hash_context_final(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushBytes(L, requireHashContext(L)->final());
|
||||
}
|
||||
|
||||
int l_hash_context_reset(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
requireHashContext(L)->reset();
|
||||
lua::pushvalue(L, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
void ensureHashContextMetatable(lua::State* L) {
|
||||
if (luaL_newmetatable(L, HASH_CONTEXT_METATABLE)) {
|
||||
lua::pushcfunction(L, lua::wrap<l_hash_context_gc>);
|
||||
lua::setfield(L, "__gc");
|
||||
lua::pushcfunction(L, lua::wrap<l_hash_context_update>);
|
||||
lua::setfield(L, "update");
|
||||
lua::pushcfunction(L, lua::wrap<l_hash_context_final>);
|
||||
lua::setfield(L, "final");
|
||||
lua::pushcfunction(L, lua::wrap<l_hash_context_reset>);
|
||||
lua::setfield(L, "reset");
|
||||
lua::pushvalue(L, -1);
|
||||
lua::setfield(L, "__index");
|
||||
}
|
||||
lua::pop(L);
|
||||
}
|
||||
|
||||
int l_hash_new(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
const auto name = lua::require_lstring(L, 1);
|
||||
ensureHashContextMetatable(L);
|
||||
void* memory = lua_newuserdata(L, sizeof(crypto::HashContext));
|
||||
new (memory) crypto::HashContext(name);
|
||||
luaL_getmetatable(L, HASH_CONTEXT_METATABLE);
|
||||
lua_setmetatable(L, -2);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int l_hmac(lua::State* L) {
|
||||
lua::check_argc(L, 3);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::hmac(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_ed25519_verify(lua::State* L) {
|
||||
lua::check_argc(L, 3);
|
||||
const auto key = lua::require_lstring(L, 1);
|
||||
const auto message = lua::require_lstring(L, 2);
|
||||
const auto signature = lua::require_lstring(L, 3);
|
||||
return verify(L, [=] {
|
||||
return crypto::ed25519Verify(key, message, signature);
|
||||
});
|
||||
}
|
||||
|
||||
int l_ed25519_keypair(lua::State* L) {
|
||||
lua::check_argc(L, 0);
|
||||
return pushKeyPair(L, crypto::ed25519KeyPair());
|
||||
}
|
||||
|
||||
int l_ed25519_public(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushBytes(L, crypto::ed25519Public(lua::require_lstring(L, 1)));
|
||||
}
|
||||
|
||||
int l_ed25519_sign(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::ed25519Sign(
|
||||
lua::require_lstring(L, 1), lua::require_lstring(L, 2)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_ecdsa_verify(lua::State* L) {
|
||||
lua::check_argc(L, 5);
|
||||
const auto curve = lua::require_lstring(L, 1);
|
||||
const auto key = lua::require_lstring(L, 2);
|
||||
const auto message = lua::require_lstring(L, 3);
|
||||
const auto signature = lua::require_lstring(L, 4);
|
||||
const auto hashName = lua::require_lstring(L, 5);
|
||||
return verify(L, [=] {
|
||||
return crypto::ecdsaVerify(
|
||||
curve, key, message, signature, hashName
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
int l_ecdsa_keypair(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushKeyPair(L, crypto::ecdsaKeyPair(lua::require_lstring(L, 1)));
|
||||
}
|
||||
|
||||
int l_ecdsa_public(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::ecdsaPublic(
|
||||
lua::require_lstring(L, 1), lua::require_lstring(L, 2)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_ecdsa_sign(lua::State* L) {
|
||||
lua::check_argc(L, 4);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::ecdsaSign(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3),
|
||||
lua::require_lstring(L, 4)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_rsa_pkcs1_verify(lua::State* L) {
|
||||
lua::check_argc(L, 5);
|
||||
const auto hashName = lua::require_lstring(L, 1);
|
||||
const auto modulus = lua::require_lstring(L, 2);
|
||||
const auto exponent = lua::require_lstring(L, 3);
|
||||
const auto message = lua::require_lstring(L, 4);
|
||||
const auto signature = lua::require_lstring(L, 5);
|
||||
return verify(L, [=] {
|
||||
return crypto::rsaPkcs1Verify(
|
||||
hashName, modulus, exponent, message, signature
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
int l_rsa_pss_verify(lua::State* L) {
|
||||
lua::check_argc(L, 6);
|
||||
const auto hashName = lua::require_lstring(L, 1);
|
||||
const auto modulus = lua::require_lstring(L, 2);
|
||||
const auto exponent = lua::require_lstring(L, 3);
|
||||
const auto message = lua::require_lstring(L, 4);
|
||||
const auto signature = lua::require_lstring(L, 5);
|
||||
const int saltLength = requireInt(L, 6, "salt_length");
|
||||
return verify(L, [=] {
|
||||
return crypto::rsaPssVerify(
|
||||
hashName, modulus, exponent, message, signature, saltLength
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
int l_x25519_public(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushBytes(L, crypto::x25519Public(lua::require_lstring(L, 1)));
|
||||
}
|
||||
|
||||
int l_x25519_keypair(lua::State* L) {
|
||||
lua::check_argc(L, 0);
|
||||
return pushKeyPair(L, crypto::x25519KeyPair());
|
||||
}
|
||||
|
||||
int l_x25519(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::x25519(
|
||||
lua::require_lstring(L, 1), lua::require_lstring(L, 2)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_p256_public(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushBytes(L, crypto::p256Public(lua::require_lstring(L, 1)));
|
||||
}
|
||||
|
||||
int l_p256_keypair(lua::State* L) {
|
||||
lua::check_argc(L, 0);
|
||||
return pushKeyPair(L, crypto::ecdsaKeyPair("P-256"));
|
||||
}
|
||||
|
||||
int l_p256_shared(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::p256Shared(
|
||||
lua::require_lstring(L, 1), lua::require_lstring(L, 2)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_aes_gcm_encrypt(lua::State* L) {
|
||||
lua::check_argc(L, 4);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::aesGcmEncrypt(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3),
|
||||
lua::require_lstring(L, 4)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_aes_gcm_decrypt(lua::State* L) {
|
||||
lua::check_argc(L, 4);
|
||||
const auto key = lua::require_lstring(L, 1);
|
||||
const auto nonce = lua::require_lstring(L, 2);
|
||||
const auto aad = lua::require_lstring(L, 3);
|
||||
const auto ciphertext = lua::require_lstring(L, 4);
|
||||
return decrypt(L, [=] {
|
||||
return crypto::aesGcmDecrypt(key, nonce, aad, ciphertext);
|
||||
});
|
||||
}
|
||||
|
||||
int l_chacha20_poly1305_encrypt(lua::State* L) {
|
||||
lua::check_argc(L, 4);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::chacha20Poly1305Encrypt(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3),
|
||||
lua::require_lstring(L, 4)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_chacha20_poly1305_decrypt(lua::State* L) {
|
||||
lua::check_argc(L, 4);
|
||||
const auto key = lua::require_lstring(L, 1);
|
||||
const auto nonce = lua::require_lstring(L, 2);
|
||||
const auto aad = lua::require_lstring(L, 3);
|
||||
const auto ciphertext = lua::require_lstring(L, 4);
|
||||
return decrypt(L, [=] {
|
||||
return crypto::chacha20Poly1305Decrypt(key, nonce, aad, ciphertext);
|
||||
});
|
||||
}
|
||||
|
||||
int l_random_bytes(lua::State* L) {
|
||||
lua::check_argc(L, 1);
|
||||
return pushBytes(L, crypto::randomBytes(requireSize(L, 1, "length")));
|
||||
}
|
||||
|
||||
int l_constant_time_equal(lua::State* L) {
|
||||
lua::check_argc(L, 2);
|
||||
return lua::pushboolean(
|
||||
L,
|
||||
crypto::constantTimeEqual(
|
||||
lua::require_lstring(L, 1), lua::require_lstring(L, 2)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_hkdf_extract(lua::State* L) {
|
||||
lua::check_argc(L, 3);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::hkdfExtract(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_hkdf_expand(lua::State* L) {
|
||||
lua::check_argc(L, 4);
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::hkdfExpand(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3),
|
||||
requireSize(L, 4, "length")
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_pbkdf2(lua::State* L) {
|
||||
lua::check_argc(L, 5);
|
||||
const auto iterations = requireSize(L, 4, "iterations");
|
||||
if (iterations == 0 || iterations > UINT32_MAX) {
|
||||
throw std::runtime_error(
|
||||
"iterations must be between 1 and 4294967295"
|
||||
);
|
||||
}
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::pbkdf2(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
lua::require_lstring(L, 3),
|
||||
static_cast<std::uint32_t>(iterations),
|
||||
requireSize(L, 5, "length")
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
int l_scrypt(lua::State* L) {
|
||||
const auto argc = lua::check_argc(L, 6, 7);
|
||||
const auto maxMemory =
|
||||
argc == 7 ? requireSize(L, 7, "max_memory") : std::size_t {0};
|
||||
return pushBytes(
|
||||
L,
|
||||
crypto::scrypt(
|
||||
lua::require_lstring(L, 1),
|
||||
lua::require_lstring(L, 2),
|
||||
requireSize(L, 3, "n"),
|
||||
requireSize(L, 4, "r"),
|
||||
requireSize(L, 5, "p"),
|
||||
requireSize(L, 6, "length"),
|
||||
maxMemory
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
void setFeature(lua::State* L, const char* name, bool available) {
|
||||
lua::pushboolean(L, available);
|
||||
lua::setfield(L, name);
|
||||
}
|
||||
|
||||
int l_features(lua::State* L) {
|
||||
lua::check_argc(L, 0);
|
||||
const auto features = crypto::features();
|
||||
lua::createtable(L, 0, 26);
|
||||
lua::pushstring(L, "OpenSSL");
|
||||
lua::setfield(L, "backend");
|
||||
lua::pushstring(L, crypto::backendVersion());
|
||||
lua::setfield(L, "backend_version");
|
||||
lua::pushinteger(L, crypto::API_VERSION);
|
||||
lua::setfield(L, "api_version");
|
||||
setFeature(L, "sha256", features.sha256);
|
||||
setFeature(L, "sha384", features.sha384);
|
||||
setFeature(L, "sha512", features.sha512);
|
||||
setFeature(L, "md5", features.md5);
|
||||
setFeature(L, "hmac", features.hmac);
|
||||
setFeature(L, "streaming_hash", features.sha256);
|
||||
setFeature(L, "ed25519", features.ed25519);
|
||||
setFeature(L, "ed25519_verify", features.ed25519);
|
||||
setFeature(L, "ecdsa", features.ecdsa);
|
||||
setFeature(L, "ecdsa_verify", features.ecdsa);
|
||||
setFeature(L, "rsa_pkcs1_verify", features.rsa);
|
||||
setFeature(L, "rsa_pss_verify", features.rsa);
|
||||
setFeature(L, "x25519", features.x25519);
|
||||
setFeature(L, "p256", features.p256);
|
||||
setFeature(L, "aes_128_gcm", features.aes128Gcm);
|
||||
setFeature(L, "aes_256_gcm", features.aes256Gcm);
|
||||
setFeature(L, "aes_gcm", features.aes128Gcm && features.aes256Gcm);
|
||||
setFeature(L, "chacha20_poly1305", features.chacha20Poly1305);
|
||||
setFeature(L, "random_bytes", features.random);
|
||||
setFeature(L, "constant_time_equal", true);
|
||||
setFeature(L, "hkdf", features.hkdf);
|
||||
setFeature(L, "pbkdf2", features.pbkdf2);
|
||||
setFeature(L, "scrypt", features.scrypt);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
const luaL_Reg cryptolib[] = {
|
||||
{"sha256", lua::wrap<l_sha256>},
|
||||
{"sha384", lua::wrap<l_sha384>},
|
||||
{"sha512", lua::wrap<l_sha512>},
|
||||
{"md5", lua::wrap<l_md5>},
|
||||
{"hash", lua::wrap<l_hash>},
|
||||
{"hash_new", lua::wrap<l_hash_new>},
|
||||
{"hmac", lua::wrap<l_hmac>},
|
||||
{"ed25519_keypair", lua::wrap<l_ed25519_keypair>},
|
||||
{"ed25519_public", lua::wrap<l_ed25519_public>},
|
||||
{"ed25519_sign", lua::wrap<l_ed25519_sign>},
|
||||
{"ed25519_verify", lua::wrap<l_ed25519_verify>},
|
||||
{"ecdsa_keypair", lua::wrap<l_ecdsa_keypair>},
|
||||
{"ecdsa_public", lua::wrap<l_ecdsa_public>},
|
||||
{"ecdsa_sign", lua::wrap<l_ecdsa_sign>},
|
||||
{"ecdsa_verify", lua::wrap<l_ecdsa_verify>},
|
||||
{"rsa_pkcs1_verify", lua::wrap<l_rsa_pkcs1_verify>},
|
||||
{"rsa_pss_verify", lua::wrap<l_rsa_pss_verify>},
|
||||
{"x25519_keypair", lua::wrap<l_x25519_keypair>},
|
||||
{"x25519_public", lua::wrap<l_x25519_public>},
|
||||
{"x25519", lua::wrap<l_x25519>},
|
||||
{"x25519_shared", lua::wrap<l_x25519>},
|
||||
{"p256_keypair", lua::wrap<l_p256_keypair>},
|
||||
{"p256_public", lua::wrap<l_p256_public>},
|
||||
{"p256_shared", lua::wrap<l_p256_shared>},
|
||||
{"aes_gcm_encrypt", lua::wrap<l_aes_gcm_encrypt>},
|
||||
{"aes_gcm_decrypt", lua::wrap<l_aes_gcm_decrypt>},
|
||||
{"chacha20_poly1305_encrypt", lua::wrap<l_chacha20_poly1305_encrypt>},
|
||||
{"chacha20_poly1305_decrypt", lua::wrap<l_chacha20_poly1305_decrypt>},
|
||||
{"random_bytes", lua::wrap<l_random_bytes>},
|
||||
{"constant_time_equal", lua::wrap<l_constant_time_equal>},
|
||||
{"hkdf_extract", lua::wrap<l_hkdf_extract>},
|
||||
{"hkdf_expand", lua::wrap<l_hkdf_expand>},
|
||||
{"pbkdf2", lua::wrap<l_pbkdf2>},
|
||||
{"scrypt", lua::wrap<l_scrypt>},
|
||||
{"features", lua::wrap<l_features>},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
void initialize_cryptolib(lua::State* L) {
|
||||
ensureHashContextMetatable(L);
|
||||
if (lua::getglobal(L, "crypto")) {
|
||||
lua::pushinteger(L, crypto::API_VERSION);
|
||||
lua::setfield(L, "API_VERSION");
|
||||
lua::pop(L);
|
||||
}
|
||||
}
|
||||
|
|
@ -25,6 +25,7 @@
|
|||
#include "items/Inventories.hpp"
|
||||
#include "util/stringutil.hpp"
|
||||
#include "world/Level.hpp"
|
||||
#include "window/Window.hpp"
|
||||
#include "../usertypes/lua_type_canvas.hpp"
|
||||
|
||||
using namespace gui;
|
||||
|
|
@ -1218,7 +1219,26 @@ static int l_get_active_frame(lua::State* L) {
|
|||
return lua::pushstring(L, frame->getId());
|
||||
}
|
||||
|
||||
static int l_screenshot(lua::State* L) {
|
||||
if (engine->isHeadless()) {
|
||||
return 0;
|
||||
}
|
||||
std::unique_ptr<ImageData> image;
|
||||
if (lua::isstring(L, 1)) {
|
||||
auto& gui = engine->getGUI();
|
||||
auto frame = gui.getFrame(lua::require_string(L, 1));
|
||||
if (frame == nullptr) {
|
||||
return 0;
|
||||
}
|
||||
image = frame->takeScreenshot();
|
||||
} else {
|
||||
image = engine->getWindow().takeScreenshot();
|
||||
}
|
||||
return lua::newuserdata<lua::LuaCanvas>(L, nullptr, std::move(image));
|
||||
}
|
||||
|
||||
const luaL_Reg guilib[] = {
|
||||
{"screenshot", lua::wrap<l_screenshot>},
|
||||
{"get_viewport", lua::wrap<l_gui_getviewport>},
|
||||
{"getattr", lua::wrap<l_gui_getattr>},
|
||||
{"setattr", lua::wrap<l_gui_setattr>},
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
#include "engine/Engine.hpp"
|
||||
#include "network/Network.hpp"
|
||||
#include "devtools/Project.hpp"
|
||||
#include "util/stringutil.hpp"
|
||||
|
||||
#include <variant>
|
||||
#include <utility>
|
||||
|
|
@ -27,7 +28,7 @@ struct ResponseEventDto {
|
|||
int status;
|
||||
bool binary;
|
||||
int requestId;
|
||||
std::vector<char> bytes;
|
||||
network::HttpResponse response;
|
||||
};
|
||||
|
||||
enum NetworkDatagramSide {
|
||||
|
|
@ -85,74 +86,55 @@ static std::vector<std::string> read_headers(lua::State* L, int index) {
|
|||
|
||||
static int request_id = 1;
|
||||
|
||||
static int perform_get(lua::State* L, network::Network& network, bool binary) {
|
||||
std::string url(lua::require_lstring(L, 1));
|
||||
auto headers = read_headers(L, 2);
|
||||
static int l_request(lua::State* L, network::Network& network) {
|
||||
network::HttpRequest request {};
|
||||
request.url = lua::require_lstring(L, 1);
|
||||
|
||||
int currentRequestId = request_id++;
|
||||
|
||||
network.get(
|
||||
url,
|
||||
[currentRequestId, binary](std::vector<char> bytes) {
|
||||
push_event(NetworkEvent(
|
||||
RESPONSE,
|
||||
ResponseEventDto {
|
||||
200, binary, currentRequestId, std::move(bytes)}
|
||||
));
|
||||
},
|
||||
[currentRequestId, binary](int code, std::vector<char> bytes) {
|
||||
push_event(NetworkEvent(
|
||||
RESPONSE,
|
||||
ResponseEventDto {
|
||||
code, binary, currentRequestId, std::move(bytes)}
|
||||
));
|
||||
},
|
||||
std::move(headers)
|
||||
);
|
||||
return lua::pushinteger(L, currentRequestId);
|
||||
}
|
||||
|
||||
static int l_get(lua::State* L, network::Network& network) {
|
||||
return perform_get(L, network, false);
|
||||
}
|
||||
|
||||
static int l_get_binary(lua::State* L, network::Network& network) {
|
||||
return perform_get(L, network, true);
|
||||
}
|
||||
|
||||
static int l_post(lua::State* L, network::Network& network) {
|
||||
std::string url(lua::require_lstring(L, 1));
|
||||
auto data = lua::tovalue(L, 2);
|
||||
|
||||
std::string string;
|
||||
if (data.isString()) {
|
||||
string = data.asString();
|
||||
} else {
|
||||
string = json::stringify(data, false);
|
||||
if (!lua::istable(L, 2)) {
|
||||
throw std::runtime_error("table expected as argument #2");
|
||||
}
|
||||
if (lua::getfield(L, "method", 2)) {
|
||||
request.method = lua::require_string(L, -1);
|
||||
lua::pop(L);
|
||||
}
|
||||
if (lua::getfield(L, "headers", 2)) {
|
||||
request.headers = read_headers(L, -1);
|
||||
lua::pop(L);
|
||||
}
|
||||
if (lua::getfield(L, "body", 2)) {
|
||||
if (lua::type(L, -1) == LUA_TCDATA) {
|
||||
request.body = lua::bytearray_as_string(L, -1);
|
||||
} else {
|
||||
request.body = lua::require_lstring(L, -1);
|
||||
}
|
||||
lua::pop(L);
|
||||
}
|
||||
if (lua::getfield(L, "follow_location", 2)) {
|
||||
request.followLocation = lua::toboolean(L, -1);
|
||||
lua::pop(L);
|
||||
}
|
||||
if (lua::getfield(L, "timeout_ms", 2)) {
|
||||
request.timeoutMs = lua::tointeger(L, -1);
|
||||
lua::pop(L);
|
||||
}
|
||||
if (lua::getfield(L, "verify_ssl", 2)) {
|
||||
request.verifySSL = lua::toboolean(L, -1);
|
||||
lua::pop(L);
|
||||
}
|
||||
|
||||
auto headers = read_headers(L, 3);
|
||||
int currentRequestId = request_id++;
|
||||
request.onResponse = [currentRequestId](network::HttpResponse response) {
|
||||
push_event(NetworkEvent(
|
||||
RESPONSE,
|
||||
ResponseEventDto {
|
||||
response.status,
|
||||
false,
|
||||
currentRequestId,
|
||||
std::move(response)}
|
||||
));
|
||||
};
|
||||
|
||||
network.post(
|
||||
url,
|
||||
string,
|
||||
[currentRequestId](std::vector<char> bytes) {
|
||||
push_event(NetworkEvent(
|
||||
RESPONSE,
|
||||
ResponseEventDto {
|
||||
200, false, currentRequestId, std::move(bytes)}
|
||||
));
|
||||
},
|
||||
[currentRequestId](int code, std::vector<char> bytes) {
|
||||
push_event(NetworkEvent(
|
||||
RESPONSE,
|
||||
ResponseEventDto {
|
||||
code, false, currentRequestId, std::move(bytes)}
|
||||
));
|
||||
},
|
||||
std::move(headers)
|
||||
);
|
||||
network.request(std::move(request));
|
||||
return lua::pushinteger(L, currentRequestId);
|
||||
}
|
||||
|
||||
|
|
@ -519,11 +501,31 @@ static int l_pull_events(lua::State* L) {
|
|||
lua::pushinteger(L, dto.requestId);
|
||||
lua::rawseti(L, 3);
|
||||
|
||||
lua::createtable(L, 0, 2);
|
||||
lua::pushinteger(L, dto.response.status);
|
||||
lua::setfield(L, "status");
|
||||
|
||||
if (dto.binary) {
|
||||
lua::create_bytearray(L, dto.bytes.data(), dto.bytes.size());
|
||||
lua::create_bytearray(
|
||||
L, dto.response.body.data(), dto.response.body.size()
|
||||
);
|
||||
} else {
|
||||
lua::pushlstring(L, std::string_view(dto.bytes.data(), dto.bytes.size()));
|
||||
lua::pushlstring(
|
||||
L,
|
||||
std::string_view(
|
||||
dto.response.body.data(), dto.response.body.size()
|
||||
)
|
||||
);
|
||||
}
|
||||
lua::setfield(L, "body");
|
||||
|
||||
lua::createtable(L, dto.response.headers.size(), 0);
|
||||
for (int i = 0; i < dto.response.headers.size(); i++) {
|
||||
lua::pushlstring(L, dto.response.headers[i]);
|
||||
lua::rawseti(L, i + 1);
|
||||
}
|
||||
lua::setfield(L, "headers");
|
||||
|
||||
lua::rawseti(L, 4);
|
||||
break;
|
||||
}
|
||||
|
|
@ -562,9 +564,7 @@ int wrap(lua_State* L) {
|
|||
}
|
||||
|
||||
const luaL_Reg networklib[] = {
|
||||
{"__get", wrap<l_get>},
|
||||
{"__get_binary", wrap<l_get_binary>},
|
||||
{"__post", wrap<l_post>},
|
||||
{"__request", wrap<l_request>},
|
||||
{"get_total_upload", wrap<l_get_total_upload>},
|
||||
{"get_total_download", wrap<l_get_total_download>},
|
||||
{"find_free_port", wrap<l_find_free_port>},
|
||||
|
|
|
|||
|
|
@ -53,6 +53,8 @@ static void create_libs(State* L, StateType stateType) {
|
|||
openlib(L, "bjson", bjsonlib);
|
||||
openlib(L, "block", blocklib);
|
||||
openlib(L, "byteutil", byteutillib);
|
||||
openlib(L, "crypto", cryptolib);
|
||||
initialize_cryptolib(L);
|
||||
openlib(L, "file", filelib);
|
||||
openlib(L, "generation", generationlib);
|
||||
openlib(L, "item", itemlib);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue