hook_param test

src/ripple/app/hook/impl/applyHook.cpp

@@ -4880,6 +4880,9 @@ DEFINE_HOOK_FUNCTION(
     if (NOT_IN_BOUNDS(read_ptr, read_len, memory_length))
         return OUT_OF_BOUNDS;
 
+    if (NOT_IN_BOUNDS(write_ptr, write_len, memory_length))
+        return OUT_OF_BOUNDS;
+
     if (read_len < 1)
         return TOO_SMALL;
 
@@ -4929,6 +4932,9 @@ DEFINE_HOOK_FUNCTION(
     if (NOT_IN_BOUNDS(read_ptr, read_len, memory_length))
         return OUT_OF_BOUNDS;
     
+    if (NOT_IN_BOUNDS(write_ptr, write_len, memory_length))
+        return OUT_OF_BOUNDS;
+
     if (read_len < 1)
         return TOO_SMALL;
 
@@ -4983,7 +4989,8 @@ DEFINE_HOOK_FUNCTION(
     HOOK_SETUP(); // populates memory_ctx, memory, memory_length, applyCtx, hookCtx on current stack
 
     if (NOT_IN_BOUNDS(read_ptr, read_len, memory_length) ||
-        NOT_IN_BOUNDS(kread_ptr, kread_len, memory_length))
+        NOT_IN_BOUNDS(kread_ptr, kread_len, memory_length) ||
+        NOT_IN_BOUNDS(hread_ptr, hread_len, memory_length))
         return OUT_OF_BOUNDS;
 
     if (kread_len < 1)

src/test/app/SetHook_test.cpp

@@ -371,7 +371,7 @@ public:
         {
             Json::Value iv;
             iv[jss::HookHash] = accept_hash_str;
-            iv[jss::HookApiVersion] = 1U;
+            iv[jss::HookApiVersion] = 0U;
             jv[jss::Hooks][0U][jss::Hook] = iv;
             env(jv,
                 M("Hook Install operation cannot set apiversion"),
@@ -4383,6 +4383,132 @@ public:
     void
     test_hook_param()
     {
+        testcase("Test hook_param");
+        using namespace jtx;
+        Env env{*this, supported_amendments()};
+
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        env.fund(XRP(10000), alice);
+        env.fund(XRP(10000), bob);
+
+        TestHook hook = 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);
+            extern int64_t rollback (uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+            extern int64_t hook_param(uint32_t, uint32_t, uint32_t, uint32_t);
+            #define ASSERT(x)\
+                if (!(x))\
+                    rollback((uint32_t)#x, sizeof(#x), __LINE__);
+            #define OUT_OF_BOUNDS (-1)
+            #define TOO_BIG (-3)
+            #define TOO_SMALL (-4)
+            #define DOESNT_EXIST (-5)
+            uint8_t* names[] =
+            {
+                "param0",
+                "param1",
+                "param2",
+                "param3",
+                "param4",
+                "param5",
+                "param6",
+                "param7",
+                "param8",
+                "param9",
+                "param10",
+                "param11",
+                "param12",
+                "param13",
+                "param14",
+                "param15"
+            };
+            uint8_t* values[] =
+            {
+                "value0",
+                "value1",
+                "value2",
+                "value3",
+                "value4",
+                "value5",
+                "value6",
+                "value7",
+                "value8",
+                "value9",
+                "value10",
+                "value11",
+                "value12",
+                "value13",
+                "value14",
+                "value15"
+            };
+            #define SBUF(x) x,sizeof(x)
+            #define GUARD(maxiter) _g((1ULL << 31U) + __LINE__, (maxiter)+1)
+            int64_t hook(uint32_t reserved )
+            {
+                _g(1,1);
+
+                ASSERT(hook_param(0, 1000000, 0,32) == OUT_OF_BOUNDS);
+                ASSERT(hook_param(1000000, 32, 0, 32) == OUT_OF_BOUNDS);
+                ASSERT(hook_param(0, 32, 1000000, 32) == OUT_OF_BOUNDS);
+                ASSERT(hook_param(0, 32, 0, 1000000) == OUT_OF_BOUNDS);
+                ASSERT(hook_param(0, 32, 0, 33) == TOO_BIG);
+                ASSERT(hook_param(0, 32, 0, 0) == TOO_SMALL);
+
+                uint8_t buf[32];
+
+                for (int i = 0; GUARD(16), i < 16; ++i)
+                {
+                    int s = 6 + (i < 10 ? 0 : 1);
+                    int64_t v = hook_param(SBUF(buf), names[i], s);
+                    ASSERT(v == s);
+
+                    ASSERT(buf[0] == 'v' && buf[1] == 'a' && buf[2] == 'l' && buf[3] == 'u' && buf[4] == 'e');
+                    ASSERT(*(buf + v - 1) == *(values[i] + v - 1));
+                    ASSERT(*(buf + v - 2) == *(values[i] + v - 2));
+                }
+                
+                accept(0,0,0);
+            }
+            
+        )[test.hook]"];
+
+        Json::Value jv;
+        jv[jss::Account] = alice.human();
+        jv[jss::TransactionType] = jss::SetHook;
+        jv[jss::Flags] = 0;
+        jv[jss::Hooks] = Json::Value{Json::arrayValue};
+
+        Json::Value iv;
+        iv[jss::CreateCode] = strHex(hook);
+        iv[jss::HookOn] = uint64_hex(0);
+        iv[jss::HookApiVersion] = 0U;
+        iv[jss::HookNamespace] =  to_string(uint256{beast::zero});
+        Json::Value params{Json::arrayValue};
+        for (uint32_t i = 0; i < 16; ++i)
+        {
+            Json::Value pv;
+            Json::Value piv;
+            piv[jss::HookParameterName] =
+                strHex("param" + std::to_string(i));
+            piv[jss::HookParameterValue] =
+                strHex("value" + std::to_string(i));
+            pv[jss::HookParameter] = piv;
+            params[i] = pv;
+        }
+        iv[jss::HookParameters] = params;
+        jv[jss::Hooks][0U][jss::Hook] = iv;
+        env(jv,
+            M("set hook_param"),
+            HSFEE,
+            ter(tesSUCCESS));
+        env.close();
+
+        // invoke
+        env(pay(bob, alice, XRP(1)), M("test hook_param"), fee(XRP(1)));
+        env.close();
+
     }
 
     void
@@ -4474,7 +4600,7 @@ public:
             extern int64_t hook_pos(void);
             #define ASSERT(x)\
                 if (!(x))\
-                    rollback(#x, sizeof(#x), __LINE__ << 8U);
+                    rollback((uint32_t)#x, sizeof(#x), __LINE__ << 8U);
             #define sfInvoiceID ((5U << 16U) + 17U)
             #define SBUF(x) x,sizeof(x)
             #define OUT_OF_BOUNDS (-1)