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
/* pgp.c — OpenPGP v4 keyrings and signatures to verify repositories (see pgp.h).
*
* The keyring is taken as trusted (it's a root file installed by the debian-archive-keyring
* package, just as gpgv does): from it we read the keys, their subkeys, what they're for
* (key flags), when they expire and whether they're revoked, according to the signatures the
* key itself made over itself. What arrives from the network (InRelease) is verified: a v4
* signature over the canonical text, the key has to exist, be able to sign, not be revoked or
* expired, and the signature can't be expired or come from the future. */
#include "pgp.h"
#include "../errcode.h"
#include "crypto.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ---- SHA-1 (only for v4 fingerprints) ---- */
static void sha1(const uint8_t *const parts[], const size_t lens[], int nparts, uint8_t out[20]) {
uint32_t h[5] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
uint8_t blk[64];
size_t bl = 0;
uint64_t total = 0;
for (int pass = 0; pass <= nparts; pass++) {
const uint8_t *p;
size_t n;
uint8_t pad[72];
if (pass < nparts) { p = parts[pass]; n = lens[pass]; total += n; }
else {
size_t padlen = (bl < 56 ? 56 : 120) - bl;
memset(pad, 0, sizeof pad);
pad[0] = 0x80;
uint64_t bits = total * 8;
for (int i = 0; i < 8; i++) pad[padlen + i] = (uint8_t)(bits >> (56 - 8 * i));
p = pad;
n = padlen + 8;
}
for (size_t i = 0; i < n; i++) {
blk[bl++] = p[i];
if (bl < 64) continue;
bl = 0;
uint32_t w[80];
for (int t = 0; t < 16; t++) w[t] = (uint32_t)blk[4 * t] << 24 | (uint32_t)blk[4 * t + 1] << 16 | (uint32_t)blk[4 * t + 2] << 8 | blk[4 * t + 3];
for (int t = 16; t < 80; t++) { uint32_t x = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]; w[t] = x << 1 | x >> 31; }
uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
for (int t = 0; t < 80; t++) {
uint32_t f, k;
if (t < 20) { f = (b & c) | (~b & d); k = 0x5A827999; }
else if (t < 40) { f = b ^ c ^ d; k = 0x6ED9EBA1; }
else if (t < 60) { f = (b & c) | (b & d) | (c & d); k = 0x8F1BBCDC; }
else { f = b ^ c ^ d; k = 0xCA62C1D6; }
uint32_t tmp = (a << 5 | a >> 27) + f + e + k + w[t];
e = d; d = c; c = b << 30 | b >> 2; b = a; a = tmp;
}
h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e;
}
}
for (int i = 0; i < 5; i++) for (int j = 0; j < 4; j++) out[4 * i + j] = (uint8_t)(h[i] >> (24 - 8 * j));
}
/* ---- packets ---- */
typedef struct { int tag; const uint8_t *body; size_t len; } Pkt;
static int next_packet(const uint8_t *d, size_t len, size_t *pos, Pkt *p) {
size_t i = *pos;
if (i >= len) return 0;
uint8_t h = d[i++];
if (!(h & 0x80)) return -1;
size_t l;
if (h & 0x40) {
p->tag = h & 0x3f;
if (i >= len) return -1;
uint8_t a = d[i++];
if (a < 192) l = a;
else if (a < 224) { if (i >= len) return -1; l = ((size_t)(a - 192) << 8) + d[i++] + 192; }
else if (a == 255) { if (i + 4 > len) return -1; l = (size_t)d[i] << 24 | (size_t)d[i + 1] << 16 | (size_t)d[i + 2] << 8 | d[i + 3]; i += 4; }
else return -1; /* partial length: not used in keys or signatures */
} else {
p->tag = (h >> 2) & 0xf;
int lt = h & 3;
if (lt == 3) return -1;
size_t nb = lt == 0 ? 1 : lt == 1 ? 2 : 4;
if (i + nb > len) return -1;
l = 0;
for (size_t k = 0; k < nb; k++) l = l << 8 | d[i + k];
i += nb;
}
if (l > len - i) return -1;
p->body = d + i;
p->len = l;
*pos = i + l;
return 1;
}
/* MPI: 2 bytes of bit count + the bytes. */
static int read_mpi(const uint8_t **p, const uint8_t *end, const uint8_t **v, size_t *vlen) {
if (end - *p < 2) return -1;
size_t bits = (size_t)(*p)[0] << 8 | (*p)[1];
size_t n = (bits + 7) / 8;
if ((size_t)(end - *p - 2) < n) return -1;
*v = *p + 2;
*vlen = n;
*p += 2 + n;
return 0;
}
typedef struct {
int type, pubalg, hashalg;
const uint8_t *head; /* version … hashed subpackets */
size_t headlen;
uint8_t left16[2];
const uint8_t *mpi, *end;
int64_t created, sig_expires, key_expires;
int key_flags, has_created;
uint8_t issuer_fpr[20], issuer_id[8];
int has_fpr, has_id;
} Sig;
static void parse_subpackets(Sig *s, const uint8_t *p, const uint8_t *end, int hashed) {
while (p < end) {
size_t l;
if (*p < 192) l = *p++;
else if (*p < 255) { if (end - p < 2) return; l = ((size_t)(p[0] - 192) << 8) + p[1] + 192; p += 2; }
else { if (end - p < 5) return; l = (size_t)p[1] << 24 | (size_t)p[2] << 16 | (size_t)p[3] << 8 | p[4]; p += 5; }
if (!l || (size_t)(end - p) < l) return;
int type = p[0] & 0x7f;
const uint8_t *v = p + 1;
size_t vl = l - 1;
uint32_t u32 = vl >= 4 ? (uint32_t)v[0] << 24 | (uint32_t)v[1] << 16 | (uint32_t)v[2] << 8 | v[3] : 0;
if (hashed) { /* what matters for security, only from the hashed area */
if (type == 2 && vl >= 4) { s->created = u32; s->has_created = 1; }
else if (type == 3 && vl >= 4) s->sig_expires = u32;
else if (type == 9 && vl >= 4) s->key_expires = u32;
else if (type == 27 && vl >= 1) s->key_flags = v[0];
}
if (type == 33 && vl == 21 && v[0] == 4) { memcpy(s->issuer_fpr, v + 1, 20); s->has_fpr = 1; }
else if (type == 16 && vl == 8) { memcpy(s->issuer_id, v, 8); s->has_id = 1; }
p += l;
}
}
static int parse_sig(const uint8_t *b, size_t len, Sig *s) {
memset(s, 0, sizeof *s);
s->key_flags = -1;
if (len < 6 || b[0] != 4) return -1;
s->type = b[1];
s->pubalg = b[2];
s->hashalg = b[3];
size_t hl = (size_t)b[4] << 8 | b[5];
if (6 + hl + 2 > len) return -1;
s->head = b;
s->headlen = 6 + hl;
parse_subpackets(s, b + 6, b + 6 + hl, 1);
size_t ul = (size_t)b[6 + hl] << 8 | b[7 + hl];
const uint8_t *u = b + 8 + hl;
if ((size_t)(b + len - u) < ul + 2) return -1;
parse_subpackets(s, u, u + ul, 0);
s->left16[0] = u[ul];
s->left16[1] = u[ul + 1];
s->mpi = u + ul + 2;
s->end = b + len;
return 0;
}
static int issued_by(const Sig *s, const PgpKey *k) {
if (s->has_fpr) return !memcmp(s->issuer_fpr, k->fpr, 20);
if (s->has_id) return !memcmp(s->issuer_id, k->fpr + 12, 8);
return 0;
}
/* ---- keyring ---- */
static int parse_key(const uint8_t *b, size_t len, PgpKey *k) {
memset(k, 0, sizeof *k);
if (len < 6 || b[0] != 4) return -1;
k->created = (int64_t)((uint32_t)b[1] << 24 | (uint32_t)b[2] << 16 | (uint32_t)b[3] << 8 | b[4]);
k->alg = b[5];
const uint8_t *p = b + 6, *end = b + len;
uint8_t hdr[3] = { 0x99, (uint8_t)(len >> 8), (uint8_t)len };
const uint8_t *parts[2] = { hdr, b };
size_t lens[2] = { 3, len };
sha1(parts, lens, 2, k->fpr);
if (k->alg == 1 || k->alg == 3) {
k->alg = PGP_RSA;
if (read_mpi(&p, end, &k->n, &k->nlen) || read_mpi(&p, end, &k->e, &k->elen)) return -1;
return 0;
}
if (k->alg == PGP_EDDSA) {
static const uint8_t oid[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0xDA, 0x47, 0x0F, 0x01 };
if (end - p < 1 || p[0] != sizeof oid || end - p < 1 + (long)sizeof oid || memcmp(p + 1, oid, sizeof oid)) return -1;
p += 1 + sizeof oid;
const uint8_t *v;
size_t vl;
if (read_mpi(&p, end, &v, &vl) || vl != 33 || v[0] != 0x40) return -1;
memcpy(k->ed, v + 1, 32);
return 0;
}
return 1; /* another algorithm: ignored */
}
static long dearmor(const char *in, size_t len, uint8_t **out);
long pgp_dearmor(const char *in, size_t len, uint8_t **out) {
return len >= 5 && !memcmp(in, "-----", 5) ? dearmor(in, len, out) : -1;
}
int pgp_keyring_add_mem(PgpKeyring *kr, const char *data, size_t len) {
uint8_t *buf;
long n;
if (len >= 5 && !memcmp(data, "-----", 5)) {
n = dearmor(data, len, &buf);
if (n < 0) return -1;
} else {
buf = malloc(len ? len : 1);
if (!buf) return -1;
memcpy(buf, data, len);
n = (long)len;
}
uint8_t **nb = realloc(kr->bufs, sizeof *nb * (size_t)(kr->nbufs + 1));
if (!nb) { free(buf); return -1; }
kr->bufs = nb;
kr->bufs[kr->nbufs++] = buf;
size_t pos = 0;
Pkt p;
int primary = -1, cur = -1, r;
int64_t best_self = -1, best_bind = -1;
while ((r = next_packet(buf, (size_t)n, &pos, &p)) > 0) {
if (p.tag == 6 || p.tag == 14) {
PgpKey k;
if (p.tag == 6) primary = -1;
cur = -1;
if (p.tag == 14 && primary < 0) continue; /* subkey without a valid primary */
if (parse_key(p.body, p.len, &k)) continue;
k.primary = p.tag == 6;
k.can_sign = 1;
if (kr->n == kr->cap) {
int cap = kr->cap ? kr->cap * 2 : 32;
PgpKey *nk = realloc(kr->keys, sizeof *nk * (size_t)cap);
if (!nk) return -1;
kr->keys = nk;
kr->cap = cap;
}
kr->keys[kr->n] = k;
cur = kr->n++;
if (p.tag == 6) { primary = cur; best_self = -1; }
else best_bind = -1;
} else if (p.tag == 2 && cur >= 0 && primary >= 0) {
Sig s;
if (parse_sig(p.body, p.len, &s) || !issued_by(&s, &kr->keys[primary])) continue;
PgpKey *k = &kr->keys[cur];
if (cur == primary) {
if (s.type == 0x20) k->revoked = 1;
else if ((s.type >= 0x10 && s.type <= 0x13) || s.type == 0x1f) {
if (s.created < best_self) continue;
best_self = s.created;
k->expires = s.key_expires ? k->created + s.key_expires : 0;
if (s.key_flags >= 0) k->can_sign = (s.key_flags & 0x02) != 0;
}
} else {
if (s.type == 0x28) k->revoked = 1;
else if (s.type == 0x18) {
if (s.created < best_bind) continue;
best_bind = s.created;
k->expires = s.key_expires ? k->created + s.key_expires : 0;
k->can_sign = s.key_flags >= 0 ? (s.key_flags & 0x02) != 0 : 1;
}
}
}
/* subkeys inherit their primary's revocation */
if (primary >= 0 && kr->keys[primary].revoked)
for (int i = primary; i < kr->n; i++) kr->keys[i].revoked = 1;
}
return r < 0 ? -1 : 0;
}
int pgp_keyring_add_file(PgpKeyring *kr, const char *path) {
FILE *f = fopen(path, "rb");
if (!f) return -1;
char *buf = NULL;
size_t len = 0, cap = 0;
for (;;) {
if (len == cap) {
cap = cap ? cap * 2 : 65536;
if (cap > (16u << 20)) { free(buf); fclose(f); return -1; }
char *nb = realloc(buf, cap);
if (!nb) { free(buf); fclose(f); return -1; }
buf = nb;
}
size_t r = fread(buf + len, 1, cap - len, f);
if (!r) break;
len += r;
}
fclose(f);
int r = pgp_keyring_add_mem(kr, buf, len);
free(buf);
return r;
}
void pgp_keyring_free(PgpKeyring *kr) {
for (int i = 0; i < kr->nbufs; i++) free(kr->bufs[i]);
free(kr->bufs);
free(kr->keys);
memset(kr, 0, sizeof *kr);
}
/* ---- armor ---- */
long pgp_base64_decode(const char *in, size_t len, uint8_t *out, size_t cap) {
uint32_t acc = 0;
int bits = 0;
size_t o = 0;
for (size_t i = 0; i < len; i++) {
char c = in[i];
int v;
if (c >= 'A' && c <= 'Z') v = c - 'A';
else if (c >= 'a' && c <= 'z') v = c - 'a' + 26;
else if (c >= '0' && c <= '9') v = c - '0' + 52;
else if (c == '+') v = 62;
else if (c == '/') v = 63;
else if (c == '=') break;
else if (c == '\n' || c == '\r' || c == ' ' || c == '\t') continue;
else return -1;
acc = acc << 6 | (uint32_t)v;
bits += 6;
if (bits >= 8) {
bits -= 8;
if (o >= cap) return -1;
out[o++] = (uint8_t)(acc >> bits);
}
}
return (long)o;
}
static uint32_t crc24(const uint8_t *p, size_t n) {
uint32_t crc = 0xB704CE;
for (size_t i = 0; i < n; i++) {
crc ^= (uint32_t)p[i] << 16;
for (int j = 0; j < 8; j++) { crc <<= 1; if (crc & 0x1000000) crc ^= 0x1864CFB; }
}
return crc & 0xFFFFFF;
}
/* From "-----BEGIN ...-----" to "-----END": headers, empty line, base64 and "=CRC". */
static long dearmor(const char *in, size_t len, uint8_t **out) {
const char *end = in + len, *p = memchr(in, '\n', len);
if (!p) return -1;
p++;
/* "Key: value" headers up to an empty line (there may be none) */
const char *q = p;
int saw_header = 0;
while (q < end) {
const char *nl = memchr(q, '\n', (size_t)(end - q));
if (!nl) return -1;
size_t l = (size_t)(nl - q);
if (l && q[l - 1] == '\r') l--;
if (!l) { p = nl + 1; break; }
if (!memchr(q, ':', l)) { if (!saw_header) break; return -1; }
saw_header = 1;
q = nl + 1;
}
const char *b64 = p, *b64end = p, *crc = NULL;
while (p < end) {
const char *nl = memchr(p, '\n', (size_t)(end - p));
if (!nl) nl = end;
if (!strncmp(p, "-----END ", 9)) break;
if (*p == '=') crc = p + 1;
else b64end = nl;
p = nl < end ? nl + 1 : end;
}
size_t cap = (size_t)(b64end - b64) * 3 / 4 + 4;
*out = malloc(cap);
if (!*out) return -1;
long n = pgp_base64_decode(b64, (size_t)(b64end - b64), *out, cap);
if (n >= 0 && crc) {
uint8_t c[3];
if (pgp_base64_decode(crc, 4, c, 3) != 3 || crc24(*out, (size_t)n) != ((uint32_t)c[0] << 16 | (uint32_t)c[1] << 8 | c[2])) n = -1;
}
if (n < 0) { free(*out); *out = NULL; }
return n;
}
/* ---- verification ---- */
static int verify_sig(const PgpKey *k, const Sig *s, const uint8_t *digest) {
const uint8_t *p = s->mpi;
if (k->alg == PGP_RSA && s->pubalg == 1) {
const uint8_t *v;
size_t vl;
if (read_mpi(&p, s->end, &v, &vl)) return 0;
return rsa_verify(k->n, k->nlen, k->e, k->elen, v, vl, s->hashalg, digest);
}
if (k->alg == PGP_EDDSA && s->pubalg == PGP_EDDSA) {
const uint8_t *r, *sv;
size_t rl, sl;
if (read_mpi(&p, s->end, &r, &rl) || read_mpi(&p, s->end, &sv, &sl) || rl > 32 || sl > 32) return 0;
uint8_t sig[64] = { 0 };
memcpy(sig + 32 - rl, r, rl);
memcpy(sig + 64 - sl, sv, sl);
return ed25519_verify(k->ed, sig, digest, s->hashalg == HASH_SHA256 ? 32 : 64);
}
return 0;
}
static void hex_fpr(const uint8_t *f, char out[41]) { hex_encode(f, 20, out); }
int pgp_verify_clearsigned(const PgpKeyring *kr, const char *msg, size_t len, int64_t now,
char **body, size_t *body_len, char *err, size_t errlen) {
static const char head[] = "-----BEGIN PGP SIGNED MESSAGE-----";
static const char sighead[] = "-----BEGIN PGP SIGNATURE-----";
*body = NULL;
*body_len = 0;
err[0] = 0;
const char *end = msg + len, *p = msg;
if (len < sizeof head || memcmp(msg, head, sizeof head - 1) || (msg[sizeof head - 1] != '\n' && msg[sizeof head - 1] != '\r')) {
lerr_set(err, errlen, "pkg.pgp.notClearsigned", NULL);
return -1;
}
p = memchr(msg, '\n', len) + 1;
/* Hash: headers up to the empty line */
for (;;) {
const char *nl = memchr(p, '\n', (size_t)(end - p));
if (!nl) { lerr_set(err, errlen, "pkg.pgp.incomplete", NULL); return -1; }
size_t l = (size_t)(nl - p);
if (l && p[l - 1] == '\r') l--;
p = nl + 1;
if (!l) break;
}
/* text: up to the signature's armor */
char *text = malloc((size_t)(end - p) + 2), *canon = malloc((size_t)(end - p) * 2 + 2);
if (!text || !canon) { free(text); free(canon); lerr_set(err, errlen, "sys.outOfMemory", NULL); return -1; }
size_t tl = 0, cl = 0;
const char *sig = NULL;
int first = 1;
while (p < end) {
const char *nl = memchr(p, '\n', (size_t)(end - p));
const char *le = nl ? nl : end;
size_t l = (size_t)(le - p);
if (l >= sizeof sighead - 1 && !memcmp(p, sighead, sizeof sighead - 1)) { sig = p; break; }
const char *s = p;
if (l >= 2 && s[0] == '-' && s[1] == ' ') { s += 2; l -= 2; }
else if (l && s[0] == '-') { free(text); free(canon); lerr_set(err, errlen, "pkg.pgp.unescapedDash", NULL); return -1; }
while (l && (s[l - 1] == ' ' || s[l - 1] == '\t' || s[l - 1] == '\r')) l--;
if (!first) { canon[cl++] = '\r'; canon[cl++] = '\n'; }
first = 0;
memcpy(canon + cl, s, l); cl += l;
memcpy(text + tl, s, l); tl += l;
text[tl++] = '\n';
if (!nl) break;
p = nl + 1;
}
if (!sig) { free(text); free(canon); lerr_set(err, errlen, "pkg.pgp.noSignature", NULL); return -1; }
/* signature armor; after END there can only be whitespace */
const char *endmark = NULL;
for (const char *q = sig; q + 27 <= end; q++)
if (!memcmp(q, "-----END PGP SIGNATURE-----", 27)) { endmark = q + 27; break; }
if (!endmark) { free(text); free(canon); lerr_set(err, errlen, "pkg.pgp.signatureIncomplete", NULL); return -1; }
for (const char *q = endmark; q < end; q++)
if (*q != '\n' && *q != '\r' && *q != ' ' && *q != '\t') { free(text); free(canon); lerr_set(err, errlen, "pkg.pgp.trailingData", NULL); return -1; }
uint8_t *raw;
long rawlen = dearmor(sig, (size_t)(endmark - sig), &raw);
if (rawlen < 0) { free(text); free(canon); lerr_set(err, errlen, "pkg.pgp.badEncoding", NULL); return -1; }
int good = 0, bad = 0, unknown = 0;
size_t pos = 0;
Pkt pk;
int r;
char why[160] = "";
while ((r = next_packet(raw, (size_t)rawlen, &pos, &pk)) > 0) {
if (pk.tag != 2) continue;
Sig s;
if (parse_sig(pk.body, pk.len, &s) || (s.type != 0x01 && s.type != 0x00) ||
(s.hashalg != HASH_SHA256 && s.hashalg != HASH_SHA512) || !s.has_created) { unknown++; continue; }
const PgpKey *k = NULL;
for (int i = 0; i < kr->n && !k; i++) if (issued_by(&s, &kr->keys[i])) k = &kr->keys[i];
if (!k) { unknown++; continue; }
char fpr[41];
hex_fpr(k->fpr, fpr);
if (k->revoked) { lerr_set(why, sizeof why, "pkg.pgp.keyRevoked", "key", fpr, NULL); continue; }
if (k->expires && k->expires <= now) { lerr_set(why, sizeof why, "pkg.pgp.keyExpired", "key", fpr, NULL); continue; }
if (!k->can_sign) { lerr_set(why, sizeof why, "pkg.pgp.keyNotSigning", "key", fpr, NULL); continue; }
if (s.created > now + 86400) { lerr_set(why, sizeof why, "pkg.pgp.futureSignature", "key", fpr, NULL); continue; }
if (s.sig_expires && s.created + s.sig_expires <= now) { lerr_set(why, sizeof why, "pkg.pgp.signatureExpired", "key", fpr, NULL); continue; }
if (s.created < k->created) { bad++; continue; }
/* hash: text (canonical if it's a text signature) + signature header + v4 trailer */
uint8_t dig[64], trailer[6] = { 4, 0xff, (uint8_t)(s.headlen >> 24), (uint8_t)(s.headlen >> 16), (uint8_t)(s.headlen >> 8), (uint8_t)s.headlen };
const char *data = s.type == 0x01 ? canon : text;
size_t dlen = s.type == 0x01 ? cl : tl;
if (s.hashalg == HASH_SHA256) {
Sha256 h;
sha256_init(&h);
sha256_update(&h, data, dlen);
sha256_update(&h, s.head, s.headlen);
sha256_update(&h, trailer, 6);
sha256_final(&h, dig);
} else {
Sha512 h;
sha512_init(&h);
sha512_update(&h, data, dlen);
sha512_update(&h, s.head, s.headlen);
sha512_update(&h, trailer, 6);
sha512_final(&h, dig);
}
if (dig[0] != s.left16[0] || dig[1] != s.left16[1] || !verify_sig(k, &s, dig)) {
bad++;
lerr_set(why, sizeof why, "pkg.pgp.badSignature", "key", fpr, NULL);
continue;
}
good++;
}
free(raw);
free(canon);
if (r < 0) { free(text); lerr_set(err, errlen, "pkg.pgp.malformed", NULL); return -1; }
if (bad) { free(text); snprintf(err, errlen, "%s", why); return -1; }
if (!good) {
free(text);
if (why[0]) snprintf(err, errlen, "%s", why);
else lerr_set(err, errlen, "pkg.pgp.unknownKeys", "count", lerr_int(unknown), NULL);
return 0;
}
*body = text;
*body_len = tl;
return good;
}