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.
C cdebiandesktop-environmentebpffirewalllandlocklinuxlinux-distributionopen-sourceprivacyquickjsraspberry-pi-5reactsecuritywaylandwayland-compositor
/* cbor.c — strict CBOR for CTAP2 (see cbor.h). */
#include "cbor.h"
#include <string.h>
/* ================= writer ================= */
void cbw_init(CbW *w, uint8_t *buf, size_t cap) { w->p = buf; w->n = 0; w->cap = cap; w->err = 0; }
void cbw_raw(CbW *w, const void *d, size_t n) {
if (w->err || n > w->cap - w->n) { w->err = 1; return; }
memcpy(w->p + w->n, d, n);
w->n += n;
}
static void head(CbW *w, int major, uint64_t v) {
uint8_t b[9];
size_t n;
uint8_t m = (uint8_t)(major << 5);
if (v < 24) { b[0] = m | (uint8_t)v; n = 1; }
else if (v <= 0xff) { b[0] = m | 24; b[1] = (uint8_t)v; n = 2; }
else if (v <= 0xffff) { b[0] = m | 25; b[1] = (uint8_t)(v >> 8); b[2] = (uint8_t)v; n = 3; }
else if (v <= 0xffffffffu) { b[0] = m | 26; for (int i = 0; i < 4; i++) b[1 + i] = (uint8_t)(v >> (24 - 8 * i)); n = 5; }
else { b[0] = m | 27; for (int i = 0; i < 8; i++) b[1 + i] = (uint8_t)(v >> (56 - 8 * i)); n = 9; }
cbw_raw(w, b, n);
}
void cbw_uint(CbW *w, uint64_t v) { head(w, 0, v); }
void cbw_int(CbW *w, int64_t v) { if (v >= 0) head(w, 0, (uint64_t)v); else head(w, 1, (uint64_t)(-1 - v)); }
void cbw_bytes(CbW *w, const void *d, size_t n) { head(w, 2, n); cbw_raw(w, d, n); }
void cbw_textn(CbW *w, const char *s, size_t n) { head(w, 3, n); cbw_raw(w, s, n); }
void cbw_text(CbW *w, const char *s) { cbw_textn(w, s, strlen(s)); }
void cbw_array(CbW *w, size_t n) { head(w, 4, n); }
void cbw_map(CbW *w, size_t n) { head(w, 5, n); }
void cbw_bool(CbW *w, int v) { uint8_t b = v ? 0xf5 : 0xf4; cbw_raw(w, &b, 1); }
void cbw_null(CbW *w) { uint8_t b = 0xf6; cbw_raw(w, &b, 1); }
/* ================= reader ================= */
typedef struct { const uint8_t *d; size_t len, p; CbItem *it; int n, max; } R;
static int utf8_ok(const uint8_t *s, size_t n) {
for (size_t i = 0; i < n;) {
uint8_t c = s[i];
if (c < 0x80) { i++; continue; }
size_t k;
uint32_t cp;
if (c >= 0xc2 && c <= 0xdf) { k = 1; cp = c & 0x1f; }
else if (c >= 0xe0 && c <= 0xef) { k = 2; cp = c & 0x0f; }
else if (c >= 0xf0 && c <= 0xf4) { k = 3; cp = c & 0x07; }
else return 0;
for (size_t j = 1; j <= k; j++) { if (i + j >= n || (s[i + j] & 0xc0) != 0x80) return 0; cp = cp << 6 | (s[i + j] & 0x3f); }
if ((k == 2 && cp < 0x800) || (k == 3 && (cp < 0x10000 || cp > 0x10ffff)) || (cp >= 0xd800 && cp < 0xe000)) return 0;
i += k + 1;
}
return 1;
}
static int item(R *r, int depth) {
if (depth > 16 || r->n >= r->max || r->p >= r->len) return -1;
uint8_t ib = r->d[r->p++];
int major = ib >> 5, ai = ib & 31;
uint64_t v;
if (ai < 24) v = (uint64_t)ai;
else if (ai <= 27) {
size_t k = (size_t)1 << (ai - 24);
if (k > r->len - r->p) return -1;
v = 0;
for (size_t i = 0; i < k; i++) v = v << 8 | r->d[r->p + i];
r->p += k;
/* minimal (canonical) encoding: if it fit in fewer bytes, it is invalid */
if ((ai == 24 && v < 24) || (ai == 25 && v <= 0xff) || (ai == 26 && v <= 0xffff) || (ai == 27 && v <= 0xffffffffu)) return -1;
} else return -1; /* 28-30 reserved, 31 indefinite */
int k = r->n++;
CbItem *it = &r->it[k];
memset(it, 0, sizeof *it);
switch (major) {
case 0: it->type = CB_UINT; it->v = v; break;
case 1: it->type = CB_NINT; it->v = v; break;
case 2: case 3:
if (v > r->len - r->p) return -1;
it->type = major == 2 ? CB_BYTES : CB_TEXT;
it->ptr = r->d + r->p;
it->len = (size_t)v;
r->p += (size_t)v;
if (major == 3 && !utf8_ok(it->ptr, it->len)) return -1;
break;
case 4: case 5: {
it->type = major == 4 ? CB_ARRAY : CB_MAP;
it->v = v;
uint64_t sub = major == 4 ? v : v * 2;
if (v > (uint64_t)r->max || sub > r->len - r->p) return -1; /* each item takes >= 1 byte */
for (uint64_t i = 0; i < sub; i++) if (item(r, depth + 1)) return -1;
break;
}
case 6: return -1; /* tags: not in CTAP2 */
default:
if (ai >= 24) return -1; /* floats and 1-byte simple values */
if (v == 20) it->type = CB_FALSE;
else if (v == 21) it->type = CB_TRUE;
else if (v == 22) it->type = CB_NULL;
else if (v == 23) it->type = CB_UNDEF;
else return -1;
}
r->it[k].next = r->n;
return 0;
}
int cb_parse(Cb *c, const uint8_t *d, size_t len, CbItem *items, int max, int allow_trailing) {
R r = { d, len, 0, items, 0, max };
c->it = items;
c->n = 0;
c->used = 0;
if (item(&r, 0)) return -1;
if (!allow_trailing && r.p != len) return -1;
c->n = r.n;
c->used = r.p;
return 0;
}
int cb_type(const Cb *c, int i) { return i >= 0 && i < c->n ? c->it[i].type : 0; }
int cb_int(const Cb *c, int i, int64_t *out) {
int t = cb_type(c, i);
if (t == CB_UINT && c->it[i].v <= (uint64_t)INT64_MAX) { *out = (int64_t)c->it[i].v; return 0; }
if (t == CB_NINT && c->it[i].v <= (uint64_t)INT64_MAX) { *out = -1 - (int64_t)c->it[i].v; return 0; }
return -1;
}
int cb_text_eq(const Cb *c, int i, const char *s) {
if (cb_type(c, i) != CB_TEXT) return 0;
size_t n = strlen(s);
return c->it[i].len == n && !memcmp(c->it[i].ptr, s, n);
}
int cb_map_int(const Cb *c, int map, int64_t key) {
if (cb_type(c, map) != CB_MAP) return -1;
int k = map + 1;
for (uint64_t i = 0; i < c->it[map].v; i++) {
int64_t v;
if (cb_int(c, k, &v) == 0 && v == key) return k + 1;
k = c->it[k + 1].next;
}
return -1;
}
int cb_map_text(const Cb *c, int map, const char *key) {
if (cb_type(c, map) != CB_MAP) return -1;
int k = map + 1;
for (uint64_t i = 0; i < c->it[map].v; i++) {
if (cb_text_eq(c, k, key)) return k + 1;
k = c->it[k + 1].next;
}
return -1;
}
int cb_at(const Cb *c, int arr, int k) {
if (cb_type(c, arr) != CB_ARRAY || k < 0 || (uint64_t)k >= c->it[arr].v) return -1;
int i = arr + 1;
while (k-- > 0) i = c->it[i].next;
return i;
}