tpm2-tools/SOURCES/0015-openssl-Implement-EVP_PKEY-based-key-export.patch

From e34d393d7c73a58b3bf6fccbe88ea1eedfe1d7b7 Mon Sep 17 00:00:00 2001
From: Petr Gotthard <petr.gotthard@centrum.cz>
Date: Sun, 15 Aug 2021 15:58:28 +0200
Subject: [PATCH 14/17] openssl: Implement EVP_PKEY based key export

The `RSA_KEY` and `EC_KEY` are not publicly available in OpenSSL 3.0 and
the generic `EVP_PKEY` must be used instead.

Signed-off-by: Petr Gotthard <petr.gotthard@centrum.cz>
---
 lib/tpm2_convert.c | 319 ++++++++++++++++++++++++++++++++-------------
 lib/tpm2_convert.h |  20 +++
 2 files changed, 245 insertions(+), 94 deletions(-)

diff --git a/lib/tpm2_convert.c b/lib/tpm2_convert.c
index cc1c18ab..986fc1a7 100644
--- a/lib/tpm2_convert.c
+++ b/lib/tpm2_convert.c
@@ -9,6 +9,13 @@
 #include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/pem.h>
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+#include <openssl/rsa.h>
+#else
+#include <openssl/core_names.h>
+#include <openssl/params.h>
+#include <openssl/param_build.h>
+#endif
 
 #include "files.h"
 #include "log.h"
@@ -70,36 +77,49 @@ bool tpm2_convert_pubkey_save(TPM2B_PUBLIC *public,
     return false;
 }
 
