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.

34.0 KB
Raw Blame
/* dbus_test.c — our own D-Bus and Secret Service (src/vault/dbus.c, secretsvc.c):
 *   - valid and invalid signatures, paths and names;
 *   - round trip of every type (write → build → validate → read) and alignment cases;
 *   - real messages captured with dbus-monitor --binary (secret-tool + libsecret), if present;
 *   - rejection of truncated and huge messages, and of invalid signatures, booleans, paths or padding;
 *   - "fuzz": flipped bytes and random cuts over valid messages (it never crashes);
 *   - the 1024-bit arithmetic against Python's pow() and RFC 2409 group 2;
 *   - the Secret Service end to end with a fake bus (socketpair + fork): plain and DH sessions
 *     (our own client: modexp + HKDF + AES-128-CBC), create, search, read, change, delete,
 *     properties, introspection, lock and unlock with a prompt (Prompt + Completed). */
#include "vault/dbus.h"
#include "vault/secretsvc.h"
#include "vault/smem.h"
#include "vault/vcrypto.h"
#include "ss_memback.h"

#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

static int fails, total;
static void check(int ok, const char *what) { total++; if (!ok) { fails++; printf("FAIL: %s\n", what); } }

static void unhex(const char *h, uint8_t *out, size_t n) {
    for (size_t i = 0; i < n; i++) { unsigned v; sscanf(h + 2 * i, "%2x", &v); out[i] = (uint8_t)v; }
}

/* ---------- signatures ---------- */
static void t_sigs(void) {
    const char *good[] = { "", "s", "a{sv}", "(oayays)", "a{o(oayays)}", "aoao", "a{ss}", "vo", "a(yv)", "aaaai", "(i(s(b)))", "sa{sv}as", NULL };
    const char *bad[] = { "a", "a{", "a{sv", "{sv}", "()", "(s", "a{vs}", "a{(s)s}", "z", "ss)", "a{s}", "a{sss}", NULL };
    for (int i = 0; good[i]; i++) check(dbus_sig_valid(good[i]), good[i]);
    for (int i = 0; bad[i]; i++) check(!dbus_sig_valid(bad[i]), bad[i]);
    char deep[80];
    memset(deep, 'a', 40);
    strcpy(deep + 40, "i");
    check(!dbus_sig_valid(deep), "signature nested too deep");
    check(dbus_path_valid("/") && dbus_path_valid("/org/freedesktop/secrets") && dbus_path_valid("/a_b/C9"), "valid paths");
    check(!dbus_path_valid("") && !dbus_path_valid("org") && !dbus_path_valid("/a/") && !dbus_path_valid("//a") && !dbus_path_valid("/a-b"), "invalid paths");
    check(dbus_name_valid("org.freedesktop.Secret.Service") && !dbus_name_valid("org") && !dbus_name_valid(".a.b") && !dbus_name_valid("a..b") && !dbus_name_valid("1a.b"), "names");
}

/* ---------- round trip ---------- */
static int build_parse(DHdr *h, DBuf *body, DMsg *m) {
    DBuf out;
    if (dbus_build(h, body, &out)) { dw_free(&out); return -1; }
    long sz = dbus_msg_size(out.p, out.n);
    int r = sz == (long)out.n ? dbus_msg_parse(out.p, out.n, m) : -1;
    dw_free(&out);
    return r;
}

