1 files changed, 180 insertions, 0 deletions

diff --git a/src/test_rvaccept.cpp b/src/test_rvaccept.cpp
new file mode 100644
index 0000000..afa9046
--- /dev/null
+++ b/src/test_rvaccept.cpp
@@ -0,0 +1,180 @@
+// Local regression test for the pool's rendezvous accept path.
+//
+// Reproduces the exact failure that took remote miners off the pool: since
+// upstream #30, RvServiceRegister returns as soon as the relay lists the
+// service and no longer consumes the relay's 0x01 pairing byte. A service that
+// goes straight from RvServiceRegister to BtfServiceWrap therefore reads that
+// 0x01 as the first byte of the client's 32-byte ephemeral key, shifting the
+// whole stream by one. X25519 has no confirmation step, so the handshake
+// "succeeds" against a garbage shared secret and the corruption only shows up
+// as a tunnel that never carries a valid byte.
+//
+// Build: g++ -std=gnu++14 -O2 -pthread test_rvaccept.cpp btftunnel.cpp btfrv.cpp \
+//        btfchan.cpp -lsodium -o test_rvaccept
+//
+// Build: g++ -std=gnu++14 -O2 -pthread test_rvaccept.cpp btftunnel.cpp \
+//        btfrv.cpp btfchan.cpp -lsodium -o test_rvaccept
+//
+// Run against a bitflashd relay already listening on 127.0.0.1:<port>.
+//   test_rvaccept broken <port>  -- the pre-fix pool code path, expected to FAIL
+//   test_rvaccept fixed  <port>  -- with RvServiceWaitPaired, expected to PASS
+
+#include "btftunnel.h"
+#include "btfrv.h"
+#include "btfchan.h"
+
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <thread>
+#include <chrono>
+
+using namespace btf;
+
+static const char*    HOST = "127.0.0.1";
+static unsigned short PORT = 18446;
+static const char*    MSG  = "mining.subscribe stand-in payload";
+
+static void SetTimeout(int fd, int secs)
+{
+    struct timeval tv;
+    tv.tv_sec  = secs;
+    tv.tv_usec = 0;
+    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+    setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
+}
+
+static bool RecvN(int fd, void* buf, int n)
+{
+    char* p = (char*)buf;
+    int off = 0;
+    while (off < n) {
+        int r = recv(fd, p + off, n - off, 0);
+        if (r <= 0) return false;
+        off += r;
+    }
+    return true;
+}
+
+static bool SendN(int fd, const void* buf, int n)
+{
+    const char* p = (const char*)buf;
+    int off = 0;
+    while (off < n) {
+        int r = send(fd, p + off, n - off, 0);
+        if (r <= 0) return false;
+        off += r;
+    }
+    return true;
+}
+
+static bool  g_serviceEcho = false;
+static std::string g_serviceSaw;
+
+// The pool's AcceptOneFn, in both shapes.
+static void ServiceThread(bool fWaitPaired,
+                          std::vector<unsigned char> id,
+                          std::vector<unsigned char> enc_sk,
+                          int len)
+{
+    RvSocket rv = RvServiceRegister(HOST, PORT, id.data());
+    if (rv == RV_INVALID) { printf("    service: RvServiceRegister failed\n"); return; }
+
+    if (fWaitPaired) {
+        if (!RvServiceWaitPaired(rv)) {
+            printf("    service: RvServiceWaitPaired failed\n");
+            RvClose(rv);
+            return;
+        }
+        printf("    service: paired (0x01 consumed by RvServiceWaitPaired)\n");
+    } else {
+        printf("    service: skipped RvServiceWaitPaired (pre-fix behaviour)\n");
+    }
+
+    btf_socket_t app = BtfServiceWrap(rv, enc_sk.data());
+    if (app == INVALID_SOCKET) { printf("    service: BtfServiceWrap failed\n"); return; }
+    printf("    service: BtfServiceWrap returned a tunnel\n");
+
+    SetTimeout(app, 5);
+    std::vector<char> buf(len);
+    if (!RecvN(app, buf.data(), len)) {
+        printf("    service: never received the client's plaintext\n");
+        close(app);
+        return;
+    }
+    g_serviceSaw.assign(buf.data(), len);
+    g_serviceEcho = SendN(app, buf.data(), len);
+    close(app);
+}
+
+int main(int argc, char* argv[])
+{
+    bool fWaitPaired = (argc >= 2 && strcmp(argv[1], "fixed") == 0);
+    if (argc >= 3) PORT = (unsigned short)atoi(argv[2]);
+
+    if (!TunnelInit()) { printf("TunnelInit failed\n"); return 2; }
+
+    unsigned char enc_pk[32], enc_sk[32];
+    ChanKeypair(enc_pk, enc_sk);
+
+    std::vector<unsigned char> id(32);
+    for (int i = 0; i < 32; i++) id[i] = (unsigned char)(i * 7 + 13);
+
+    const std::string msg(MSG);
+    const int len = (int)msg.size();
+
+    printf("  mode: %s   relay: %s:%u\n", fWaitPaired ? "fixed" : "broken", HOST, PORT);
+
+    std::thread svc(ServiceThread, fWaitPaired, id,
+                    std::vector<unsigned char>(enc_sk, enc_sk + 32), len);
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+    int nFail = 0;
+
+    btf_socket_t app = BtfClientTunnel(HOST, PORT, id.data(), enc_pk);
+    if (app == INVALID_SOCKET) {
+        printf("    client: BtfClientTunnel failed\n");
+        nFail++;
+    } else {
+        printf("    client: tunnel established\n");
+        SetTimeout(app, 5);
+        if (!SendN(app, msg.data(), len)) { printf("    client: send failed\n"); nFail++; }
+        std::vector<char> echo(len);
+        if (!RecvN(app, echo.data(), len)) {
+            printf("    client: no echo came back\n");
+            nFail++;
+        } else if (std::string(echo.data(), len) != msg) {
+            printf("    client: echo did not match what was sent\n");
+            nFail++;
+        } else {
+            printf("    client: round-tripped the payload intact\n");
+        }
+        close(app);
+    }
+
+    svc.join();
+
+    if (g_serviceSaw != msg) {
+        printf("    service did not see the correct plaintext (saw %d bytes)\n",
+               (int)g_serviceSaw.size());
+        nFail++;
+    }
+    if (!g_serviceEcho) { printf("    service could not echo\n"); nFail++; }
+
+    bool fPassed = (nFail == 0);
+    printf("  RESULT: %s\n", fPassed ? "PASS -- tunnel carries plaintext end to end"
+                                     : "FAIL -- tunnel never carried a valid byte");
+
+    // A broken run is the expected outcome pre-fix, so exit 0 when the
+    // observed behaviour matches the expectation for the mode under test.
+    bool fAsExpected = (fWaitPaired ? fPassed : !fPassed);
+    printf("  EXPECTED %s -> %s\n",
+           fWaitPaired ? "PASS" : "FAIL",
+           fAsExpected ? "as expected" : "UNEXPECTED");
+    return fAsExpected ? 0 : 1;
+}