Skip to content

LordOS — a free, fast and secure GNU/Linux distribution based on Debian, with its own desktop environment: display server and Wayland compositor in C, a React UI engine on QuickJS, and private native apps.

6.9 KB
Raw Blame
/* mailnet_test.c — lord-maild's wire readers against hostile servers (docs/MAIL.md): HTTP chunk
 * sizes and Content-Length (overflow, garbage, negative), header limits, IMAP literal sizes near
 * SIZE_MAX, and lines that never end. Everything runs over a local socketpair: no network and a
 * global alarm, so `make test` can never hang on it. */
#include "mail/http.h"
#include "mail/imapio.h"
#include "mail/net.h"

#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>

static int fails, checks;
#define CHECK(c) do { checks++; if (!(c)) { fails++; fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #c); } } while (0)

/* A "server" child that writes `resp` (len bytes, then repeats `tail` n times) and closes. */
static Conn *serve(const char *resp, size_t len, const char *tail, long reps) {
    int sv[2];
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv)) return NULL;
    pid_t p = fork();
    if (p == 0) {
        close(sv[0]);
        signal(SIGPIPE, SIG_IGN);
        /* drain what the client sends */
        if (fork() == 0) { char b[4096]; while (read(sv[1], b, sizeof b) > 0) {} _exit(0); }
        if (len && write(sv[1], resp, len) < 0) _exit(1);
        for (long i = 0; tail && i < reps; i++) if (write(sv[1], tail, strlen(tail)) < 0) break;
        shutdown(sv[1], SHUT_WR);
        _exit(0);
    }
    close(sv[1]);
    return conn_new(sv[0], "test", 5000);
}

static int http_case(const char *resp, size_t max, HttpResp *r) {
    Conn *c = serve(resp, strlen(resp), NULL, 0);
    int rc = http_request(c, "GET", "test", "/", NULL, NULL, 0, max, 5000, r);
    conn_close(c);
    while (waitpid(-1, NULL, WNOHANG) > 0) {}
    return rc;
}