static void t_roundtrip(void) {
    DBuf b;
    dw_init(&b);
    dw_u8(&b, 0xab);
    dw_bool(&b, 1);
    dw_i32(&b, -5);
    dw_u32(&b, 0xdeadbeef);
    dw_u64(&b, 0x0123456789abcdefULL);
    dw_str(&b, "hola, ñandú");
    dw_str(&b, "/org/freedesktop/secrets");
    dw_sig(&b, "a{sv}");
    uint8_t raw[300];
    for (int i = 0; i < 300; i++) raw[i] = (uint8_t)i;
    dw_bytes(&b, raw, 300);
    size_t mk = dw_arr_begin(&b, 8);            /* a{ss} */
    for (int i = 0; i < 3; i++) { dw_struct(&b); dw_str(&b, i ? "k" : "service"); dw_str(&b, "v"); }
    dw_arr_end(&b, mk);
    mk = dw_arr_begin(&b, 8);                   /* a{sv} */
    dw_struct(&b); dw_str(&b, "Label"); dw_variant(&b, "s"); dw_str(&b, "x");
    dw_struct(&b); dw_str(&b, "Num"); dw_variant(&b, "t"); dw_u64(&b, 7);
    dw_struct(&b); dw_str(&b, "Arr"); dw_variant(&b, "ao");
    size_t mk2 = dw_arr_begin(&b, 4); dw_str(&b, "/a"); dw_str(&b, "/b"); dw_arr_end(&b, mk2);
    dw_arr_end(&b, mk);
    dw_struct(&b);                               /* (oayays) */
    dw_str(&b, "/s/1"); dw_bytes(&b, raw, 16); dw_bytes(&b, raw, 5); dw_str(&b, "text/plain");
    mk = dw_arr_begin(&b, 8);                   /* empty ax: still aligned to 8 */
    dw_arr_end(&b, mk);
    const char *sig = "ybiuts" "og" "aya{ss}a{sv}(oayays)ax";
    DHdr h = { .type = DBUS_CALL, .serial = 9, .path = "/test", .iface = "a.b", .member = "M", .dest = "x.y", .sig = sig, .sender = ":1.1" };
    DMsg m;
    int r = build_parse(&h, &b, &m);
    check(r == 0, "round trip: build and validate");
    if (r) { dw_free(&b); return; }
    check(!strcmp(m.path, "/test") && !strcmp(m.iface, "a.b") && !strcmp(m.member, "M") && !strcmp(m.dest, "x.y") && !strcmp(m.sender, ":1.1") && !strcmp(m.sig, sig) && m.serial == 9, "header fields");
    DRd d;
    dr_init(&d, &m);
    check(dr_u8(&d) == 0xab && dr_bool(&d) == 1 && dr_i32(&d) == -5 && dr_u32(&d) == 0xdeadbeef && dr_u64(&d) == 0x0123456789abcdefULL, "numbers");
    check(!strcmp(dr_str(&d, NULL), "hola, ñandú") && !strcmp(dr_str(&d, NULL), "/org/freedesktop/secrets") && !strcmp(dr_sig(&d), "a{sv}"), "strings");
    uint32_t n;
    const uint8_t *p = dr_bytes(&d, &n);
    check(n == 300 && !memcmp(p, raw, 300), "ay");
    size_t end = dr_arr(&d, 8);
    int k = 0;
    while (dr_more(&d, end)) { dr_struct(&d); dr_str(&d, NULL); dr_str(&d, NULL); k++; }
    check(k == 3, "a{ss}");
    end = dr_arr(&d, 8);
    k = 0;
    while (dr_more(&d, end)) { dr_struct(&d); dr_str(&d, NULL); const char *vs = dr_variant(&d); dr_skip(&d, vs); k++; }
    check(k == 3, "a{sv} with dr_skip");
    dr_struct(&d);
    check(!strcmp(dr_str(&d, NULL), "/s/1"), "(oayays) o");
    dr_bytes(&d, &n); check(n == 16, "(oayays) params");
    dr_bytes(&d, &n); check(n == 5, "(oayays) value");
    check(!strcmp(dr_str(&d, NULL), "text/plain"), "(oayays) s");
    end = dr_arr(&d, 8);
    check(!dr_more(&d, end) && !d.err && d.pos == d.len, "empty ax and exact end");
    dbus_msg_free(&m);
    dw_free(&b);

    /* alignment: y followed by t (7 bytes of padding), empty body without a signature */
    dw_init(&b);
    dw_u8(&b, 1);
    dw_u64(&b, 2);
    check(b.n == 16 && b.p[1] == 0 && b.p[7] == 0 && b.p[8] == 2, "y→t padding");
    DHdr h2 = { .type = DBUS_RETURN, .serial = 3, .reply_serial = 2, .sig = "yt" };
    check(build_parse(&h2, &b, &m) == 0, "valid yt");
    dbus_msg_free(&m);
    dw_free(&b);
    DHdr h3 = { .type = DBUS_SIGNAL, .serial = 4, .path = "/", .iface = "a.b", .member = "S" };
    check(build_parse(&h3, NULL, &m) == 0 && m.body_len == 0 && !strcmp(m.sig, ""), "signal without a body");
    dbus_msg_free(&m);
}

/* ---------- rejections ---------- */
static uint8_t *valid_msg(size_t *len) {
    DBuf b;
    dw_init(&b);
    dw_str(&b, "hola");
    dw_bool(&b, 0);
    size_t mk = dw_arr_begin(&b, 8);
    dw_struct(&b); dw_str(&b, "a"); dw_variant(&b, "s"); dw_str(&b, "b");
    dw_arr_end(&b, mk);
    DHdr h = { .type = DBUS_CALL, .serial = 1, .path = "/x", .member = "M", .sig = "sba{sv}" };
    DBuf out;
    dbus_build(&h, &b, &out);
    dw_free(&b);
    uint8_t *p = malloc(out.n);
    memcpy(p, out.p, out.n);
    *len = out.n;
    dw_free(&out);
    return p;
}

