key_distribution_server.c
http-3.0/key_distribution_server.c · 258 line(s) · c
#define _POSIX_C_SOURCE 200809L
#include "key_distribution_server.h"
#include "crypto_openssl.h"
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
static pthread_mutex_t *kds_mutex(http3_kds_server_t *server) {
return (pthread_mutex_t *)server->lock;
}
static void secure_zero(void *p, size_t n) {
volatile unsigned char *v = (volatile unsigned char *)p;
while (n--) *v++ = 0;
}
static int write_key_file(const char *path, const uint8_t priv[32],
const uint8_t pub[32]) {
int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
uint8_t record[64];
ssize_t n;
if (fd < 0) return 0;
memcpy(record, priv, 32);
memcpy(record + 32, pub, 32);
{
size_t written = 0;
while (written < sizeof(record)) {
n = write(fd, record + written, sizeof(record) - written);
if (n <= 0) { close(fd); secure_zero(record, sizeof(record)); return 0; }
written += (size_t)n;
}
}
secure_zero(record, sizeof(record));
if (close(fd) != 0) return 0;
return 1;
}
static int read_key_file(const char *path, uint8_t priv[32], uint8_t pub[32]) {
int fd = open(path, O_RDONLY);
uint8_t record[64];
ssize_t n;
if (fd < 0) return 0;
{
size_t read_total = 0;
while (read_total < sizeof(record)) {
n = read(fd, record + read_total, sizeof(record) - read_total);
if (n <= 0) break;
read_total += (size_t)n;
}
n = (ssize_t)read_total;
}
close(fd);
if (n != (ssize_t)sizeof(record)) {
secure_zero(record, sizeof(record));
return 0;
}
memcpy(priv, record, 32);
memcpy(pub, record + 32, 32);
secure_zero(record, sizeof(record));
return 1;
}
static int valid_text(const char *s, size_t max) {
size_t i, n;
if (!s) return 0;
n = strnlen(s, max + 1U);
if (n == 0 || n > max) return 0;
for (i = 0; i < n; ++i) {
unsigned char c = (unsigned char)s[i];
if (c < 0x20 || c == '"' || c == '\\') return 0;
}
return 1;
}
int http3_kds_server_init(http3_kds_server_t *server, const char *key_file) {
pthread_mutex_t *mutex;
if (!server || !key_file || strlen(key_file) >= sizeof(server->key_file)) return 0;
memset(server, 0, sizeof(*server));
mutex = (pthread_mutex_t *)calloc(1, sizeof(*mutex));
if (!mutex) return 0;
if (pthread_mutex_init(mutex, NULL) != 0) {
free(mutex);
return 0;
}
server->lock = mutex;
strncpy(server->key_file, key_file, sizeof(server->key_file) - 1U);
if (!read_key_file(key_file, server->server_private, server->server_public)) {
if (!http3_openssl_x25519_generate(server->server_private,
server->server_public) ||
!write_key_file(key_file, server->server_private, server->server_public)) {
http3_kds_server_clear(server);
return 0;
}
}
server->rate.window_start = 0;
server->rate.issued = 0;
return 1;
}
void http3_kds_server_clear(http3_kds_server_t *server) {
pthread_mutex_t *mutex;
if (!server) return;
mutex = kds_mutex(server);
if (mutex) {
pthread_mutex_destroy(mutex);
free(mutex);
}
secure_zero(server->server_private, sizeof(server->server_private));
secure_zero(server->server_public, sizeof(server->server_public));
secure_zero(server, sizeof(*server));
}
int http3_kds_allow_issue(http3_kds_server_t *server, uint64_t now) {
int allowed = 0;
pthread_mutex_t *mutex;
if (!server || !server->lock) return 0;
mutex = kds_mutex(server);
pthread_mutex_lock(mutex);
if (server->rate.window_start == 0 || now < server->rate.window_start || now - server->rate.window_start >= 60U) {
server->rate.window_start = now;
server->rate.issued = 0;
}
if (server->rate.issued < HTTP3_KDS_MAX_KEYS_PER_MINUTE) {
++server->rate.issued;
allowed = 1;
}
pthread_mutex_unlock(mutex);
return allowed;
}
static int make_plaintext(const http3_kds_contract_t *contract,
char *out, size_t out_size) {
int n;
n = snprintf(out, out_size,
"SLeeLa-HTTP3-BOOTSTRAP-v1\\n"
"key_id=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\\n"
"client_id=%s\\n"
"jurisdiction=%s\\n"
"issued_at=%llu\\n"
"expires_at=%llu\\n",
contract->key_id[0], contract->key_id[1], contract->key_id[2], contract->key_id[3],
contract->key_id[4], contract->key_id[5], contract->key_id[6], contract->key_id[7],
contract->key_id[8], contract->key_id[9], contract->key_id[10], contract->key_id[11],
contract->key_id[12], contract->key_id[13], contract->key_id[14], contract->key_id[15],
contract->client_id, contract->jurisdiction,
(unsigned long long)contract->issued_at,
(unsigned long long)contract->expires_at);
return n > 0 && (size_t)n < out_size ? n : 0;
}
int http3_kds_issue_contract(http3_kds_server_t *server,
const uint8_t client_public[32],
const char *client_id,
const char *jurisdiction,
uint64_t now,
uint64_t ttl_seconds,
http3_kds_contract_t *contract) {
uint8_t shared[32], key[32], nonce[12], tag[16];
char plaintext[1024];
int plain_len;
if (!server || !client_public || !contract || !server->lock) return 0;
if (!valid_text(client_id, HTTP3_KDS_MAX_CLIENT_ID - 1U) ||
!valid_text(jurisdiction, HTTP3_KDS_MAX_JURISDICTION - 1U)) return 0;
if (!http3_kds_allow_issue(server, now)) return 0;
memset(contract, 0, sizeof(*contract));
contract->version = HTTP3_KDS_CONTRACT_VERSION;
contract->issued_at = now;
{ uint64_t ttl = ttl_seconds ? ttl_seconds : 3600U; if (ttl > UINT64_MAX - now) return 0; contract->expires_at = now + ttl; }
memcpy(contract->server_public, server->server_public, 32);
memcpy(contract->client_public, client_public, 32);
if (!http3_openssl_random(contract->key_id, sizeof(contract->key_id)) ||
!http3_openssl_x25519_derive(server->server_private, client_public, shared) ||
!http3_openssl_hkdf_sha256(shared, sizeof(shared), contract->key_id,
sizeof(contract->key_id),
(const uint8_t *)"SLeeLa/HTTP3/KDS/bootstrap/v1", 29,
key) ||
!http3_openssl_random(nonce, sizeof(nonce))) {
secure_zero(shared, sizeof(shared));
secure_zero(key, sizeof(key));
return 0;
}
strncpy(contract->client_id, client_id, sizeof(contract->client_id) - 1U);
strncpy(contract->jurisdiction, jurisdiction, sizeof(contract->jurisdiction) - 1U);
plain_len = make_plaintext(contract, plaintext, sizeof(plaintext));
if (!plain_len || !http3_openssl_aes256gcm_encrypt(
key, nonce, contract->key_id, sizeof(contract->key_id),
(const uint8_t *)plaintext, (size_t)plain_len,
contract->ciphertext + sizeof(nonce), tag)) {
secure_zero(shared, sizeof(shared));
secure_zero(key, sizeof(key));
secure_zero(plaintext, sizeof(plaintext));
return 0;
}
memcpy(contract->ciphertext, nonce, sizeof(nonce));
memcpy(contract->ciphertext + sizeof(nonce) + (size_t)plain_len, tag, sizeof(tag));
contract->ciphertext_len = sizeof(nonce) + (size_t)plain_len + sizeof(tag);
secure_zero(shared, sizeof(shared));
secure_zero(key, sizeof(key));
secure_zero(nonce, sizeof(nonce));
secure_zero(tag, sizeof(tag));
secure_zero(plaintext, sizeof(plaintext));
return 1;
}
int http3_kds_contract_json(const http3_kds_contract_t *contract,
char *output, size_t output_size) {
size_t i;
size_t pos = 0;
int n;
if (!contract || !output || output_size == 0 || contract->ciphertext_len > HTTP3_KDS_MAX_CONTRACT) return 0;
n = snprintf(output + pos, output_size - pos,
"{\"version\":%u,\"issued_at\":%llu,\"expires_at\":%llu,\"server_public\":\"",
contract->version,
(unsigned long long)contract->issued_at,
(unsigned long long)contract->expires_at);
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
for (i = 0; i < 32; ++i) {
n = snprintf(output + pos, output_size - pos, "%02x", contract->server_public[i]);
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
}
n = snprintf(output + pos, output_size - pos, "\",\"client_public\":\"");
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
for (i = 0; i < 32; ++i) {
n = snprintf(output + pos, output_size - pos, "%02x", contract->client_public[i]);
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
}
n = snprintf(output + pos, output_size - pos, "\",\"jurisdiction\":\"%s\",\"client_id\":\"%s\",\"key_id\":\"",
contract->jurisdiction, contract->client_id);
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
for (i = 0; i < sizeof(contract->key_id); ++i) {
n = snprintf(output + pos, output_size - pos, "%02x", contract->key_id[i]);
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
}
n = snprintf(output + pos, output_size - pos, "\",\"ciphertext\":\"");
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
for (i = 0; i < contract->ciphertext_len; ++i) {
n = snprintf(output + pos, output_size - pos, "%02x", contract->ciphertext[i]);
if (n < 0 || (size_t)n >= output_size - pos) return 0;
pos += (size_t)n;
}
n = snprintf(output + pos, output_size - pos, "\"}\n");
return n >= 0 && (size_t)n < output_size - pos ? (int)(pos + (size_t)n) : 0;
}