int main(void) {
    alarm(60);
    signal(SIGPIPE, SIG_IGN);
    unsigned long long v;
    CHECK(http_chunk_size("1a\r\n", &v) == 0 && v == 26);
    CHECK(http_chunk_size("0\r\n", &v) == 0 && v == 0);
    CHECK(http_chunk_size("10;name=val\r\n", &v) == 0 && v == 16);
    CHECK(http_chunk_size("ffffffffffffffff\r\n", &v) == 0 && v == 0xffffffffffffffffull);   /* parsed, then rejected by size */
    CHECK(http_chunk_size("1ffffffffffffffff\r\n", &v) == -1);       /* 17 digits: ERANGE */
    CHECK(http_chunk_size("-1\r\n", &v) == -1);
    CHECK(http_chunk_size("zz\r\n", &v) == -1);
    CHECK(http_chunk_size("12 garbage\r\n", &v) == -1);
    CHECK(http_chunk_size("\r\n", &v) == -1);
    CHECK(http_content_length("123", &v) == 0 && v == 123);
    CHECK(http_content_length(" 42 ", &v) == 0 && v == 42);
    CHECK(http_content_length("-5", &v) == -1);
    CHECK(http_content_length("99999999999999999999999", &v) == -1);
    CHECK(http_content_length("12abc", &v) == -1);
    CHECK(http_content_length("", &v) == -1);

    HttpResp r;
    CHECK(http_case("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhello\r\n6\r\n world\r\n0\r\n\r\n", 1 << 20, &r) == 0 && r.blen == 11 && !strcmp(r.body, "hello world"));
    http_resp_free(&r);
    CHECK(http_case("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\nffffffffffffffff\r\nxx", 1 << 20, &r) == -2);
    CHECK(http_case("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\nfffffffffffffff0\r\nxx", 1 << 20, &r) == -2);
    CHECK(http_case("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhello\r\nfffffffffffffffb\r\nx", 1 << 20, &r) == -2);
    CHECK(http_case("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5 junk\r\nhello\r\n0\r\n\r\n", 1 << 20, &r) == -1);
    CHECK(http_case("HTTP/1.1 200 OK\r\nContent-Length: 18446744073709551615\r\n\r\nx", 1 << 20, &r) == -1);
    CHECK(http_case("HTTP/1.1 200 OK\r\nContent-Length: 9223372036854775807\r\n\r\nx", 1 << 20, &r) == -2);
    CHECK(http_case("HTTP/1.1 200 OK\r\nContent-Length: -1\r\n\r\nx", 1 << 20, &r) == -1);
    CHECK(http_case("HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\nabcd", 1 << 20, &r) == 0 && r.blen == 4);
    http_resp_free(&r);
    CHECK(http_case("HTTP/1.1 200 OK\r\nContent-Length: 400\r\n\r\nabcd", 100, &r) == -2);
    /* endless headers and an endless header line */
    {
        Conn *c = serve("HTTP/1.1 200 OK\r\n", 17, "X-A: b\r\n", 100000);
        CHECK(http_request(c, "GET", "test", "/", NULL, NULL, 0, 1 << 20, 5000, &r) == -1);
        conn_close(c);
        c = serve("HTTP/1.1 200 OK\r\nX-Long: ", 25, "aaaaaaaaaaaaaaaa", 100000);
        CHECK(http_request(c, "GET", "test", "/", NULL, NULL, 0, 1 << 20, 5000, &r) == -1);
        conn_close(c);
        c = serve("HTTP/1.1 200 OK\r\n\r\n", 19, "0123456789abcdef", 100000);    /* body until close, over the cap */
        CHECK(http_request(c, "GET", "test", "/", NULL, NULL, 0, 4096, 5000, &r) == -2);
        conn_close(c);
    }
    /* IMAP literals */
    CHECK(imap_literal_size("* 1 FETCH (BODY[] {12}\r\n", 24) == 12);
    CHECK(imap_literal_size("* 1 FETCH (BODY[] {12+}\r\n", 25) == 12);
    CHECK(imap_literal_size("* OK done\r\n", 11) == -1);
    CHECK(imap_literal_size("a {}\r\n", 6) == -1);
    CHECK(imap_literal_size("a {18446744073709551615}\r\n", 26) == -2);
    CHECK(imap_literal_size("a {99999999999}\r\n", 17) == 99999999999LL);
    char err[96];
    size_t len;
    const char *ok = "* 1 FETCH (BODY[] {5}\r\nhello)\r\n";
    Conn *c = serve(ok, strlen(ok), NULL, 0);
    char *resp = imap_read_response(c, &len, 1 << 20, 1 << 20, err, sizeof err);
    CHECK(resp && len == strlen(ok) && !memcmp(resp, ok, len) && resp[len] == 0);
    free(resp);
    conn_close(c);
    static const char *bad[] = {
        "* 1 FETCH (BODY[] {18446744073709551615}\r\nx",
        "* 1 FETCH (BODY[] {18446744073709551614}\r\nx",
        "* 1 FETCH (BODY[] {4294967296}\r\nx",
        "* 1 FETCH (BODY[] {2000000}\r\nshort",
    };
    for (size_t i = 0; i < sizeof bad / sizeof bad[0]; i++) {
        c = serve(bad[i], strlen(bad[i]), NULL, 0);
        resp = imap_read_response(c, &len, 1 << 20, 1 << 20, err, sizeof err);
        CHECK(resp == NULL);
        free(resp);
        conn_close(c);
    }
    /* literals of every size around the buffer growth boundaries (off-by-one hunting under ASan) */
    for (int n = 0; n < 1100; n += (n < 70 ? 1 : 37)) {
        char head[64];
        int hl = snprintf(head, sizeof head, "* 1 FETCH (BODY[] {%d}\r\n", n);
        char *msg = malloc((size_t)hl + (size_t)n + 4);
        memcpy(msg, head, (size_t)hl);
        memset(msg + hl, 'x', (size_t)n);
        memcpy(msg + hl + n, ")\r\n", 3);
        c = serve(msg, (size_t)hl + (size_t)n + 3, NULL, 0);
        resp = imap_read_response(c, &len, 1 << 20, 1 << 20, err, sizeof err);
        CHECK(resp && len == (size_t)hl + (size_t)n + 3 && resp[len] == 0);
        free(resp);
        conn_close(c);
        free(msg);
    }
    /* a line that never ends */
    c = serve("* OK ", 5, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 100000);
    resp = imap_read_response(c, &len, 65536, 1 << 20, err, sizeof err);
    CHECK(resp == NULL);
    conn_close(c);
    while (waitpid(-1, NULL, WNOHANG) > 0) {}
    printf("mailnet-test: %d/%d checks ok\n", checks - fails, checks);
    return fails ? 1 : 0;
}