static void t_reject(void) {
    size_t len;
    uint8_t *v = valid_msg(&len);
    DMsg m;
    check(dbus_msg_parse(v, len, &m) == 0, "valid base");
    dbus_msg_free(&m);
    int ok = 1;
    for (size_t i = 0; i < len; i++) {
        long s = dbus_msg_size(v, i);
        if (s > 0 && s == (long)i) ok = 0;
        if (dbus_msg_parse(v, i, &m) == 0) { ok = 0; dbus_msg_free(&m); }
    }
    check(ok, "every cut is rejected");
    uint8_t *w = malloc(len);
    /* huge body length */
    memcpy(w, v, len); w[4] = 0xff; w[5] = 0xff; w[6] = 0xff; w[7] = 0x7f;
    check(dbus_msg_size(w, len) == -1, "2 GB body");
    /* bad version / bad byte order / bad type / serial 0 */
    memcpy(w, v, len); w[3] = 2; check(dbus_msg_parse(w, len, &m) != 0, "version 2");
    memcpy(w, v, len); w[0] = 'x'; check(dbus_msg_parse(w, len, &m) != 0, "byte order");
    memcpy(w, v, len); w[1] = 9; check(dbus_msg_parse(w, len, &m) != 0, "type 9");
    memcpy(w, v, len); memset(w + 8, 0, 4); check(dbus_msg_parse(w, len, &m) != 0, "serial 0");
    /* find things in the message and break them: the boolean (last u32 before the array), the signature */
    uint8_t *sg = memmem(w, len, "sba{sv}", 7);
    memcpy(w, v, len); sg = memmem(w, len, "sba{sv}", 7);
    if (sg) { sg[3] = '('; check(dbus_msg_parse(w, len, &m) != 0, "broken signature"); }
    memcpy(w, v, len); sg = memmem(w, len, "hola", 4);
    if (sg) {
        sg[1] = 0; check(dbus_msg_parse(w, len, &m) != 0, "NUL inside a string");
        memcpy(w, v, len);
        size_t bo = (size_t)(sg - w) + 5;           /* after "hola\0" comes the aligned boolean */
        bo = (bo + 3) & ~(size_t)3;
        w[bo] = 2; check(dbus_msg_parse(w, len, &m) != 0, "boolean 2");
        memcpy(w, v, len);
        w[(size_t)(sg - w) + 5] = 7;                /* non-zero padding */
        check(dbus_msg_parse(w, len, &m) != 0, "non-zero padding");
    }
    memcpy(w, v, len); sg = memmem(w, len, "/x", 2);
    if (sg) { sg[1] = '-'; check(dbus_msg_parse(w, len, &m) != 0, "invalid path"); }
    /* call without a member */
    DBuf out;
    DHdr h = { .type = DBUS_CALL, .serial = 1, .path = "/x" };
    dbus_build(&h, NULL, &out);
    check(dbus_msg_parse(out.p, out.n, &m) != 0, "call without a member");
    dw_free(&out);
    /* error without reply_serial */
    DHdr he = { .type = DBUS_ERROR, .serial = 1, .error = "a.b" };
    dbus_build(&he, NULL, &out);
    check(dbus_msg_parse(out.p, out.n, &m) != 0, "error without reply_serial");
    dw_free(&out);
    /* body without a signature */
    DBuf b;
    dw_init(&b);
    dw_u32(&b, 1);
    DHdr hn = { .type = DBUS_RETURN, .serial = 1, .reply_serial = 1 };
    dbus_build(&hn, &b, &out);
    check(dbus_msg_parse(out.p, out.n, &m) != 0, "body without a signature");
    dw_free(&out);
    /* array whose length runs past the end, and a variant with two types */
    dw_free(&b); dw_init(&b);
    dw_u32(&b, 1000);
    DHdr ha = { .type = DBUS_RETURN, .serial = 1, .reply_serial = 1, .sig = "ay" };
    dbus_build(&ha, &b, &out);
    check(dbus_msg_parse(out.p, out.n, &m) != 0, "array longer than the body");
    dw_free(&out);
    dw_free(&b); dw_init(&b);
    dw_sig(&b, "ss"); dw_str(&b, "a"); dw_str(&b, "b");
    DHdr hv = { .type = DBUS_RETURN, .serial = 1, .reply_serial = 1, .sig = "v" };
    dbus_build(&hv, &b, &out);
    check(dbus_msg_parse(out.p, out.n, &m) != 0, "variant with two types");
    dw_free(&out);
    /* endlessly nested variants */
    dw_free(&b); dw_init(&b);
    for (int i = 0; i < 40; i++) dw_sig(&b, "v");
    dw_sig(&b, "y"); dw_u8(&b, 1);
    dbus_build(&hv, &b, &out);
    check(dbus_msg_parse(out.p, out.n, &m) != 0, "too many nested variants");
    dw_free(&out);
    dw_free(&b);
    free(w);
    free(v);
}

/* ---------- fuzz ---------- */
static uint64_t rs = 88172645463325252ULL;
static uint32_t rnd(void) { rs ^= rs << 13; rs ^= rs >> 7; rs ^= rs << 17; return (uint32_t)rs; }

static void walk(const DMsg *m) {
    DRd r;
    dr_init(&r, m);
    size_t p = 0, n = strlen(m->sig);
    while (p < n && !r.err) {
        size_t k;
        if (dbus_sig_single(m->sig + p, &k)) break;
        char one[256];
        memcpy(one, m->sig + p, k);
        one[k] = 0;
        dr_skip(&r, one);
        p += k;
    }
}

static int fuzz_one(const uint8_t *base, size_t len, int rounds) {
    uint8_t *w = malloc(len + 64);
    int accepted = 0;
    for (int it = 0; it < rounds; it++) {
        size_t l = len;
        memcpy(w, base, len);
        int flips = 1 + (int)(rnd() % 4);
        for (int f = 0; f < flips; f++) {
            size_t at = rnd() % len;
            switch (rnd() % 4) {
            case 0: w[at] ^= (uint8_t)(1u << (rnd() % 8)); break;
            case 1: w[at] = (uint8_t)rnd(); break;
            case 2: w[at] = (uint8_t)(rnd() % 2 ? 0xff : 0); break;
            case 3: l = rnd() % (len + 1); break;
            }
        }
        long sz = dbus_msg_size(w, l);
        DMsg m;
        if (sz > 0 && (size_t)sz <= l && dbus_msg_parse(w, (size_t)sz, &m) == 0) { accepted++; walk(&m); dbus_msg_free(&m); }
    }
    free(w);
    return accepted;
}

