Home /Modules/advantage/kex.c

kex.c

advantage/transport/kex.c · 190 line(s) · c

/*
 * kex.c - DH / ECDH key agreement + HKDF session key (see kex.h).
 *
 * Uses OpenSSL 3.x EVP_PKEY APIs. For X25519 we use raw public keys; for
 * P-256 and FFDHE we use SubjectPublicKeyInfo DER so the group parameters
 * travel with the key.
 */
#include "kex.h"

#include <stdlib.h>
#include <string.h>

#include <openssl/evp.h>
#include <openssl/kdf.h>
#include <openssl/core_names.h>
#include <openssl/param_build.h>
#include <openssl/x509.h>

struct kex_keypair {
    kex_group group;
    EVP_PKEY *pkey;
};

static int is_raw(kex_group g) { return g == KEX_X25519; }

static const char *group_sn(kex_group g) {
    switch (g) {
        case KEX_P256:      return "prime256v1";
        case KEX_FFDHE2048: return "ffdhe2048";
        case KEX_FFDHE3072: return "ffdhe3072";
        default:            return NULL;
    }
}

const char *kex_group_name(kex_group g) {
    switch (g) {
        case KEX_X25519:    return "X25519";
        case KEX_P256:      return "P-256 (prime256v1)";
        case KEX_FFDHE2048: return "FFDHE2048";
        case KEX_FFDHE3072: return "FFDHE3072";
    }
    return "unknown";
}

kex_status kex_generate(kex_group group, kex_keypair **out) {
    if (!out) return KEX_ERR_ARG;
    *out = NULL;

    EVP_PKEY_CTX *ctx = NULL;
    EVP_PKEY *pkey = NULL;
    kex_status rc = KEX_ERR_CRYPTO;

    if (group == KEX_X25519) {
        ctx = EVP_PKEY_CTX_new_from_name(NULL, "X25519", NULL);
        if (!ctx || EVP_PKEY_keygen_init(ctx) != 1) goto done;
        if (EVP_PKEY_keygen(ctx, &pkey) != 1) goto done;
    } else if (group == KEX_P256) {
        ctx = EVP_PKEY_CTX_new_from_name(NULL, "EC", NULL);
        if (!ctx || EVP_PKEY_keygen_init(ctx) != 1) goto done;
        if (EVP_PKEY_CTX_set_group_name(ctx, "prime256v1") != 1) goto done;
        if (EVP_PKEY_keygen(ctx, &pkey) != 1) goto done;
    } else if (group == KEX_FFDHE2048 || group == KEX_FFDHE3072) {
        ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL);
        if (!ctx || EVP_PKEY_keygen_init(ctx) != 1) goto done;
        OSSL_PARAM params[2];
        params[0] = OSSL_PARAM_construct_utf8_string(
            OSSL_PKEY_PARAM_GROUP_NAME, (char *)group_sn(group), 0);
        params[1] = OSSL_PARAM_construct_end();
        if (EVP_PKEY_CTX_set_params(ctx, params) != 1) goto done;
        if (EVP_PKEY_keygen(ctx, &pkey) != 1) goto done;
    } else {
        rc = KEX_ERR_ARG;
        goto done;
    }

    kex_keypair *kp = calloc(1, sizeof(*kp));
    if (!kp) { rc = KEX_ERR_CRYPTO; goto done; }
    kp->group = group;
    kp->pkey = pkey;
    pkey = NULL;
    *out = kp;
    rc = KEX_OK;

done:
    if (pkey) EVP_PKEY_free(pkey);
    if (ctx) EVP_PKEY_CTX_free(ctx);
    return rc;
}

