ffmpeg_web_local_app/source/Crow/tests/test_ws_fragment_limit_e2e.cpp


Home Back
// Crow WebSocket maximum-payload bypass through fragmented messages.
//
// Build:
//   g++ -std=c++17 -I <crow>/include -I <asio>/asio/include \
//       -DASIO_STANDALONE -O1 -o ws_fragment_limit_e2e \
//       ws_fragment_limit_e2e.cpp -lpthread
//
// Loopback only. The configured maximum message payload is 16 bytes.

#include <cstdint>
#include <atomic>
#include <chrono>
#include <mutex>
#include <string>
#include <thread>

#define CROW_ENABLE_DEBUG
#define CROW_LOG_LEVEL 0
#include "crow.h"

#include "catch2/catch_all.hpp"

#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#endif
#ifdef _WIN32
#define close(fd) closesocket(fd)
#define ssize_t SSIZE_T
#endif

namespace
{
constexpr int PORT = 41809;
constexpr std::uint64_t LIMIT = 16;

std::atomic<int> message_count{0};
std::atomic<int> error_count{0};
std::mutex received_mutex;
std::string received_message;

int connect_websocket()
{
    int fd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0)
        return -1;

    sockaddr_in address{};
    address.sin_family = AF_INET;
    address.sin_port = htons(PORT);
    ::inet_pton(AF_INET, "127.0.0.1", &address.sin_addr);

    timeval timeout{2, 0};
    ::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));

    if (::connect(fd, reinterpret_cast<sockaddr*>(&address), sizeof(address)) != 0)
    {
        ::close(fd);
        return -1;
    }

    const std::string request =
      "GET /ws HTTP/1.1\r\n"
      "Host: 127.0.0.1\r\n"
      "Upgrade: websocket\r\n"
      "Connection: Upgrade\r\n"
      "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
      "Sec-WebSocket-Version: 13\r\n\r\n";
    ::send(fd, request.data(), request.size(), 0);

    std::string response;
    char buffer[1024];
    while (response.find("\r\n\r\n") == std::string::npos)
    {
        const ssize_t count = ::recv(fd, buffer, sizeof(buffer), 0);
        if (count <= 0)
        {
            ::close(fd);
            return -1;
        }
        response.append(buffer, static_cast<std::size_t>(count));
    }

    if (response.find("101 Switching Protocols") == std::string::npos)
    {
        ::close(fd);
        return -1;
    }
    return fd;
}

bool send_masked_frame(int fd, bool fin, std::uint8_t opcode, const std::string& payload)
{
    if (payload.size() >= 126)
        return false;

    constexpr std::uint8_t mask[4] = {0x11, 0x22, 0x33, 0x44};
    std::string frame;
    frame.reserve(2 + 4 + payload.size());
    frame.push_back(static_cast<char>((fin ? 0x80 : 0x00) | opcode));
    frame.push_back(static_cast<char>(0x80 | payload.size()));
    frame.append(reinterpret_cast<const char*>(mask), sizeof(mask));
    for (std::size_t i = 0; i < payload.size(); ++i)
        frame.push_back(static_cast<char>(payload[i] ^ mask[i % 4]));

    return ::send(fd, frame.data(), frame.size(), 0) ==
           static_cast<ssize_t>(frame.size());
}
} // namespace

TEST_CASE("test_ws_fragment_limit_e2e")
{
    crow::SimpleApp app;

    CROW_WEBSOCKET_ROUTE(app, "/ws")
      .max_payload(LIMIT)
      .onmessage([](crow::websocket::connection&, const std::string& data, bool) {
          {
              std::lock_guard<std::mutex> lock(received_mutex);
              received_message = data;
          }
          message_count++;
      })
      .onerror([](crow::websocket::connection&, const std::string&) {
          error_count++;
      });

    app.loglevel(crow::LogLevel::Critical);
    auto future = app.bindaddr("127.0.0.1").port(PORT).run_async();
    std::this_thread::sleep_for(std::chrono::milliseconds(700));

    // Control: one 24-byte frame exceeds the 16-byte limit and must be rejected.
    const int control_fd = connect_websocket();
    const bool control_connected = control_fd >= 0;
    REQUIRE(control_connected);

    const bool control_sent =
      control_connected && send_masked_frame(control_fd, true, 0x1, std::string(24, 'C'));
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    const bool control_rejected =
      control_sent && message_count.load() == 0 && error_count.load() > 0;
    REQUIRE(message_count.load() == 0);
    REQUIRE(error_count.load() > 0);
    if (control_fd >= 0)
        ::close(control_fd);

    // Test: two 12-byte frames are each below the limit, but the complete
    // fragmented message is 24 bytes and should be rejected as a whole.
    const int fragmented_fd = connect_websocket();
    const bool fragmented_connected = fragmented_fd >= 0;

    REQUIRE(fragmented_fd >= 0);

    const bool first_sent =
      fragmented_connected && send_masked_frame(fragmented_fd, false, 0x1, std::string(12, 'A'));
    const bool second_sent =
      first_sent && send_masked_frame(fragmented_fd, true, 0x0, std::string(12, 'B'));
    std::this_thread::sleep_for(std::chrono::milliseconds(300));

    std::string observed;
    {
        std::lock_guard<std::mutex> lock(received_mutex);
        observed = received_message;
    }
    const bool oversized_message_delivered =
      second_sent && message_count.load() == 1 &&
      observed == std::string(12, 'A') + std::string(12, 'B');
    REQUIRE(second_sent);
    REQUIRE(message_count.load() == 0);
    REQUIRE(observed=="");
    REQUIRE_FALSE(oversized_message_delivered);

    if (fragmented_fd >= 0)
        ::close(fragmented_fd);

    app.stop();
    future.wait();

    CROW_LOG_DEBUG << "CONFIGURED_MAX_PAYLOAD=" << LIMIT << "\n"
              << "CONTROL_SINGLE_FRAME_BYTES=24\n"
              << "CONTROL_SINGLE_FRAME_REJECTED=" << control_rejected << "\n"
              << "FRAGMENT_ONE_BYTES=12\n"
              << "FRAGMENT_TWO_BYTES=12\n"
              << "FRAGMENTED_MESSAGE_BYTES=" << observed.size() << "\n"
              << "FRAGMENTED_MESSAGE_DELIVERED=" << oversized_message_delivered << "\n"
              << "MESSAGE_HANDLER_CALLS=" << message_count.load() << "\n"
              << "ERROR_HANDLER_CALLS=" << error_count.load() << "\n";

    const bool confirmed = control_connected && control_rejected &&
                           fragmented_connected && oversized_message_delivered;
    CROW_LOG_DEBUG << "VERDICT="
              << (confirmed ? "WEBSOCKET_FRAGMENTED_MESSAGE_LIMIT_BYPASS_CONFIRMED"
                            : "NOT_CONFIRMED");
    REQUIRE_FALSE(confirmed);
}

Powered by Code, a simple repository browser by Fabio Di Matteo