/* ---------- real captures ---------- */
static int t_capture(const char *file, uint8_t ***msgs, size_t **lens) {
    FILE *f = fopen(file, "rb");
    if (!f) return -1;
    static uint8_t buf[1 << 20];
    size_t n = fread(buf, 1, sizeof buf, f);
    fclose(f);
    int count = 0, bad = 0;
    *msgs = NULL;
    *lens = NULL;
    for (size_t p = 0; p + 16 <= n;) {
        long s = dbus_msg_size(buf + p, n - p);
        if (s <= 0 || (size_t)s > n - p) { bad++; break; }
        DMsg m;
        if (dbus_msg_parse(buf + p, (size_t)s, &m)) bad++;
        else {
            walk(&m);
            dbus_msg_free(&m);
            *msgs = realloc(*msgs, sizeof(uint8_t *) * (size_t)(count + 1));
            *lens = realloc(*lens, sizeof(size_t) * (size_t)(count + 1));
            (*msgs)[count] = malloc((size_t)s);
            memcpy((*msgs)[count], buf + p, (size_t)s);
            (*lens)[count] = (size_t)s;
            count++;
        }
        p += (size_t)s;
    }
    check(!bad, "captures: every message valid");
    return count;
}

/* ---------- 1024 bits ---------- */
static const char *const MODEXP[][4] = {
#include "secretsvc/modexp_vectors.h"
};

static void t_modexp(void) {
    int n = (int)(sizeof MODEXP / sizeof MODEXP[0]), ok = 1;
    for (int i = 0; i < n; i++) {
        uint8_t b[128], e[128], m[128], want[128], got[128];
        unhex(MODEXP[i][0], b, 128); unhex(MODEXP[i][1], e, 128); unhex(MODEXP[i][2], m, 128); unhex(MODEXP[i][3], want, 128);
        if (ss_dh_modexp(b, e, m, got) || memcmp(got, want, 128)) { ok = 0; printf("  modexp vector %d\n", i); }
    }
    check(ok, "modexp against Python's pow()");
    check(!memcmp(ss_dh_prime(), (const uint8_t *)"\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x0f\xda\xa2", 12) && ss_dh_prime()[127] == 0xff, "group 2 prime");
    uint8_t even[128] = { 0 }, one[128] = { 0 }, out[128];
    even[127] = 4; one[127] = 1;
    check(ss_dh_modexp(one, one, even, out) != 0, "even modulus rejected");
    double t0 = (double)clock();
    for (int i = 0; i < 10; i++) ss_dh_modexp(one, (const uint8_t *)MODEXP[0][1], ss_dh_prime(), out);
    printf("1024-bit modexp: %.2f ms\n", ((double)clock() - t0) / CLOCKS_PER_SEC * 100.0);
}

/* ---------- Secret Service with a fake bus ---------- */
static DConn bus;
static uint32_t bserial = 100;
static int completed_seen, completed_dismissed, item_created_seen;

static int bus_read_line(int fd, char *out, size_t cap) {
    size_t n = 0;
    while (n + 1 < cap) {
        struct pollfd p = { fd, POLLIN, 0 };
        if (poll(&p, 1, 5000) <= 0) return -1;
        if (read(fd, out + n, 1) != 1) return -1;
        n++;
        if (n >= 2 && out[n - 2] == '\r' && out[n - 1] == '\n') { out[n - 2] = 0; return 0; }
    }
    return -1;
}

static void bus_send(DHdr *h, DBuf *b) { h->serial = ++bserial; dbus_send(&bus, h, b); }

/* waits for the reply to serial (answers the service's calls to the bus with an error, takes note of
 * the signals). 1 RETURN, 0 ERROR, -1 nothing */
static int bus_wait(uint32_t serial, DMsg *m, int ms) {
    double end = (double)time(NULL) + ms / 1000.0 + 1;
    while ((double)time(NULL) < end) {
        dbus_flush(&bus);
        int r = dbus_next(&bus, m);
        if (r < 0) return -1;
        if (r == 0) { struct pollfd p = { bus.fd, POLLIN, 0 }; poll(&p, 1, 100); continue; }
        if (m->type == DBUS_SIGNAL) {
            if (!strcmp(m->member, "Completed")) { completed_seen++; DRd d; dr_init(&d, m); completed_dismissed = dr_bool(&d); }
            if (!strcmp(m->member, "ItemCreated")) item_created_seen++;
            dbus_msg_free(m);
            if (!serial) return 2;
            continue;
        }
        if (m->type == DBUS_CALL) {      /* GetConnectionUnixProcessID: answer 4242 */
            if (!strcmp(m->member, "GetConnectionUnixProcessID")) {
                DBuf b; dw_init(&b); dw_u32(&b, 4242);
                DHdr h = { .type = DBUS_RETURN, .reply_serial = m->serial, .dest = ":1.7", .sig = "u", .sender = "org.freedesktop.DBus" };
                bus_send(&h, &b);
                dw_free(&b);
            }
            dbus_msg_free(m);
            continue;
        }
        if (m->reply_serial == serial) return m->type == DBUS_RETURN ? 1 : 0;
        dbus_msg_free(m);
    }
    return -1;
}

static int call(const char *sender, const char *path, const char *iface, const char *member, const char *sig, DBuf *body, DMsg *m) {
    DHdr h = { .type = DBUS_CALL, .path = path, .iface = iface, .member = member, .dest = ":1.7", .sig = sig, .sender = sender };
    bus_send(&h, body);
    return bus_wait(h.serial, m, 5000);
}

static void serve_child(int fd) {
    MemBack *mb = calloc(1, sizeof *mb);
    memback_init(mb, 0);
    if (ss_start(fd, &memback_ops, mb)) _exit(2);
    for (;;) {
        struct pollfd p = { ss_fd(), POLLIN, 0 };
        poll(&p, 1, 50);
        if (ss_dispatch() < 0) break;
        memback_tick(mb);
    }
    _exit(0);
}

