Home /Modules/test-suites/reg_http6.c

reg_http6.c

test-suites/regression/c/reg_http6.c · 364 line(s) · c

/*
 * reg_http6.c -- regression suite for the HTTP 6.0 frame layer
 * (http-6.0/http6_protocol.c)
 *
 * Contract (http-6.0/http6_protocol.h):
 *   - a frame is a 32-byte big-endian header followed by payload_length bytes:
 *       0 version(6)  1 type(1..20)  2..3 flags  4..11 stream  12..19 request
 *       20..27 sequence  28..31 payload length (at most 16 MiB);
 *   - validate: -1 NULL header, -2 wrong version, -3 unknown type, -4 length over
 *     the cap, -5 length beyond the bytes available, 0 acceptable;
 *   - decode never reads past the buffer it is given: a short header is -2, a
 *     truncated payload, an oversized length, a bad version or type is -3;
 *   - encode never writes past out_cap and encode/decode round-trip exactly.
 *
 * Every buffer handed to the code under test is a separate exact-size heap
 * block, so the harness's guard bytes catch a one-byte over-read or over-write.
 */
#include "../../../http-6.0/http6_protocol.h"
#include "regression.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define HDR HTTP6_FRAME_HEADER_SIZE

static http6_frame_header_t header(uint8_t type, uint32_t len) {
    http6_frame_header_t h;
    memset(&h, 0, sizeof h);
    h.version = HTTP6_VERSION;
    h.type = type;
    h.payload_length = len;
    return h;
}

/* Encode into an exact-size block; returns NULL on failure. */
static uint8_t *encode_exact(const http6_frame_header_t *h, const uint8_t *payload, size_t *len) {
    size_t cap = HDR + h->payload_length;
    uint8_t *w = (uint8_t *)malloc(cap ? cap : 1);
    if (!w) return NULL;
    if (http6_frame_encode(h, payload, w, cap, len) != 0) { free(w); return NULL; }
    return w;
}

/* ---- validate -------------------------------------------------------------- */
static void t_validate_codes(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_DATA, 10);
    REG_EQ_I(-1, http6_frame_validate(NULL, 100));
    REG_EQ_I(0, http6_frame_validate(&h, 10));
    REG_EQ_I(0, http6_frame_validate(&h, 11));
    REG_EQ_I(-5, http6_frame_validate(&h, 9));         /* payload longer than what is there */
    REG_EQ_I(-5, http6_frame_validate(&h, 0));

    h.version = 5;  REG_EQ_I(-2, http6_frame_validate(&h, 10));
    h.version = 7;  REG_EQ_I(-2, http6_frame_validate(&h, 10));
    h.version = 0;  REG_EQ_I(-2, http6_frame_validate(&h, 10));
    h.version = 255; REG_EQ_I(-2, http6_frame_validate(&h, 10));
    h.version = HTTP6_VERSION;

    h.type = 0;   REG_EQ_I(-3, http6_frame_validate(&h, 10));
    h.type = 21;  REG_EQ_I(-3, http6_frame_validate(&h, 10));
    h.type = 255; REG_EQ_I(-3, http6_frame_validate(&h, 10));
    h.type = HTTP6_FRAME_DATA;

    h.payload_length = HTTP6_MAX_PAYLOAD + 1u;
    REG_EQ_I(-4, http6_frame_validate(&h, (size_t)-1));  /* over the cap even if the bytes exist */
    h.payload_length = 0xFFFFFFFFu;
    REG_EQ_I(-4, http6_frame_validate(&h, (size_t)-1));
    h.payload_length = HTTP6_MAX_PAYLOAD;
    REG_EQ_I(0, http6_frame_validate(&h, HTTP6_MAX_PAYLOAD));       /* the cap itself is allowed */
    REG_EQ_I(-5, http6_frame_validate(&h, HTTP6_MAX_PAYLOAD - 1u));
}

static void t_every_defined_type_is_valid_and_named(void) {
    static const char *const names[] = {
        "OPEN", "DATA", "END", "RESET", "WINDOW", "PING", "PONG", "RESUME", "CAPSULE",
        "FRIENDS_PACK", "BONUS_OFFER", "FP_UPDATE", "AUDIT", "CONSOLIDATED_FRIENDS_BET",
        "TEAMSTER_DEBATE", "CONSOLIDATE_IQ", "TEAM_AREA", "DEBATE_TOPIC", "DEBATE_POSITION",
        "RECIPIENT_LABEL" };
    unsigned t;
    for (t = 1; t <= 20; ++t) {
        http6_frame_header_t h = header((uint8_t)t, 0);
        REG_EQ_I(0, http6_frame_validate(&h, 0));
        REG_EQ_S(names[t - 1], http6_frame_type_name((http6_frame_type_t)t));
    }
    REG_EQ_S("UNKNOWN", http6_frame_type_name((http6_frame_type_t)0));
    REG_EQ_S("UNKNOWN", http6_frame_type_name((http6_frame_type_t)21));
    REG_EQ_S("UNKNOWN", http6_frame_type_name((http6_frame_type_t)255));
}