-static bool convert_pubkey_RSA(TPMT_PUBLIC *public,
-        tpm2_convert_pubkey_fmt format, BIO *bio) {
+EVP_PKEY *convert_pubkey_RSA(TPMT_PUBLIC *public) {
 
-    bool ret = false;
-    RSA *ssl_rsa_key = NULL;
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+    RSA *rsa_key = NULL;
+#else
+    OSSL_PARAM_BLD *build = NULL;
+    OSSL_PARAM *params = NULL;
+    EVP_PKEY_CTX *ctx = NULL;
+#endif
     BIGNUM *e = NULL, *n = NULL;
+    EVP_PKEY *pkey = NULL;
 
     UINT32 exponent = (public->parameters).rsaDetail.exponent;
     if (exponent == 0) {
         exponent = 0x10001;
     }
 
-    // OpenSSL expects this in network byte order
-    exponent = tpm2_util_hton_32(exponent);
-    ssl_rsa_key = RSA_new();
-    if (!ssl_rsa_key) {
-        print_ssl_error("Failed to allocate OpenSSL RSA structure");
+    n = BN_bin2bn(public->unique.rsa.buffer, public->unique.rsa.size, NULL);
+    if (!n) {
+        print_ssl_error("Failed to convert data to SSL internal format");
         goto error;
     }
 
-    e = BN_bin2bn((void*) &exponent, sizeof(exponent), NULL);
-    n = BN_bin2bn(public->unique.rsa.buffer, public->unique.rsa.size,
-    NULL);
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+    rsa_key = RSA_new();
+    if (!rsa_key) {
+        print_ssl_error("Failed to allocate OpenSSL RSA structure");
+        goto error;
+    }
 
-    if (!n || !e) {
+    e = BN_new();
+    if (!e) {
+        print_ssl_error("Failed to convert data to SSL internal format");
+        goto error;
+    }
+    int rc = BN_set_word(e, exponent);
+    if (!rc) {
         print_ssl_error("Failed to convert data to SSL internal format");
         goto error;
     }
 
-    if (!RSA_set0_key(ssl_rsa_key, n, e, NULL)) {
+    rc = RSA_set0_key(rsa_key, n, e, NULL);
+    if (!rc) {
         print_ssl_error("Failed to set RSA modulus and exponent components");
         goto error;
     }
@@ -107,162 +127,273 @@ static bool convert_pubkey_RSA(TPMT_PUBLIC *public,
     /* modulus and exponent components are now owned by the RSA struct */
     n = e = NULL;
 
-    int ssl_res = 0;
+    pkey = EVP_PKEY_new();
+    if (!pkey) {
+        print_ssl_error("Failed to allocate OpenSSL EVP structure");
+        goto error;
+    }
 
-    switch (format) {
-    case pubkey_format_pem:
-        ssl_res = PEM_write_bio_RSA_PUBKEY(bio, ssl_rsa_key);
-        break;
-    case pubkey_format_der:
-        ssl_res = i2d_RSA_PUBKEY_bio(bio, ssl_rsa_key);
-        break;
-    default:
-        LOG_ERR("Invalid OpenSSL target format %d encountered", format);
+    rc = EVP_PKEY_assign_RSA(pkey, rsa_key);
+    if (!rc) {
+        print_ssl_error("Failed to set OpenSSL EVP structure");
+        EVP_PKEY_free(pkey);
+        pkey = NULL;
+        goto error;
+    }
+    /* rsa key is now owner by the EVP_PKEY struct */
+    rsa_key = NULL;
+#else
+    build = OSSL_PARAM_BLD_new();
+    if (!build) {
+        print_ssl_error("Failed to allocate OpenSSL parameters");
         goto error;
     }
 
-    if (ssl_res <= 0) {
-        print_ssl_error("OpenSSL public key conversion failed");
+    int rc = OSSL_PARAM_BLD_push_BN(build, OSSL_PKEY_PARAM_RSA_N, n);
+    if (!rc) {
+        print_ssl_error("Failed to set RSA modulus");
         goto error;
     }
 
-    ret = true;
+    rc = OSSL_PARAM_BLD_push_uint32(build, OSSL_PKEY_PARAM_RSA_E, exponent);
+    if (!rc) {
+        print_ssl_error("Failed to set RSA exponent");
+        goto error;
+    }
 
-    error: if (n) {
-        BN_free(n);
+    params = OSSL_PARAM_BLD_to_param(build);
+    if (!params) {
+        print_ssl_error("Failed to build OpenSSL parameters");
+        goto error;
     }
-    if (e) {
-        BN_free(e);
+
+    ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL);
+    if (!ctx) {
+        print_ssl_error("Failed to allocate RSA key context");
+        goto error;
     }
-    if (ssl_rsa_key) {
-        RSA_free(ssl_rsa_key);
+
+    rc = EVP_PKEY_fromdata_init(ctx);
+    if (rc <= 0) {
+        print_ssl_error("Failed to initialize RSA key creation");
+        goto error;
     }
 
-    return ret;
+    rc = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params);
+    if (rc <= 0) {
+        print_ssl_error("Failed to create a RSA public key");
+        goto error;
+    }
+#endif
+error:
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+    RSA_free(rsa_key);
+#else
+    EVP_PKEY_CTX_free(ctx);
+    OSSL_PARAM_free(params);
+    OSSL_PARAM_BLD_free(build);
+#endif
+    BN_free(n);
+    BN_free(e);
+    return pkey;
 }
 
-static bool convert_pubkey_ECC(TPMT_PUBLIC *public,
-        tpm2_convert_pubkey_fmt format, BIO *bio) {
+EVP_PKEY *convert_pubkey_ECC(TPMT_PUBLIC *public) {
 
     BIGNUM *x = NULL;
     BIGNUM *y = NULL;
-    EC_KEY *key = NULL;
     EC_POINT *point = NULL;
-    const EC_GROUP *group = NULL;
-
-    bool result = false;
+    EC_GROUP *group = NULL;
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+    EC_KEY *ec_key = NULL;
+#else
+    OSSL_PARAM_BLD *build = NULL;
+    OSSL_PARAM *params = NULL;
+    EVP_PKEY_CTX *ctx = NULL;
+    unsigned char *puboct = NULL;
+    size_t bsize;
+#endif
+    EVP_PKEY *pkey = NULL;
 
     TPMS_ECC_PARMS *tpm_ecc = &public->parameters.eccDetail;
     TPMS_ECC_POINT *tpm_point = &public->unique.ecc;
 
+    /*
+     * Set the affine coordinates for the point
+     */
+    x = BN_bin2bn(tpm_point->x.buffer, tpm_point->x.size, NULL);
+    if (!x) {
+        print_ssl_error("Could not convert x coordinate to BN");
+        goto out;
+    }
+
+    y = BN_bin2bn(tpm_point->y.buffer, tpm_point->y.size, NULL);
+    if (!y) {
+        print_ssl_error("Could not convert y coordinate to BN");
+        goto out;
+    }
+
     int nid = tpm2_ossl_curve_to_nid(tpm_ecc->curveID);
     if (nid < 0) {
-        return false;
+        goto out;
     }
 
     /*
-     * Create an empty EC key by the NID
+     * Create a new point in the group, which is the public key.
      */
-    key = EC_KEY_new_by_curve_name(nid);
-    if (!key) {
-        print_ssl_error("Failed to create EC key from nid");
-        return false;
-    }
-
-    group = EC_KEY_get0_group(key);
+    group = EC_GROUP_new_by_curve_name(nid);
     if (!group) {
         print_ssl_error("EC key missing group");
         goto out;
     }
 
-    /*
-     * Create a new point in the group, which is the public key.
-     */
     point = EC_POINT_new(group);
 
+    int rc = EC_POINT_set_affine_coordinates_tss(group, point, x, y, NULL);
+    if (!rc) {
+        print_ssl_error("Could not set affine coordinates");
+        goto out;
+    }
+
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
     /*
-     * Set the affine coordinates for the point
+     * Create an empty EC key by the NID
      */
-    x = BN_bin2bn(tpm_point->x.buffer, tpm_point->x.size, NULL);
-    if (!x) {
-        print_ssl_error("Could not convert x coordinate to BN");
+    ec_key = EC_KEY_new_by_curve_name(nid);
+    if (!ec_key) {
+        print_ssl_error("Failed to create EC key from nid");
+        return false;
+    }
+
+    rc = EC_KEY_set_public_key(ec_key, point);
+    if (!rc) {
+        print_ssl_error("Could not set point as public key portion");
         goto out;
     }
 
-    y = BN_bin2bn(tpm_point->y.buffer, tpm_point->y.size, NULL);
-    if (!y) {
-        print_ssl_error("Could not convert y coordinate to BN");
+    if ((pkey = EVP_PKEY_new()) == NULL) {
+        print_ssl_error("Failed to allocate OpenSSL EVP structure");
         goto out;
     }
 
-    int rc = EC_POINT_set_affine_coordinates_tss(group, point, x, y, NULL);
+    rc = EVP_PKEY_assign_EC_KEY(pkey, ec_key);
     if (!rc) {
-        print_ssl_error("Could not set affine coordinates");
+        print_ssl_error("Failed to set OpenSSL EVP structure");
+        EVP_PKEY_free(pkey);
+        pkey = NULL;
+        goto out;
+    }
+    /* rsa key is now owner by the EVP_PKEY struct */
+    ec_key = NULL;
+#else
+    build = OSSL_PARAM_BLD_new();
+    if (!build) {
+        print_ssl_error("Failed to allocate OpenSSL parameters");
         goto out;
     }
 
-    rc = EC_KEY_set_public_key(key, point);
+    rc = OSSL_PARAM_BLD_push_utf8_string(build, OSSL_PKEY_PARAM_GROUP_NAME,
+                                         (char *)OBJ_nid2sn(nid), 0);
     if (!rc) {
-        print_ssl_error("Could not set point as public key portion");
+        print_ssl_error("Failed to set the EC group name");
         goto out;
     }
 
-    int ssl_res = 0;
-
-    switch (format) {
-    case pubkey_format_pem:
-        ssl_res = PEM_write_bio_EC_PUBKEY(bio, key);
-        break;
-    case pubkey_format_der:
-        ssl_res = i2d_EC_PUBKEY_bio(bio, key);
-        break;
-    default:
-        LOG_ERR("Invalid OpenSSL target format %d encountered", format);
+    bsize = EC_POINT_point2buf(group, point,
+                               POINT_CONVERSION_COMPRESSED,
+                               &puboct, NULL);
+    if (bsize == 0) {
+        print_ssl_error("Failed compress the EC public key");
         goto out;
     }
 
-    if (ssl_res <= 0) {
-        print_ssl_error("OpenSSL public key conversion failed");
+    rc = OSSL_PARAM_BLD_push_octet_string(build, OSSL_PKEY_PARAM_PUB_KEY,
+                                          puboct, bsize);
+    if (!rc) {
+        print_ssl_error("Failed set the EC public key");
         goto out;
     }
 
-    result = true;
-
-out:
-    if (x) {
-        BN_free(x);
+    params = OSSL_PARAM_BLD_to_param(build);
+    if (!params) {
+        print_ssl_error("Failed to build OpenSSL parameters");
+        goto out;
     }
-    if (y) {
-        BN_free(y);
+
+    ctx = EVP_PKEY_CTX_new_from_name(NULL, "EC", NULL);
+    if (!ctx) {
+        print_ssl_error("Failed to allocate EC key context");
+        goto out;
     }
-    if (point) {
-        EC_POINT_free(point);
+
+    rc = EVP_PKEY_fromdata_init(ctx);
+    if (rc <= 0) {
+        print_ssl_error("Failed to initialize EC key creation");
+        goto out;
     }
-    if (key) {
-        EC_KEY_free(key);
+
+    rc = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, params);
+    if (rc <= 0) {
+        print_ssl_error("Failed to create a EC public key");
+        goto out;
     }
+#endif
 
-    return result;
+out:
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+    EC_KEY_free(ec_key);
+#else
+    EVP_PKEY_CTX_free(ctx);
+    OSSL_PARAM_free(params);
+    OSSL_PARAM_BLD_free(build);
+    OPENSSL_free(puboct);
+#endif
+    EC_POINT_free(point);
+    EC_GROUP_free(group);
+    BN_free(x);
+    BN_free(y);
+    return pkey;
 }
 
 static bool tpm2_convert_pubkey_bio(TPMT_PUBLIC *public,
         tpm2_convert_pubkey_fmt format, BIO *bio) {
 
-    bool result = false;
+    EVP_PKEY *pubkey = NULL;
+    int ssl_res = 0;
 
     switch (public->type) {
     case TPM2_ALG_RSA:
-        result = convert_pubkey_RSA(public, format, bio);
+        pubkey = convert_pubkey_RSA(public);
         break;
     case TPM2_ALG_ECC:
-        result = convert_pubkey_ECC(public, format, bio);
+        pubkey = convert_pubkey_ECC(public);
         break;
     default:
-        LOG_ERR(
-                "Unsupported key type for requested output format. Only RSA is supported.");
+        LOG_ERR("Unsupported key type for requested output format.");
     }
 
-    return result;
+    if (pubkey == NULL)
+        return false;
+
+    switch (format) {
+    case pubkey_format_pem:
+        ssl_res = PEM_write_bio_PUBKEY(bio, pubkey);
+        break;
+    case pubkey_format_der:
+        ssl_res = i2d_PUBKEY_bio(bio, pubkey);
+        break;
+    default:
+        LOG_ERR("Invalid OpenSSL target format %d encountered", format);
+    }
+
+    EVP_PKEY_free(pubkey);
+
+    if (ssl_res <= 0) {
+        print_ssl_error("OpenSSL public key conversion failed");
+        return false;
+    }
+
+    return true;
 }
 
 static bool tpm2_convert_pubkey_ssl(TPMT_PUBLIC *public,
diff --git a/lib/tpm2_convert.h b/lib/tpm2_convert.h
index f8c82155..bddb455d 100644
--- a/lib/tpm2_convert.h
+++ b/lib/tpm2_convert.h
@@ -45,6 +45,26 @@ tpm2_convert_pubkey_fmt tpm2_convert_pubkey_fmt_from_optarg(const char *label);
 bool tpm2_convert_pubkey_save(TPM2B_PUBLIC *public,
         tpm2_convert_pubkey_fmt format, const char *path);
 
+/**
+ * Converts the given RSA public key structure into the EVP_PKEY.
+ *
+ * @param public
+ *  TPM2 public key structure structure.
+ * @return
+ *   OpenSSL key structure, or NULL on error.
+ */
+EVP_PKEY *convert_pubkey_RSA(TPMT_PUBLIC *public);
+
+/**
+ * Converts the given ECC public key structure into the EVP_PKEY.
+ *
+ * @param public
+ *  TPM2 public key structure structure.
+ * @return
+ *   OpenSSL key structure, or NULL on error.
+ */
+EVP_PKEY *convert_pubkey_ECC(TPMT_PUBLIC *public);
+
 /**
  * Parses the given command line signature format option string and returns
  * the corresponding signature_format enum value.
-- 
2.31.1