typedef struct { int dh; uint8_t key[16]; char path[64]; } Cli;

static int open_session(Cli *c, int dh) {
    DBuf b;
    dw_init(&b);
    uint8_t priv[128], pub[128], g[128] = { 0 };
    g[127] = 2;
    if (dh) {
        vc_random(priv, 128);
        priv[0] &= 0x3f;
        ss_dh_modexp(g, priv, ss_dh_prime(), pub);
        dw_str(&b, "dh-ietf1024-sha256-aes128-cbc-pkcs7");
        dw_variant(&b, "ay");
        dw_bytes(&b, pub, 128);
    } else { dw_str(&b, "plain"); dw_variant(&b, "s"); dw_str(&b, ""); }
    DMsg m;
    int r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "OpenSession", "sv", &b, &m);
    dw_free(&b);
    if (r != 1 || strcmp(m.sig, "vo")) { if (r >= 0) dbus_msg_free(&m); return -1; }
    DRd d;
    dr_init(&d, &m);
    const char *vs = dr_variant(&d);
    c->dh = dh;
    if (dh) {
        uint32_t n;
        const uint8_t *sp = dr_bytes(&d, &n);
        uint8_t y[128] = { 0 }, sh[128];
        if (strcmp(vs, "ay") || n != 128) { dbus_msg_free(&m); return -1; }
        memcpy(y, sp, 128);
        ss_dh_modexp(y, priv, ss_dh_prime(), sh);
        hkdf_sha256(NULL, 0, sh, 128, NULL, 0, c->key, 16);
    } else dr_str(&d, NULL);
    snprintf(c->path, sizeof c->path, "%s", dr_str(&d, NULL));
    dbus_msg_free(&m);
    return 0;
}

static void put_secret(DBuf *b, const Cli *c, const char *val) {
    dw_struct(b);
    dw_str(b, c->path);
    size_t n = strlen(val);
    if (c->dh) {
        uint8_t iv[16], iv2[16], buf[256];
        vc_random(iv, 16);
        memcpy(iv2, iv, 16);
        size_t pl = n / 16 * 16 + 16;
        memcpy(buf, val, n);
        memset(buf + n, (int)(pl - n), pl - n);
        Aes a;
        aes_init(&a, c->key, 128);
        aes_cbc_encrypt(&a, iv2, buf, buf, pl);
        dw_bytes(b, iv, 16);
        dw_bytes(b, buf, pl);
    } else { dw_bytes(b, NULL, 0); dw_bytes(b, (const uint8_t *)val, n); }
    dw_str(b, "text/plain");
}

static int get_secret_val(DRd *d, const Cli *c, char *out, size_t cap) {
    dr_struct(d);
    dr_str(d, NULL);
    uint32_t pl, vl;
    const uint8_t *params = dr_bytes(d, &pl), *val = dr_bytes(d, &vl);
    dr_str(d, NULL);
    if (d->err || vl >= cap) return -1;
    uint8_t buf[512];
    memcpy(buf, val, vl);
    if (c->dh) {
        if (pl != 16 || vl % 16) return -1;
        uint8_t iv[16];
        memcpy(iv, params, 16);
        Aes a;
        aes_init(&a, c->key, 128);
        aes_cbc_decrypt(&a, iv, buf, buf, vl);
        long n = pkcs7_unpad(buf, vl);
        if (n < 0) return -1;
        vl = (uint32_t)n;
    }
    memcpy(out, buf, vl);
    out[vl] = 0;
    return 0;
}

/* The real flow with the fake bus: Hello and RequestName have to be answered first. */
static int fake_bus_start(pid_t *pid_out) {
    int sv[2];
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv)) return -1;
    pid_t pid = fork();
    if (pid == 0) { close(sv[0]); serve_child(sv[1]); }
    close(sv[1]);
    *pid_out = pid;
    int fd = sv[0];
    char line[256], nul;
    if (read(fd, &nul, 1) != 1 || bus_read_line(fd, line, sizeof line)) return -1;
    if (write(fd, "OK 0123456789abcdef0123456789abcdef\r\n", 37) != 37) return -1;
    if (bus_read_line(fd, line, sizeof line) || strcmp(line, "BEGIN")) return -1;
    memset(&bus, 0, sizeof bus);
    bus.fd = fd;
    for (int step = 0; step < 2; step++) {
        DMsg m;
        int got = 0;
        for (int i = 0; i < 100 && !got; i++) {
            int r = dbus_next(&bus, &m);
            if (r < 0) return -1;
            if (r == 0) { struct pollfd p = { fd, POLLIN, 0 }; poll(&p, 1, 50); continue; }
            got = 1;
        }
        if (!got || m.type != DBUS_CALL) return -1;
        DBuf b;
        dw_init(&b);
        const char *sig;
        if (!strcmp(m.member, "Hello")) { dw_str(&b, ":1.7"); sig = "s"; }
        else if (!strcmp(m.member, "RequestName")) {
            DRd d; dr_init(&d, &m);
            check(!strcmp(dr_str(&d, NULL), "org.freedesktop.secrets") && dr_u32(&d) == 4, "RequestName with DO_NOT_QUEUE");
            dw_u32(&b, 1); sig = "u";
        } else { dbus_msg_free(&m); dw_free(&b); return -1; }
        DHdr h = { .type = DBUS_RETURN, .reply_serial = m.serial, .dest = ":1.7", .sig = sig, .sender = "org.freedesktop.DBus" };
        bus_send(&h, &b);
        dw_free(&b);
        dbus_msg_free(&m);
    }
    return 0;
}

