ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2026-08-21 23:40:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: chorse:

Browse Source
This commit is contained in:
Nicholas Dudfield
2026-03-27 22:54:03 +07:00
parent a8ca62a148
commit 8a61dd44e0
4 changed files with 356 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
cmake/RippledCore.cmake
View File

@@ -205,10 +205,24 @@ if(xrpld)
if(EXTERNAL_HOOK_TESTS)
# Build extra args for x-build-test-hooks
set(_hooks_extra_args "")
set(_hooks_source_deps "")
if(HOOKS_C_DIR)
foreach(_dir ${HOOKS_C_DIR})
list(APPEND _hooks_extra_args "--hooks-c-dir" "${_dir}")
string(REGEX REPLACE "^[^=]+=" "" _hook_dir "${_dir}")
if(EXISTS "${_hook_dir}")
file(GLOB_RECURSE _hook_dir_deps CONFIGURE_DEPENDS
"${_hook_dir}/*.c"
"${_hook_dir}/*.h"
)
if(HOOKS_TEST_DIR)
list(FILTER _hook_dir_deps EXCLUDE REGEX "^${HOOKS_TEST_DIR}/")
endif()
list(APPEND _hooks_source_deps ${_hook_dir_deps})
endif()
endforeach()
list(REMOVE_DUPLICATES _hooks_source_deps)
endif()
if(HOOKS_COVERAGE OR DEFINED ENV{HOOKS_COVERAGE})
list(APPEND _hooks_extra_args "--hook-coverage")
@@ -222,7 +236,7 @@ if(xrpld)
add_custom_command(
OUTPUT "${_hooks_header}"
COMMAND x-build-test-hooks "${_test_file}" ${_hooks_extra_args}
DEPENDS "${_test_file}"
DEPENDS "${_test_file}" ${_hooks_source_deps}
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
COMMENT "Compiling hooks for ${_stem}"
VERBATIM

249
src/test/app/HookCoverage_test.cpp Normal file
View File

@@ -0,0 +1,249 @@
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012-2016 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
//
// Tests for WASM hook coverage instrumentation.
//
// These tests validate whether xahaud can load and execute hooks that contain
// SanitizerCoverage (sancov) imports — the mechanism we use for line-level
// code coverage of C-compiled hooks.
//
// The key question: does xahaud's hook validator reject WASM with extra
// imports beyond the standard hook API?
//
//==============================================================================
#include <test/app/HookCoverage_test_hooks.h>
#include <test/jtx.h>
#include <test/jtx/hook.h>
#include <xrpld/app/hook/applyHook.h>
#include <xrpld/app/tx/detail/SetHook.h>
#include <xrpl/hook/Enum.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/jss.h>
#include <fstream>
namespace ripple {
namespace test {
#define BEAST_REQUIRE(x) \
{ \
BEAST_EXPECT(!!(x)); \
if (!(x)) \
return; \
}
#define HOOK_WASM(name, path) \
[[maybe_unused]] auto const& name##_wasm = hookcoverage_test_wasm[path]; \
[[maybe_unused]] uint256 const name##_hash = \
ripple::sha512Half_s(ripple::Slice(name##_wasm.data(), name##_wasm.size())); \
[[maybe_unused]] std::string const name##_hash_str = to_string(name##_hash); \
[[maybe_unused]] Keylet const name##_keylet = keylet::hookDefinition(name##_hash);
class HookCoverage_test : public beast::unit_test::suite
{
private:
void static overrideFlag(Json::Value& jv)
{
jv[jss::Flags] = hsfOVERRIDE;
}
public:
#define HSFEE fee(100'000'000)
#define M(m) memo(m, "", "")
void
testHookWithSancovImportAccepted(FeatureBitset features)
{
testcase("Hook with sancov import is accepted (whitelisted)");
using namespace jtx;
Env env{*this, features};
auto const alice = Account{"alice"};
auto const bob = Account{"bob"};
env.fund(XRP(10000), alice);
env.fund(XRP(10000), bob);
env.close();
// This hook declares __sanitizer_cov_trace_pc_guard which is now
// in the import whitelist with void return type. The validator
// should accept it.
auto const& hook_with_sancov = hookcoverage_test_wasm[R"[test.hook](
#include <stdint.h>
extern int32_t _g(uint32_t id, uint32_t maxiter);
extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
// Sancov callback — whitelisted with void return
extern void __sanitizer_cov_trace_pc_guard(uint32_t* guard);
int64_t hook(uint32_t reserved)
{
_g(1, 1);
uint32_t guard = 1;
__sanitizer_cov_trace_pc_guard(&guard);
return accept(0, 0, 0);
}
)[test.hook]"];
// Should succeed now that sancov is whitelisted
env(ripple::test::jtx::hook(
alice, {{hso(hook_with_sancov, overrideFlag)}}, 0),
M("Hook with sancov import"),
HSFEE,
ter(tesSUCCESS));
env.close();
// Now trigger the hook and verify coverage is recorded
hook::coverageReset();
env(pay(bob, alice, XRP(1)),
M("Trigger sancov hook"),
fee(XRP(1)),
ter(tesSUCCESS));
env.close();
// The hook has a manually placed guard call, so we should see hits
auto const hookHash = ripple::sha512Half_s(
ripple::Slice(hook_with_sancov.data(), hook_with_sancov.size()));
auto const* hits = hook::coverageHits(hookHash);
// Coverage may or may not be recorded depending on whether the
// sancov init ran (hook-cleaner strips the ctor). But the hook
// should at minimum not crash.
BEAST_EXPECT(true); // hook executed without crashing
}
void
testCleanHookStillWorks(FeatureBitset features)
{
testcase("Clean hook without sancov imports works normally");
using namespace jtx;
Env env{*this, features};
auto const alice = Account{"alice"};
auto const bob = Account{"bob"};
env.fund(XRP(10000), alice);
env.fund(XRP(10000), bob);
env.close();
// Baseline: a normal hook with no coverage instrumentation
auto const& clean_hook = hookcoverage_test_wasm[R"[test.hook](
#include <stdint.h>
extern int32_t _g(uint32_t id, uint32_t maxiter);
extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
int64_t hook(uint32_t reserved)
{
_g(1, 1);
return accept(0, 0, 0);
}
)[test.hook]"];
env(ripple::test::jtx::hook(
alice, {{hso(clean_hook, overrideFlag)}}, 0),
M("Install clean hook"),
HSFEE,
ter(tesSUCCESS));
env.close();
// Verify it executes
env(pay(bob, alice, XRP(1)),
M("Trigger hook"),
fee(XRP(1)),
ter(tesSUCCESS));
env.close();
}
void
testCoverageAPI(FeatureBitset features)
{
testcase("Coverage API: reset, query, dump");
using namespace jtx;
// Test the coverage API independently
hook::coverageReset();
// After reset, no hits for any hash
ripple::uint256 fakeHash{};
BEAST_EXPECT(hook::coverageHits(fakeHash) == nullptr);
// Manually poke the global accumulator to verify dump works
auto& map = hook::coverageMap();
map[fakeHash].guard_start = 1024;
map[fakeHash].guard_stop = 1040;
map[fakeHash].hits = {1, 3, 4};
auto const* hits = hook::coverageHits(fakeHash);
BEAST_REQUIRE(hits != nullptr);
BEAST_EXPECT(hits->size() == 3);
BEAST_EXPECT(hits->count(1) == 1);
BEAST_EXPECT(hits->count(2) == 0);
BEAST_EXPECT(hits->count(3) == 1);
// Test dump
std::string dumpPath = "/tmp/test_hook_coverage.dat";
BEAST_EXPECT(hook::coverageDump(dumpPath));
// Verify file was written
std::ifstream in(dumpPath);
BEAST_EXPECT(in.good());
std::string content(
(std::istreambuf_iterator<char>(in)),
std::istreambuf_iterator<char>());
BEAST_EXPECT(content.find("guards=1024,1040") != std::string::npos);
BEAST_EXPECT(content.find("hits=1,3,4") != std::string::npos);
// Test reset clears everything
hook::coverageReset();
BEAST_EXPECT(hook::coverageHits(fakeHash) == nullptr);
}
bool
shouldRun(std::string const& name, char const* filter)
{
if (!filter || !filter[0])
return true;
return name.find(filter) != std::string::npos;
}
#define RUN(fn) \
if (shouldRun(#fn, filter)) \
fn(sa);
void
run() override
{
using namespace test::jtx;
auto const sa = supported_amendments();
auto const* filter = std::getenv("HOOKCOV_TEST");
RUN(testCoverageAPI);
RUN(testCleanHookStillWorks);
RUN(testHookWithSancovImportAccepted);
}
#undef RUN
};
BEAST_DEFINE_TESTSUITE(HookCoverage, app, ripple);
} // namespace test
} // namespace ripple

91
src/test/app/HookCoverage_test_hooks.h Normal file
View File

@@ -0,0 +1,91 @@
// This file is generated by build_test_hooks.py
#ifndef HOOKCOVERAGE_TEST_WASM_INCLUDED
#define HOOKCOVERAGE_TEST_WASM_INCLUDED
#include <map>
#include <stdint.h>
#include <string>
#include <vector>
namespace ripple {
namespace test {
inline std::map<std::string, std::vector<uint8_t>> hookcoverage_test_wasm = {
/* ==== WASM: 0 ==== */
{R"[test.hook](
#include <stdint.h>
extern int32_t _g(uint32_t id, uint32_t maxiter);
extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
// Sancov callback — whitelisted with void return
extern void __sanitizer_cov_trace_pc_guard(uint32_t* guard);
int64_t hook(uint32_t reserved)
{
_g(1, 1);
uint32_t guard = 1;
__sanitizer_cov_trace_pc_guard(&guard);
return accept(0, 0, 0);
}
)[test.hook]",
{
0x00U, 0x61U, 0x73U, 0x6DU, 0x01U, 0x00U, 0x00U, 0x00U, 0x01U, 0x17U,
0x04U, 0x60U, 0x02U, 0x7FU, 0x7FU, 0x01U, 0x7FU, 0x60U, 0x01U, 0x7FU,
0x00U, 0x60U, 0x03U, 0x7FU, 0x7FU, 0x7EU, 0x01U, 0x7EU, 0x60U, 0x01U,
0x7FU, 0x01U, 0x7EU, 0x02U, 0x3CU, 0x03U, 0x03U, 0x65U, 0x6EU, 0x76U,
0x02U, 0x5FU, 0x67U, 0x00U, 0x00U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x1EU,
0x5FU, 0x5FU, 0x73U, 0x61U, 0x6EU, 0x69U, 0x74U, 0x69U, 0x7AU, 0x65U,
0x72U, 0x5FU, 0x63U, 0x6FU, 0x76U, 0x5FU, 0x74U, 0x72U, 0x61U, 0x63U,
0x65U, 0x5FU, 0x70U, 0x63U, 0x5FU, 0x67U, 0x75U, 0x61U, 0x72U, 0x64U,
0x00U, 0x01U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x06U, 0x61U, 0x63U, 0x63U,
0x65U, 0x70U, 0x74U, 0x00U, 0x02U, 0x03U, 0x02U, 0x01U, 0x03U, 0x05U,
0x03U, 0x01U, 0x00U, 0x02U, 0x06U, 0x21U, 0x05U, 0x7FU, 0x01U, 0x41U,
0x80U, 0x88U, 0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU,
0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U,
0x88U, 0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x07U,
0x08U, 0x01U, 0x04U, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x00U, 0x03U, 0x0AU,
0xD3U, 0x80U, 0x00U, 0x01U, 0xCFU, 0x80U, 0x00U, 0x02U, 0x01U, 0x7FU,
0x01U, 0x7EU, 0x23U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U, 0x10U,
0x6BU, 0x22U, 0x01U, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U,
0x01U, 0x41U, 0x01U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU,
0x20U, 0x01U, 0x41U, 0x01U, 0x36U, 0x02U, 0x0CU, 0x20U, 0x01U, 0x41U,
0x0CU, 0x6AU, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U, 0x00U,
0x41U, 0x00U, 0x42U, 0x00U, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U, 0x00U,
0x21U, 0x02U, 0x20U, 0x01U, 0x41U, 0x10U, 0x6AU, 0x24U, 0x80U, 0x80U,
0x80U, 0x80U, 0x00U, 0x20U, 0x02U, 0x0BU,
}},
/* ==== WASM: 1 ==== */
{R"[test.hook](
#include <stdint.h>
extern int32_t _g(uint32_t id, uint32_t maxiter);
extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
int64_t hook(uint32_t reserved)
{
_g(1, 1);
return accept(0, 0, 0);
}
)[test.hook]",
{
0x00U, 0x61U, 0x73U, 0x6DU, 0x01U, 0x00U, 0x00U, 0x00U, 0x01U, 0x13U,
0x03U, 0x60U, 0x02U, 0x7FU, 0x7FU, 0x01U, 0x7FU, 0x60U, 0x03U, 0x7FU,
0x7FU, 0x7EU, 0x01U, 0x7EU, 0x60U, 0x01U, 0x7FU, 0x01U, 0x7EU, 0x02U,
0x17U, 0x02U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x02U, 0x5FU, 0x67U, 0x00U,
0x00U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x06U, 0x61U, 0x63U, 0x63U, 0x65U,
0x70U, 0x74U, 0x00U, 0x01U, 0x03U, 0x02U, 0x01U, 0x02U, 0x05U, 0x03U,
0x01U, 0x00U, 0x02U, 0x06U, 0x21U, 0x05U, 0x7FU, 0x01U, 0x41U, 0x80U,
0x88U, 0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x7FU,
0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x88U,
0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x07U, 0x08U,
0x01U, 0x04U, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x00U, 0x02U, 0x0AU, 0x9DU,
0x80U, 0x00U, 0x01U, 0x99U, 0x80U, 0x00U, 0x00U, 0x41U, 0x01U, 0x41U,
0x01U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x41U, 0x00U,
0x41U, 0x00U, 0x42U, 0x00U, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U,
0x0BU,
}},
};
}
} // namespace ripple
#endif

18
src/test/unit_test/SuiteLogsWithOverrides.h
View File

@@ -40,31 +40,15 @@ namespace test {
class StderrJournalSink : public beast::Journal::Sink
{
std::string partition_;
beast::severities::Severity pinnedThreshold_;
public:
StderrJournalSink(
std::string const& partition,
beast::severities::Severity threshold)
: Sink(threshold, false)
, partition_(partition)
, pinnedThreshold_(threshold)
: Sink(threshold, false), partition_(partition)
{
}
beast::severities::Severity
threshold() const override
{
return pinnedThreshold_;
}
void
threshold(beast::severities::Severity threshold) override
{
(void)threshold;
Sink::threshold(pinnedThreshold_);
}
bool
active(beast::severities::Severity level) const override
{