/* ---- wire layout ------------------------------------------------------------ */
static void t_wire_layout_is_big_endian(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_PING, 3);
    static const uint8_t payload[3] = { 0xAA, 0xBB, 0xCC };
    static const uint8_t expect[HTTP6_FRAME_HEADER_SIZE + 3] = {
        6, 6,                                           /* version, type PING */
        0x12, 0x34,                                     /* flags */
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* stream id */
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, /* request id */
        0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, /* sequence */
        0, 0, 0, 3,                                     /* payload length */
        0xAA, 0xBB, 0xCC };
    size_t n = 0;
    uint8_t *w;
    h.flags = 0x1234;
    h.stream_id = 0x0102030405060708ull;
    h.request_id = 0x1112131415161718ull;
    h.sequence = 0x2122232425262728ull;
    w = encode_exact(&h, payload, &n);
    REG_REQUIRE(w != NULL);
    REG_EQ_U(sizeof expect, n);
    REG_EQ_MEM(expect, w, sizeof expect);
    free(w);
}

/* ---- encode ----------------------------------------------------------------- */
static void t_encode_refusals(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_DATA, 4);
    uint8_t payload[4] = { 1, 2, 3, 4 };
    uint8_t *out = (uint8_t *)malloc(HDR + 4);
    size_t n = 0;
    REG_REQUIRE(out != NULL);
    REG_EQ_I(-1, http6_frame_encode(NULL, payload, out, HDR + 4, &n));
    REG_EQ_I(-1, http6_frame_encode(&h, payload, NULL, HDR + 4, &n));
    REG_EQ_I(-1, http6_frame_encode(&h, payload, out, HDR + 4, NULL));
    REG_EQ_I(-3, http6_frame_encode(&h, NULL, out, HDR + 4, &n));          /* length > 0 but no bytes */
    REG_EQ_I(-4, http6_frame_encode(&h, payload, out, HDR + 3, &n));       /* one byte short */
    REG_EQ_I(-4, http6_frame_encode(&h, payload, out, 0, &n));
    h.version = 9;
    REG_EQ_I(-2, http6_frame_encode(&h, payload, out, HDR + 4, &n));       /* invalid header */
    h = header(0, 4);
    REG_EQ_I(-2, http6_frame_encode(&h, payload, out, HDR + 4, &n));
    h = header(HTTP6_FRAME_DATA, HTTP6_MAX_PAYLOAD + 1u);
    REG_EQ_I(-2, http6_frame_encode(&h, payload, out, HDR + 4, &n));
    free(out);
}

static void t_encode_exact_capacity_and_empty_payload(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_END, 0);
    size_t n = 99;
    uint8_t *out = (uint8_t *)malloc(HDR);
    REG_REQUIRE(out != NULL);
    REG_EQ_I(0, http6_frame_encode(&h, NULL, out, HDR, &n));               /* no payload: NULL is fine */
    REG_EQ_U(HDR, n);
    free(out);
}

/* ---- decode ----------------------------------------------------------------- */
static void t_decode_refusals(void) {
    uint8_t *w;
    size_t n = 0, used = 0;
    http6_frame_view_t v;
    http6_frame_header_t h = header(HTTP6_FRAME_DATA, 5);
    static const uint8_t payload[5] = { 9, 8, 7, 6, 5 };
    w = encode_exact(&h, payload, &n);
    REG_REQUIRE(w != NULL);
    REG_EQ_I(-1, http6_frame_decode(NULL, n, &v, &used));
    REG_EQ_I(-1, http6_frame_decode(w, n, NULL, &used));
    REG_EQ_I(-1, http6_frame_decode(w, n, &v, NULL));
    free(w);
}

/* Truncate a valid frame at every possible length: each shorter prefix fails
 * with the right code and, being an exact-size block, cannot be over-read. */