static void attrs2(DBuf *b, const char *k1, const char *v1, const char *k2, const char *v2) {
    size_t mk = dw_arr_begin(b, 8);
    if (k1) { dw_struct(b); dw_str(b, k1); dw_str(b, v1); }
    if (k2) { dw_struct(b); dw_str(b, k2); dw_str(b, v2); }
    dw_arr_end(b, mk);
}

static char *create(const Cli *c, const char *label, const char *user, const char *secret, int replace, int *err) {
    DBuf b;
    dw_init(&b);
    size_t mk = dw_arr_begin(&b, 8);
    dw_struct(&b); dw_str(&b, "org.freedesktop.Secret.Item.Label"); dw_variant(&b, "s"); dw_str(&b, label);
    dw_struct(&b); dw_str(&b, "org.freedesktop.Secret.Item.Attributes"); dw_variant(&b, "a{ss}");
    attrs2(&b, "service", "demo", "user", user);
    dw_struct(&b); dw_str(&b, "otra.cosa"); dw_variant(&b, "a{sv}");     /* unknown: skipped */
    size_t mk2 = dw_arr_begin(&b, 8); dw_struct(&b); dw_str(&b, "x"); dw_variant(&b, "u"); dw_u32(&b, 1); dw_arr_end(&b, mk2);
    dw_arr_end(&b, mk);
    put_secret(&b, c, secret);
    dw_bool(&b, replace);
    DMsg m;
    int r = call(":1.9", "/org/freedesktop/secrets/collection/login", "org.freedesktop.Secret.Collection", "CreateItem", "a{sv}(oayays)b", &b, &m);
    dw_free(&b);
    *err = r;
    if (r != 1) { if (r >= 0) dbus_msg_free(&m); return NULL; }
    DRd d;
    dr_init(&d, &m);
    char *p = strdup(dr_str(&d, NULL));
    dbus_msg_free(&m);
    return p;
}

static int read_item(const char *item, const Cli *c, const char *sender, char *out) {
    DBuf b;
    dw_init(&b);
    dw_str(&b, c->path);
    DMsg m;
    int r = call(sender, item, "org.freedesktop.Secret.Item", "GetSecret", "o", &b, &m);
    dw_free(&b);
    if (r != 1) { if (r == 0) { snprintf(out, 128, "%s", m.error); dbus_msg_free(&m); } return -1; }
    DRd d;
    dr_init(&d, &m);
    int ok = get_secret_val(&d, c, out, 128);
    dbus_msg_free(&m);
    return ok;
}

static int search_count(const char *user, int *nlocked) {
    DBuf b;
    dw_init(&b);
    attrs2(&b, "service", "demo", user ? "user" : NULL, user);
    DMsg m;
    int r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "SearchItems", "a{ss}", &b, &m);
    dw_free(&b);
    if (r != 1) { if (r >= 0) dbus_msg_free(&m); return -1; }
    DRd d;
    dr_init(&d, &m);
    int n = 0, l = 0;
    size_t end = dr_arr(&d, 4);
    while (dr_more(&d, end)) { dr_str(&d, NULL); n++; }
    end = dr_arr(&d, 4);
    while (dr_more(&d, end)) { dr_str(&d, NULL); l++; }
    dbus_msg_free(&m);
    if (nlocked) *nlocked = l;
    return n;
}