kex_status kex_export_public(const kex_keypair *kp, uint8_t *pub, size_t *len) {
    if (!kp || !len) return KEX_ERR_ARG;

    if (is_raw(kp->group)) {
        size_t need = 0;
        if (EVP_PKEY_get_raw_public_key(kp->pkey, NULL, &need) != 1)
            return KEX_ERR_CRYPTO;
        if (!pub || *len < need) { *len = need; return KEX_ERR_BUFFER; }
        if (EVP_PKEY_get_raw_public_key(kp->pkey, pub, len) != 1)
            return KEX_ERR_CRYPTO;
        return KEX_OK;
    }

    /* SubjectPublicKeyInfo DER. */
    unsigned char *der = NULL;
    int n = i2d_PUBKEY(kp->pkey, &der);
    if (n <= 0) return KEX_ERR_CRYPTO;
    if (!pub || *len < (size_t)n) { *len = (size_t)n; OPENSSL_free(der); return KEX_ERR_BUFFER; }
    memcpy(pub, der, (size_t)n);
    *len = (size_t)n;
    OPENSSL_free(der);
    return KEX_OK;
}

static EVP_PKEY *import_peer(kex_group group, const uint8_t *pub, size_t len) {
    if (is_raw(group)) {
        return EVP_PKEY_new_raw_public_key_ex(NULL, "X25519", NULL, pub, len);
    }
    const unsigned char *p = pub;
    return d2i_PUBKEY(NULL, &p, (long)len);
}

static kex_status hkdf_sha256(const uint8_t *ikm, size_t ikm_len,
                              const char *info,
                              uint8_t *out, size_t out_len) {
    EVP_KDF *kdf = EVP_KDF_fetch(NULL, "HKDF", NULL);
    if (!kdf) return KEX_ERR_CRYPTO;
    EVP_KDF_CTX *kctx = EVP_KDF_CTX_new(kdf);
    EVP_KDF_free(kdf);
    if (!kctx) return KEX_ERR_CRYPTO;

    OSSL_PARAM params[4];
    size_t i = 0;
    params[i++] = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char *)"SHA256", 0);
    params[i++] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (void *)ikm, ikm_len);
    if (info)
        params[i++] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO, (void *)info, strlen(info));
    params[i] = OSSL_PARAM_construct_end();

    kex_status rc = (EVP_KDF_derive(kctx, out, out_len, params) == 1) ? KEX_OK : KEX_ERR_CRYPTO;
    EVP_KDF_CTX_free(kctx);
    return rc;
}

kex_status kex_derive(const kex_keypair *kp,
                      const uint8_t *peer_pub, size_t peer_pub_len,
                      const char *info,
                      uint8_t *out_key, size_t key_len) {
    if (!kp || !peer_pub || !out_key || key_len == 0) return KEX_ERR_ARG;

    EVP_PKEY *peer = import_peer(kp->group, peer_pub, peer_pub_len);
    if (!peer) return KEX_ERR_CRYPTO;

    EVP_PKEY_CTX *dctx = EVP_PKEY_CTX_new(kp->pkey, NULL);
    kex_status rc = KEX_ERR_CRYPTO;
    uint8_t *secret = NULL;
    size_t secret_len = 0;

    if (!dctx) goto done;
    if (EVP_PKEY_derive_init(dctx) != 1) goto done;
    if (EVP_PKEY_derive_set_peer(dctx, peer) != 1) goto done;
    if (EVP_PKEY_derive(dctx, NULL, &secret_len) != 1) goto done;
    secret = OPENSSL_malloc(secret_len);
    if (!secret) goto done;
    if (EVP_PKEY_derive(dctx, secret, &secret_len) != 1) goto done;

    rc = hkdf_sha256(secret, secret_len, info, out_key, key_len);

done:
    if (secret) OPENSSL_clear_free(secret, secret_len);
    if (dctx) EVP_PKEY_CTX_free(dctx);
    if (peer) EVP_PKEY_free(peer);
    return rc;
}

void kex_free(kex_keypair *kp) {
    if (!kp) return;
    if (kp->pkey) EVP_PKEY_free(kp->pkey);
    free(kp);
}

const char *kex_strerror(kex_status st) {
    switch (st) {
        case KEX_OK:         return "ok";
        case KEX_ERR_ARG:    return "invalid argument";
        case KEX_ERR_CRYPTO: return "cryptographic operation failed";
        case KEX_ERR_BUFFER: return "output buffer too small";
    }
    return "unknown error";
}