#include "../preferred-routers/preferred_router.h" /* ========================================================================== * http3_envelope.c -- implementation of the HTTP 3.0 compact envelope (§5) * and response model (§7). Pure data: no I/O, no crypto, no allocation. * ========================================================================== */ #include "http3_envelope.h" #include "http3_mac.h" #include "http3_basket.h" #include "http3_port.h" #include #include /* Canonical serialized header size the DIGEST is computed over (big-endian, * fixed-width fields; excludes the DIGEST itself, includes the NONCE). The * basket block and payload are appended after this header when MACing. */ #define ENV_DIGEST_HDR 58u /* Big-endian field writers (defined fully in the binary-wire section below). */ static void put_u32(uint8_t *b, uint32_t v); static void put_u64(uint8_t *b, uint64_t v); /* ---- Per-packet DIGEST (keyed MAC: SipHash-2-4 over header + payload) ------ * The DIGEST is a KEYED message authentication code, not a plain hash: it * resists deliberate forgery, because an attacker who rewrites a packet cannot * recompute a matching tag without the per-connection key. The MAC message is a * canonical, endianness-independent serialization (each header field big-endian * and fixed width, excluding the DIGEST) followed by the raw payload, so the * textual and binary wire forms of the same logical envelope share a tag and * the Python reference reproduces it byte-for-byte. */ uint64_t http3_envelope_compute_digest(const http3_envelope_t *env, const uint8_t key[HTTP3_MAC_KEY_BYTES]) { if (!sleela_preferred_router_packet_policy("HTTP/3.0", 4)) return 0; uint8_t msg[ENV_DIGEST_HDR + HTTP3_BASKET_BLOCK_SIZE + HTTP3_ENVELOPE_MAX_PAYLOAD]; uint8_t logical_flags; size_t pos; if (env == NULL || key == NULL || env->payload_len > HTTP3_ENVELOPE_MAX_PAYLOAD) { return 0; } /* HTTP3_FLAG_BINARY is a transport-form marker set only on the binary wire; * exclude it so the tag is identical for the textual and binary forms. */ logical_flags = (uint8_t)(env->flags & ~(uint8_t)HTTP3_FLAG_BINARY); msg[0] = env->version; msg[1] = logical_flags; put_u32(msg + 2, env->service_id); put_u32(msg + 6, env->op_id); put_u64(msg + 10, env->request_id); /* NONCE is inside the MAC so it cannot be altered without detection; the * receiver's high-water-mark check then defeats replay. */ memcpy(msg + 18, env->port.bytes, HTTP3_PORT_BYTES); put_u64(msg + 38, env->nonce); put_u64(msg + 46, env->intactx); /* payload length as a fixed 32-bit big-endian field (payloads are capped at * HTTP3_ENVELOPE_MAX_PAYLOAD, well within 32 bits). */ put_u32(msg + 54, (uint32_t)env->payload_len); pos = ENV_DIGEST_HDR; /* BASKET travels on every packet and is covered by the MAC. */ memcpy(msg + pos, env->basket, HTTP3_BASKET_BLOCK_SIZE); pos += HTTP3_BASKET_BLOCK_SIZE; if (env->payload_len > 0U) { memcpy(msg + pos, env->payload, env->payload_len); } pos += env->payload_len; return http3_mac_siphash24(key, msg, pos); } int http3_envelope_verify_digest(const http3_envelope_t *env, const uint8_t key[HTTP3_MAC_KEY_BYTES]) { if (env == NULL || key == NULL) { return 0; } return http3_envelope_compute_digest(env, key) == env->digest ? 1 : 0; } int http3_envelope_set_port_decimal(http3_envelope_t *env, const char *decimal, const uint8_t key[HTTP3_MAC_KEY_BYTES]) { if (!env || !key || http3_port_from_decimal(&env->port, decimal) != 0) return -1; env->digest = http3_envelope_compute_digest(env, key); return 0; } int http3_envelope_set_port_u64(http3_envelope_t *env, uint64_t port, const uint8_t key[HTTP3_MAC_KEY_BYTES]) { if (!env || !key) return -1; http3_port_from_u64(&env->port, port); env->digest = http3_envelope_compute_digest(env, key); return 0; } int http3_envelope_init(http3_envelope_t *env, uint32_t service_id, uint32_t op_id, uint64_t request_id, uint8_t flags, uint64_t nonce, uint64_t intactx, const uint8_t key[HTTP3_MAC_KEY_BYTES], const uint8_t *payload, size_t payload_len) { if (env == NULL || key == NULL || payload_len > HTTP3_ENVELOPE_MAX_PAYLOAD) { return -1; } memset(env, 0, sizeof(*env)); env->version = HTTP3_ENVELOPE_VERSION; env->flags = flags; env->service_id = service_id; env->op_id = op_id; env->request_id = request_id; http3_port_zero(&env->port); env->nonce = nonce; env->intactx = intactx; /* The fixed basket of goods & services rides on every packet. */ (void)http3_basket_serialize(env->basket, sizeof(env->basket)); if (payload != NULL && payload_len > 0U) { memcpy(env->payload, payload, payload_len); } env->payload_len = payload_len; /* Seal the packet with its keyed MAC over the finished contents. */ env->digest = http3_envelope_compute_digest(env, key); return 0; } /* ---- Textual envelope ----------------------------------------------------- */ static const char k_hex[] = "0123456789abcdef"; static void hex_encode(const uint8_t *in, size_t len, char *out) { size_t i; for (i = 0; i < len; ++i) { out[2 * i] = k_hex[(in[i] >> 4) & 0xF]; out[2 * i + 1] = k_hex[in[i] & 0xF]; } } static int hex_val(char c) { if (c >= '0' && c <= '9') return c - '0'; if (c >= 'a' && c <= 'f') return c - 'a' + 10; if (c >= 'A' && c <= 'F') return c - 'A' + 10; return -1; } static int hex_decode(const char *in, size_t hexlen, uint8_t *out, size_t out_cap) { size_t i; if (hexlen % 2u != 0u || hexlen / 2u > out_cap) { return -1; } for (i = 0; i < hexlen / 2u; ++i) { int hi = hex_val(in[2 * i]); int lo = hex_val(in[2 * i + 1]); if (hi < 0 || lo < 0) { return -1; } out[i] = (uint8_t)((hi << 4) | lo); } return 0; } int http3_envelope_pack_text(const http3_envelope_t *env, char *out, size_t out_cap, size_t *written) { int n; size_t pos; char basket_hex[2 * HTTP3_BASKET_BLOCK_SIZE + 1]; if (env == NULL || out == NULL || env->payload_len > HTTP3_ENVELOPE_MAX_PAYLOAD) { return -1; } hex_encode(env->basket, HTTP3_BASKET_BLOCK_SIZE, basket_hex); basket_hex[2 * HTTP3_BASKET_BLOCK_SIZE] = '\0'; { char port_text[49]; if (http3_port_to_decimal(&env->port, port_text, sizeof(port_text)) != 0) return -1; n = snprintf(out, out_cap, "H3 %u %u %u %u %llu %s %llu %llu %llu %s %zu:", (unsigned)env->version, (unsigned)env->flags, (unsigned)env->service_id, (unsigned)env->op_id, (unsigned long long)env->request_id, port_text, (unsigned long long)env->nonce, (unsigned long long)env->digest, (unsigned long long)env->intactx, basket_hex, env->payload_len); } if (n < 0 || (size_t)n >= out_cap) { return -1; } pos = (size_t)n; if (pos + env->payload_len + 1U > out_cap) { /* +1 for trailing newline */ return -1; } memcpy(out + pos, env->payload, env->payload_len); pos += env->payload_len; out[pos++] = '\n'; if (written != NULL) { *written = pos; } return 0; } int http3_envelope_unpack_text(const char *in, size_t in_len, http3_envelope_t *env) { unsigned version, flags, service_id, op_id; unsigned long long request_id, nonce, digest, intactx; char port_text[49]; unsigned long payload_len; int consumed = 0; char basket_hex[2 * HTTP3_BASKET_BLOCK_SIZE + 1]; const char *p; (void)in_len; if (in == NULL || env == NULL) { return -1; } /* Parse the fixed prefix, the fixed-width basket-hex token, then the ':' * after payload_len. The %Ns width guards the basket_hex buffer. */ { char fmt[96]; (void)snprintf(fmt, sizeof(fmt), "H3 %%u %%u %%u %%u %%llu %%%us %%llu %%llu %%llu %%%us %%lu:%%n", (unsigned)48u, (unsigned)(2 * HTTP3_BASKET_BLOCK_SIZE)); if (sscanf(in, fmt, &version, &flags, &service_id, &op_id, &request_id, port_text, &nonce, &digest, &intactx, basket_hex, &payload_len, &consumed) != 11 || consumed <= 0) { return -1; } } if (payload_len > HTTP3_ENVELOPE_MAX_PAYLOAD) { return -1; } p = in + consumed; memset(env, 0, sizeof(*env)); env->version = (uint8_t)version; env->flags = (uint8_t)flags; env->service_id = (uint32_t)service_id; env->op_id = (uint32_t)op_id; env->request_id = (uint64_t)request_id; if (http3_port_from_decimal(&env->port, port_text) != 0) return -1; env->nonce = (uint64_t)nonce; env->digest = (uint64_t)digest; env->intactx = (uint64_t)intactx; if (hex_decode(basket_hex, strlen(basket_hex), env->basket, sizeof(env->basket)) != 0) { return -1; } env->payload_len = (size_t)payload_len; if (payload_len > 0U) { memcpy(env->payload, p, payload_len); } return 0; } /* ---- Binary envelope (big-endian header) ---------------------------------- */ static void put_u32(uint8_t *b, uint32_t v) { b[0] = (uint8_t)(v >> 24); b[1] = (uint8_t)(v >> 16); b[2] = (uint8_t)(v >> 8); b[3] = (uint8_t)v; } static void put_u64(uint8_t *b, uint64_t v) { b[0] = (uint8_t)(v >> 56); b[1] = (uint8_t)(v >> 48); b[2] = (uint8_t)(v >> 40); b[3] = (uint8_t)(v >> 32); b[4] = (uint8_t)(v >> 24); b[5] = (uint8_t)(v >> 16); b[6] = (uint8_t)(v >> 8); b[7] = (uint8_t)v; } static uint32_t get_u32(const uint8_t *b) { return ((uint32_t)b[0] << 24) | ((uint32_t)b[1] << 16) | ((uint32_t)b[2] << 8) | (uint32_t)b[3]; } static uint64_t get_u64(const uint8_t *b) { return ((uint64_t)b[0] << 56) | ((uint64_t)b[1] << 48) | ((uint64_t)b[2] << 40) | ((uint64_t)b[3] << 32) | ((uint64_t)b[4] << 24) | ((uint64_t)b[5] << 16) | ((uint64_t)b[6] << 8) | (uint64_t)b[7]; } int http3_envelope_pack_binary(const http3_envelope_t *env, uint8_t *out, size_t out_cap, size_t *written) { if (env == NULL || out == NULL || env->payload_len > HTTP3_ENVELOPE_MAX_PAYLOAD || out_cap < HTTP3_ENVELOPE_BIN_HEADER + env->payload_len) { return -1; } out[0] = env->version; out[1] = (uint8_t)(env->flags | HTTP3_FLAG_BINARY); put_u32(out + 2, env->service_id); put_u32(out + 6, env->op_id); put_u64(out + 10, env->request_id); memcpy(out + 18, env->port.bytes, HTTP3_PORT_BYTES); put_u64(out + 38, env->nonce); put_u64(out + 46, env->digest); put_u64(out + 54, env->intactx); memcpy(out + 62, env->basket, HTTP3_BASKET_BLOCK_SIZE); put_u32(out + 62 + HTTP3_BASKET_BLOCK_SIZE, (uint32_t)env->payload_len); memcpy(out + HTTP3_ENVELOPE_BIN_HEADER, env->payload, env->payload_len); if (written != NULL) { *written = HTTP3_ENVELOPE_BIN_HEADER + env->payload_len; } return 0; } int http3_envelope_unpack_binary(const uint8_t *in, size_t in_len, http3_envelope_t *env) { uint32_t payload_len; if (in == NULL || env == NULL || in_len < HTTP3_ENVELOPE_BIN_HEADER) { return -1; } payload_len = get_u32(in + 62 + HTTP3_BASKET_BLOCK_SIZE); if (payload_len > HTTP3_ENVELOPE_MAX_PAYLOAD || in_len < (size_t)HTTP3_ENVELOPE_BIN_HEADER + payload_len) { return -1; } memset(env, 0, sizeof(*env)); env->version = in[0]; env->flags = in[1]; env->service_id = get_u32(in + 2); env->op_id = get_u32(in + 6); env->request_id = get_u64(in + 10); memcpy(env->port.bytes, in + 18, HTTP3_PORT_BYTES); if (!http3_port_is_valid(&env->port)) return -1; env->nonce = get_u64(in + 38); env->digest = get_u64(in + 46); env->intactx = get_u64(in + 54); memcpy(env->basket, in + 62, HTTP3_BASKET_BLOCK_SIZE); env->payload_len = payload_len; if (payload_len > 0U) { memcpy(env->payload, in + HTTP3_ENVELOPE_BIN_HEADER, payload_len); } return 0; } /* ---- Response ------------------------------------------------------------- */ int http3_response_pack_text(const http3_response_t *resp, char *out, size_t out_cap, size_t *written) { int n; size_t pos; if (resp == NULL || out == NULL || resp->result_len > HTTP3_ENVELOPE_MAX_PAYLOAD) { return -1; } n = snprintf(out, out_cap, "H3R %d %llu %zu:", (int)resp->status, (unsigned long long)resp->request_id, resp->result_len); if (n < 0 || (size_t)n >= out_cap) { return -1; } pos = (size_t)n; if (pos + resp->result_len + 1U > out_cap) { return -1; } memcpy(out + pos, resp->result, resp->result_len); pos += resp->result_len; out[pos++] = '\n'; if (written != NULL) { *written = pos; } return 0; } int http3_response_unpack_text(const char *in, size_t in_len, http3_response_t *resp) { int status; unsigned long long request_id; unsigned long result_len; int consumed = 0; (void)in_len; if (in == NULL || resp == NULL) { return -1; } if (sscanf(in, "H3R %d %llu %lu:%n", &status, &request_id, &result_len, &consumed) != 3 || consumed <= 0 || result_len > HTTP3_ENVELOPE_MAX_PAYLOAD) { return -1; } memset(resp, 0, sizeof(*resp)); resp->status = (http3_status_t)status; resp->request_id = (uint64_t)request_id; resp->result_len = (size_t)result_len; if (result_len > 0U) { memcpy(resp->result, in + consumed, result_len); } return 0; } const char *http3_status_name(http3_status_t status) { switch (status) { case HTTP3_STATUS_OK: return "OK"; case HTTP3_STATUS_APP_ERROR: return "APP_ERROR"; case HTTP3_STATUS_UNKNOWN_SVC: return "UNKNOWN_SERVICE"; case HTTP3_STATUS_UNKNOWN_OP: return "UNKNOWN_OPERATION"; case HTTP3_STATUS_BAD_ENVELOPE: return "BAD_ENVELOPE"; case HTTP3_STATUS_TOO_LARGE: return "TOO_LARGE"; case HTTP3_STATUS_RETRY_DENIED: return "RETRY_DENIED"; case HTTP3_STATUS_BAD_DIGEST: return "BAD_DIGEST"; case HTTP3_STATUS_TAMPERED: return "TAMPERED"; case HTTP3_STATUS_REPLAYED: return "REPLAYED"; default: return "UNKNOWN"; } }