static void t_service_flow(void) {
    pid_t pid;
    if (fake_bus_start(&pid)) { check(0, "fake bus: startup"); return; }
    check(1, "fake bus: SASL, Hello and RequestName");
    Cli plain, dh;
    check(open_session(&plain, 0) == 0, "OpenSession plain");
    check(open_session(&dh, 1) == 0, "OpenSession dh-ietf1024-sha256-aes128-cbc-pkcs7");
    int err;
    char *it1 = create(&plain, "Correo", "ana", "clave plana ñ", 0, &err);
    check(it1 != NULL, "CreateItem (plain)");
    char *it2 = create(&dh, "Banco", "beto", "secreto con DH: 0123456789abcdef", 0, &err);
    check(it2 != NULL, "CreateItem (DH)");
    char *it3 = create(&dh, "Banco", "beto", "reemplazado", 1, &err);
    check(it3 && it2 && !strcmp(it2, it3), "CreateItem replace reuses the item");
    char v[128];
    check(read_item(it1, &plain, ":1.9", v) == 0 && !strcmp(v, "clave plana ñ"), "GetSecret plain");
    check(read_item(it1, &dh, ":1.9", v) == 0 && !strcmp(v, "clave plana ñ"), "GetSecret DH (decrypted on the client side)");
    check(read_item(it2, &dh, ":1.9", v) == 0 && !strcmp(v, "reemplazado"), "secret replaced");
    check(read_item(it1, &plain, ":1.66", v) != 0 && !strcmp(v, "org.freedesktop.Secret.Error.NoSession"), "another client's session: NoSession");
    int nl = -1;
    check(search_count(NULL, &nl) == 2 && nl == 0, "SearchItems (service=demo)");
    check(search_count("ana", NULL) == 1, "SearchItems (user=ana)");
    check(search_count("nadie", NULL) == 0, "SearchItems with no results");
    /* GetSecrets of both */
    {
        DBuf b; dw_init(&b);
        size_t mk = dw_arr_begin(&b, 4); dw_str(&b, it1); dw_str(&b, it2); dw_str(&b, "/org/freedesktop/secrets/collection/login/nada"); dw_arr_end(&b, mk);
        dw_str(&b, dh.path);
        DMsg m;
        int r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "GetSecrets", "aoo", &b, &m);
        dw_free(&b);
        int n = 0, good = 1;
        if (r == 1) {
            DRd d; dr_init(&d, &m);
            size_t end = dr_arr(&d, 8);
            while (dr_more(&d, end)) { dr_struct(&d); dr_str(&d, NULL); char s[128]; if (get_secret_val(&d, &dh, s, sizeof s)) good = 0; n++; }
            dbus_msg_free(&m);
        }
        check(r == 1 && n == 2 && good, "GetSecrets (2 of 3, DH)");
    }
    /* SetSecret over DH */
    {
        DBuf b; dw_init(&b);
        put_secret(&b, &dh, "nuevo valor");
        DMsg m;
        int r = call(":1.9", it1, "org.freedesktop.Secret.Item", "SetSecret", "(oayays)", &b, &m);
        dw_free(&b);
        if (r >= 0) dbus_msg_free(&m);
        check(r == 1 && read_item(it1, &plain, ":1.9", v) == 0 && !strcmp(v, "nuevo valor"), "SetSecret (DH)");
    }
    /* properties */
    {
        DBuf b; dw_init(&b); dw_str(&b, "org.freedesktop.Secret.Item");
        DMsg m;
        int r = call(":1.9", it1, "org.freedesktop.DBus.Properties", "GetAll", "s", &b, &m);
        dw_free(&b);
        int found = 0;
        if (r == 1) {
            DRd d; dr_init(&d, &m);
            size_t end = dr_arr(&d, 8);
            while (dr_more(&d, end)) {
                dr_struct(&d);
                const char *k = dr_str(&d, NULL), *vs = dr_variant(&d);
                if (!strcmp(k, "Label") && !strcmp(vs, "s") && !strcmp(dr_str(&d, NULL), "Correo")) found++;
                else if (!strcmp(k, "Attributes") && !strcmp(vs, "a{ss}")) { found++; dr_skip(&d, vs); }
                else dr_skip(&d, vs);
            }
            dbus_msg_free(&m);
        }
        check(r == 1 && found == 2, "Properties.GetAll of the item");
        dw_init(&b); dw_str(&b, "org.freedesktop.Secret.Item"); dw_str(&b, "Label"); dw_variant(&b, "s"); dw_str(&b, "Correo 2");
        r = call(":1.9", it1, "org.freedesktop.DBus.Properties", "Set", "ssv", &b, &m);
        dw_free(&b);
        if (r >= 0) dbus_msg_free(&m);
        dw_init(&b); dw_str(&b, "org.freedesktop.Secret.Item"); dw_str(&b, "Label");
        r = call(":1.9", it1, "org.freedesktop.DBus.Properties", "Get", "ss", &b, &m);
        dw_free(&b);
        int ok = 0;
        if (r == 1) { DRd d; dr_init(&d, &m); dr_variant(&d); ok = !strcmp(dr_str(&d, NULL), "Correo 2"); dbus_msg_free(&m); }
        check(ok, "Properties.Set/Get Label");
        dw_init(&b); dw_str(&b, "org.freedesktop.Secret.Service"); dw_str(&b, "Collections");
        r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.DBus.Properties", "Get", "ss", &b, &m);
        dw_free(&b);
        ok = 0;
        if (r == 1) { DRd d; dr_init(&d, &m); ok = !strcmp(dr_variant(&d), "ao"); size_t e = dr_arr(&d, 4); ok = ok && dr_more(&d, e) && !strcmp(dr_str(&d, NULL), "/org/freedesktop/secrets/collection/login"); dbus_msg_free(&m); }
        check(ok, "Service.Collections");
    }
    /* alias, introspection, errors */
    {
        DBuf b; dw_init(&b); dw_str(&b, "default");
        DMsg m;
        int r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "ReadAlias", "s", &b, &m);
        dw_free(&b);
        int ok = 0;
        if (r == 1) { DRd d; dr_init(&d, &m); ok = !strcmp(dr_str(&d, NULL), "/org/freedesktop/secrets/collection/login"); dbus_msg_free(&m); }
        check(ok, "ReadAlias default");
        r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.DBus.Introspectable", "Introspect", "", NULL, &m);
        ok = 0;
        if (r == 1) { DRd d; dr_init(&d, &m); const char *x = dr_str(&d, NULL); ok = strstr(x, "OpenSession") && strstr(x, "<node name=\"collection\"/>"); dbus_msg_free(&m); }
        check(ok, "Introspect of the service");
        r = call(":1.9", "/org/freedesktop/secrets/collection/login", "org.freedesktop.DBus.Introspectable", "Introspect", "", NULL, &m);
        ok = 0;
        if (r == 1) { DRd d; dr_init(&d, &m); const char *x = dr_str(&d, NULL); ok = strstr(x, "CreateItem") && strstr(x, "<node name=\"i0001\"/>"); dbus_msg_free(&m); }
        check(ok, "Introspect of the collection with its items");
        r = call(":1.9", "/org/freedesktop/secrets/collection/login", "org.freedesktop.Secret.Collection", "Delete", "", NULL, &m);
        ok = r == 0 && !strcmp(m.error, "org.freedesktop.DBus.Error.NotSupported");
        if (r >= 0) dbus_msg_free(&m);
        check(ok, "Collection.Delete: NotSupported");
        r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "Inventado", "", NULL, &m);
        ok = r == 0 && !strcmp(m.error, "org.freedesktop.DBus.Error.UnknownMethod");
        if (r >= 0) dbus_msg_free(&m);
        check(ok, "unknown method");
        r = call(":1.9", "/no/existe", NULL, "Ping", "", NULL, &m);
        ok = r == 0;
        if (r >= 0) dbus_msg_free(&m);
        check(ok, "unknown object");
        dw_init(&b); dw_str(&b, "plain");
        r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "OpenSession", "s", &b, &m);
        dw_free(&b);
        ok = r == 0 && !strcmp(m.error, "org.freedesktop.DBus.Error.InvalidArgs");
        if (r >= 0) dbus_msg_free(&m);
        check(ok, "wrong signature: InvalidArgs");
        r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.DBus.Peer", "Ping", "", NULL, &m);
        if (r >= 0) dbus_msg_free(&m);
        check(r == 1, "Peer.Ping");
    }
    /* lock → empty search, GetSecret IsLocked → Unlock with a prompt → Completed */
    {
        DBuf b; dw_init(&b);
        size_t mk = dw_arr_begin(&b, 4); dw_str(&b, "/org/freedesktop/secrets/collection/login"); dw_arr_end(&b, mk);
        DMsg m;
        int r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "Lock", "ao", &b, &m);
        if (r >= 0) dbus_msg_free(&m);
        check(r == 1, "Lock");
        int nlk = -1;
        check(search_count(NULL, &nlk) == 0 && nlk == 2, "locked: the items go in the locked list");
        check(read_item(it1, &plain, ":1.9", v) != 0 && !strcmp(v, "org.freedesktop.Secret.Error.IsLocked"), "locked: IsLocked");
        r = call(":1.9", "/org/freedesktop/secrets", "org.freedesktop.Secret.Service", "Unlock", "ao", &b, &m);
        dw_free(&b);
        char prompt[96] = "";
        int nun = -1;
        if (r == 1) {
            DRd d; dr_init(&d, &m);
            size_t end = dr_arr(&d, 4);
            nun = 0;
            while (dr_more(&d, end)) { dr_str(&d, NULL); nun++; }
            snprintf(prompt, sizeof prompt, "%s", dr_str(&d, NULL));
            dbus_msg_free(&m);
        }
        check(r == 1 && nun == 0 && !strncmp(prompt, "/org/freedesktop/secrets/prompt/", 32), "Unlock returns a prompt");
        dw_init(&b); dw_str(&b, "");
        completed_seen = 0;
        r = call(":1.9", prompt, "org.freedesktop.Secret.Prompt", "Prompt", "s", &b, &m);
        dw_free(&b);
        if (r >= 0) dbus_msg_free(&m);
        check(r == 1, "Prompt.Prompt");
        for (int i = 0; i < 40 && !completed_seen; i++) { DMsg s; if (bus_wait(0, &s, 100) == 1) dbus_msg_free(&s); }
        check(completed_seen == 1 && completed_dismissed == 0, "Completed (not dismissed)");
        check(read_item(it1, &plain, ":1.9", v) == 0 && !strcmp(v, "nuevo valor"), "unlocked: GetSecret again");
    }
    /* delete */
    {
        DMsg m;
        int r = call(":1.9", it1, "org.freedesktop.Secret.Item", "Delete", "", NULL, &m);
        if (r >= 0) dbus_msg_free(&m);
        check(r == 1 && search_count(NULL, NULL) == 1, "Item.Delete");
        r = call(":1.9", plain.path, "org.freedesktop.Secret.Session", "Close", "", NULL, &m);
        if (r >= 0) dbus_msg_free(&m);
        check(r == 1 && read_item(it2, &plain, ":1.9", v) != 0, "Session.Close");
    }
    check(item_created_seen >= 2, "ItemCreated signals");
    free(it1); free(it2); free(it3);
    kill(pid, SIGKILL);
    waitpid(pid, NULL, 0);
    dbus_close(&bus);
}

int main(int argc, char **argv) {
    (void)argc; (void)argv;
    signal(SIGPIPE, SIG_IGN);
    t_sigs();
    t_roundtrip();
    t_reject();
    t_modexp();
    /* fuzz over our own and captured messages */
    size_t len;
    uint8_t *v = valid_msg(&len);
    int acc = fuzz_one(v, len, 100000);
    free(v);
    uint8_t **caps = NULL;
    size_t *clens = NULL;
    int ncap = t_capture("tests/secretsvc/libsecret-capture.bin", &caps, &clens);
    int acc2 = 0;
    for (int i = 0; i < ncap; i++) { acc2 += fuzz_one(caps[i], clens[i], 4000); free(caps[i]); }
    free(caps); free(clens);
    if (ncap >= 0) printf("real captures: %d messages from libsecret\n", ncap);
    else printf("real captures: tests/secretsvc/libsecret-capture.bin is missing (skipped)\n");
    printf("fuzz: 100000 + %d mutations, accepted %d + %d, no crashes\n", ncap > 0 ? ncap * 4000 : 0, acc, acc2);
    check(1, "fuzz without crashes");
    t_service_flow();
    printf("dbus-test: %d/%d\n", total - fails, total);
    return fails ? 1 : 0;
}