static void t_every_truncation_is_refused(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_CAPSULE, 40);
    uint8_t payload[40];
    size_t full = 0, cut, bad_short = 0, bad_trunc = 0;
    uint8_t *w;
    unsigned i;
    for (i = 0; i < sizeof payload; ++i) payload[i] = (uint8_t)(i * 7u + 1u);
    w = encode_exact(&h, payload, &full);
    REG_REQUIRE(w != NULL);
    REG_EQ_U(HDR + 40, full);
    for (cut = 0; cut < full; ++cut) {
        uint8_t *copy = (uint8_t *)malloc(cut ? cut : 1);
        http6_frame_view_t v;
        size_t used = 12345;
        int rc;
        REG_REQUIRE(copy != NULL);
        memcpy(copy, w, cut);
        rc = http6_frame_decode(copy, cut, &v, &used);
        if (cut < HDR) { if (rc != -2) ++bad_short; }
        else if (rc != -3) ++bad_trunc;
        if (used != 12345) ++bad_trunc;                /* a refused decode leaves *consumed alone */
        free(copy);
    }
    REG_EQ_U(0, bad_short);
    REG_EQ_U(0, bad_trunc);
    free(w);
}

static void t_oversized_and_hostile_lengths(void) {
    static const uint32_t lengths[] = { HTTP6_MAX_PAYLOAD + 1u, 0x7FFFFFFFu, 0x80000000u, 0xFFFFFFFFu, 1u << 24 | 1u };
    size_t i;
    for (i = 0; i < sizeof lengths / sizeof lengths[0]; ++i) {
        uint8_t *w = (uint8_t *)calloc(HDR + 8, 1);
        http6_frame_view_t v;
        size_t used = 0;
        REG_REQUIRE(w != NULL);
        w[0] = 6; w[1] = 2;
        w[28] = (uint8_t)(lengths[i] >> 24); w[29] = (uint8_t)(lengths[i] >> 16);
        w[30] = (uint8_t)(lengths[i] >> 8);  w[31] = (uint8_t)lengths[i];
        REG_EQ_I(-3, http6_frame_decode(w, HDR + 8, &v, &used));
        free(w);
    }
}

static void t_bad_version_and_type_refused_on_the_wire(void) {
    uint8_t *w = (uint8_t *)calloc(HDR, 1);
    http6_frame_view_t v;
    size_t used = 0;
    REG_REQUIRE(w != NULL);
    w[0] = 6; w[1] = 1;
    REG_EQ_I(0, http6_frame_decode(w, HDR, &v, &used));
    w[0] = 5; REG_EQ_I(-3, http6_frame_decode(w, HDR, &v, &used));
    w[0] = 6; w[1] = 0;  REG_EQ_I(-3, http6_frame_decode(w, HDR, &v, &used));
    w[1] = 21; REG_EQ_I(-3, http6_frame_decode(w, HDR, &v, &used));
    free(w);
}

static void t_trailing_bytes_are_not_consumed(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_DATA, 2);
    static const uint8_t payload[2] = { 0x10, 0x20 };
    size_t n = 0, used = 0;
    uint8_t *w = encode_exact(&h, payload, &n);
    uint8_t *two;
    http6_frame_view_t v;
    REG_REQUIRE(w != NULL);
    two = (uint8_t *)malloc(n * 2);
    REG_REQUIRE(two != NULL);
    memcpy(two, w, n);
    memcpy(two + n, w, n);                             /* two frames back to back */
    REG_EQ_I(0, http6_frame_decode(two, n * 2, &v, &used));
    REG_EQ_U(n, used);                                 /* only the first frame */
    REG_EQ_I(0, http6_frame_decode(two + used, n * 2 - used, &v, &used));
    REG_EQ_U(n, used);
    free(two);
    free(w);
}

/* ---- round trips ------------------------------------------------------------ */
static void t_round_trip_every_type_and_size(void) {
    static const uint32_t sizes[] = { 0, 1, 2, 31, 32, 33, 255, 256, 4096, 65535, 65536 };
    unsigned t;
    size_t si, bad = 0, checked = 0;
    for (t = 1; t <= 20; ++t) {
        for (si = 0; si < sizeof sizes / sizeof sizes[0]; ++si) {
            http6_frame_header_t h = header((uint8_t)t, sizes[si]), back;
            uint8_t *payload = (uint8_t *)malloc(sizes[si] ? sizes[si] : 1), *wire;
            size_t n = 0, used = 0;
            http6_frame_view_t v;
            uint32_t i;
            REG_REQUIRE(payload != NULL);
            for (i = 0; i < sizes[si]; ++i) payload[i] = (uint8_t)reg_below(256);
            h.flags = (uint16_t)reg_next();
            h.stream_id = reg_next();
            h.request_id = reg_next();
            h.sequence = reg_next();
            wire = encode_exact(&h, payload, &n);
            REG_REQUIRE(wire != NULL);
            ++checked;
            if (http6_frame_decode(wire, n, &v, &used) != 0) { ++bad; free(wire); free(payload); continue; }
            back = v.header;
            if (used != n || back.version != h.version || back.type != h.type || back.flags != h.flags ||
                back.stream_id != h.stream_id || back.request_id != h.request_id ||
                back.sequence != h.sequence || back.payload_length != h.payload_length ||
                v.payload != wire + HDR || (sizes[si] && memcmp(v.payload, payload, sizes[si]) != 0))
                ++bad;
            free(wire);
            free(payload);
        }
    }
    REG_EQ_U(20 * 11, checked);
    REG_EQ_U(0, bad);
}

static void t_maximum_payload_round_trips(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_DATA, HTTP6_MAX_PAYLOAD);
    uint8_t *payload = (uint8_t *)calloc(HTTP6_MAX_PAYLOAD, 1), *wire;
    size_t n = 0, used = 0;
    http6_frame_view_t v;
    REG_REQUIRE(payload != NULL);
    payload[0] = 0x5A; payload[HTTP6_MAX_PAYLOAD - 1] = 0xA5;
    wire = encode_exact(&h, payload, &n);
    REG_REQUIRE(wire != NULL);
    REG_EQ_U(HDR + HTTP6_MAX_PAYLOAD, n);
    REG_EQ_I(0, http6_frame_decode(wire, n, &v, &used));
    REG_EQ_U(n, used);
    REG_EQ_I(0x5A, v.payload[0]);
    REG_EQ_I(0xA5, v.payload[HTTP6_MAX_PAYLOAD - 1]);
    REG_EQ_I(-3, http6_frame_decode(wire, n - 1, &v, &used));       /* one byte short of the maximum */
    free(wire);
    free(payload);
}

/* ---- hostile input ----------------------------------------------------------- */
/* Random buffers and single-byte corruptions of valid frames.  Whatever the
 * outcome, decode must stay inside the exact-size block (the guard bytes check
 * this), and a success must be self-consistent. */
static void t_random_input_never_escapes_the_buffer(void) {
    size_t i, accepted = 0, inconsistent = 0;
    reg_seed(0x6B6B6B6Bull);
    for (i = 0; i < 20000; ++i) {
        size_t len = reg_below(120), k;
        uint8_t *buf = (uint8_t *)malloc(len ? len : 1);
        http6_frame_view_t v;
        size_t used = 0;
        REG_REQUIRE(buf != NULL);
        for (k = 0; k < len; ++k) buf[k] = (uint8_t)reg_below(256);
        if (len >= 2 && (i & 1u)) { buf[0] = 6; buf[1] = (uint8_t)(1u + reg_below(20)); }   /* often header-plausible */
        if (len >= HDR && (i & 2u)) { buf[28] = 0; buf[29] = 0; buf[30] = 0; buf[31] = (uint8_t)reg_below(90); }
        if (http6_frame_decode(buf, len, &v, &used) == 0) {
            ++accepted;
            if (used > len || used != HDR + v.header.payload_length || v.payload != buf + HDR) ++inconsistent;
        }
        free(buf);
    }
    REG_CHECK(accepted > 100);                         /* the generator really reaches the accept path */
    REG_EQ_U(0, inconsistent);
}

static void t_single_byte_corruption_is_contained(void) {
    http6_frame_header_t h = header(HTTP6_FRAME_DATA, 16);
    uint8_t payload[16] = { 0 };
    size_t n = 0, pos, bad = 0;
    unsigned bit;
    uint8_t *w = encode_exact(&h, payload, &n);
    REG_REQUIRE(w != NULL);
    for (pos = 0; pos < n; ++pos) {
        for (bit = 0; bit < 8; ++bit) {
            uint8_t *copy = (uint8_t *)malloc(n);
            http6_frame_view_t v;
            size_t used = 0;
            REG_REQUIRE(copy != NULL);
            memcpy(copy, w, n);
            copy[pos] ^= (uint8_t)(1u << bit);
            if (http6_frame_decode(copy, n, &v, &used) == 0 && used > n) ++bad;
            free(copy);
        }
    }
    REG_EQ_U(0, bad);
    free(w);
}

int main(void) {
    printf("http6 frame regression suite\n");
    REG_RUN(t_validate_codes);
    REG_RUN(t_every_defined_type_is_valid_and_named);
    REG_RUN(t_wire_layout_is_big_endian);
    REG_RUN(t_encode_refusals);
    REG_RUN(t_encode_exact_capacity_and_empty_payload);
    REG_RUN(t_decode_refusals);
    REG_RUN(t_every_truncation_is_refused);
    REG_RUN(t_oversized_and_hostile_lengths);
    REG_RUN(t_bad_version_and_type_refused_on_the_wire);
    REG_RUN(t_trailing_bytes_are_not_consumed);
    REG_RUN(t_round_trip_every_type_and_size);
    REG_RUN(t_maximum_payload_round_trips);
    REG_RUN(t_random_input_never_escapes_the_buffer);
    REG_RUN(t_single_byte_corruption_is_contained);
    return reg_finish("http6");
}