|
[AMD Official Use Only - General] Hello everyone, I am currently working on updating a signature verification function in C++ and I am a bit stuck. I am trying to replace the deprecated 1.1.1 functions to the appropriate 3.0 versions. The function takes in 2 certificate objects (parent
and cert), which are not x509 certificates, but certificates the company had previously defined. Using the contents from parent we create an RSA public key and using the contents from cert we create the digest and grab the signature to verify.
In the 1.1.1 version we were using the RSA Object and the rsa_set0_key function to create the RSA public key and then used RSA_public_decrypt to decrypt the signature and RSA_verify_PKCS1_PSS to verify it. This whole workflow is now deprecated.
//OPENSSL 1.1.1 Code SEV_ERROR_CODE AMDCert::amd_cert_validate_sig(const amd_cert *cert, const amd_cert *parent, ePSP_DEVICE_TYPE device_type) { SEV_ERROR_CODE cmd_ret = ERROR_INVALID_CERTIFICATE; hmac_sha_256 sha_digest_256; hmac_sha_512 sha_digest_384; SHA_TYPE algo = SHA_TYPE_256; uint8_t *sha_digest = NULL; size_t sha_length = 0; RSA *rsa_pub_key = NULL; BIGNUM *modulus = NULL; BIGNUM *pub_exp = NULL; EVP_MD_CTX* md_ctx = NULL; uint32_t sig_len = cert->modulus_size/8; uint32_t digest_len = 0; uint8_t decrypted[AMD_CERT_KEY_BYTES_4K] = {0}; // TODO wrong length uint8_t signature[AMD_CERT_KEY_BYTES_4K] = {0}; uint32_t fixed_offset = offsetof(amd_cert, pub_exp); // 64 bytes do { if (!cert || !parent) { cmd_ret = ERROR_INVALID_PARAM; break; } // Set SHA_TYPE to 256 bit or 384 bit depending on device_type if (device_type == PSP_DEVICE_TYPE_NAPLES) { algo = SHA_TYPE_256; sha_digest = sha_digest_256; sha_length = sizeof(hmac_sha_256); } else /*if (ROME/MILAN)*/ { algo = SHA_TYPE_384; sha_digest = sha_digest_384; sha_length = sizeof(hmac_sha_512); } // Memzero all the buffers memset(sha_digest, 0, sha_length); memset(decrypted, 0, sizeof(decrypted)); memset(signature, 0, sizeof(signature)); // New up the RSA key rsa_pub_key = RSA_new(); // Convert the parent to an RSA key to pass into RSA_verify modulus = BN_lebin2bn((uint8_t *)&parent->modulus, parent->modulus_size/8, NULL); // n // New's up BigNum pub_exp = BN_lebin2bn((uint8_t *)&parent->pub_exp, parent->pub_exp_size/8, NULL); // e if (RSA_set0_key(rsa_pub_key, modulus, pub_exp, NULL) != 1) break; // Create digest from certificate md_ctx = EVP_MD_CTX_create(); if (EVP_DigestInit(md_ctx, (algo == SHA_TYPE_256) ? EVP_sha256() : EVP_sha384()) <= 0) break; if (EVP_DigestUpdate(md_ctx, cert, fixed_offset) <= 0) // Calls SHA256_UPDATE break; if (EVP_DigestUpdate(md_ctx, &cert->pub_exp, cert->pub_exp_size/8) <= 0) break; if (EVP_DigestUpdate(md_ctx, &cert->modulus, cert->modulus_size/8) <= 0) break; EVP_DigestFinal(md_ctx, sha_digest, &digest_len); // Swap the bytes of the signature memcpy(signature, &cert->sig, parent->modulus_size/8); if (!sev::reverse_bytes(signature, parent->modulus_size/8)) break; // Now we will verify the signature. Start by a RAW decrypt of the signature if (RSA_public_decrypt(sig_len, signature, decrypted, rsa_pub_key, RSA_NO_PADDING) == -1) break; // Verify the data // SLen of -2 means salt length is recovered from the signature if (RSA_verify_PKCS1_PSS(rsa_pub_key, sha_digest, (algo == SHA_TYPE_256) ? EVP_sha256() : EVP_sha384(), decrypted, -2) != 1) { break; } cmd_ret = STATUS_SUCCESS; } while (0); // Free the keys and contexts if (rsa_pub_key) RSA_free(rsa_pub_key); if (md_ctx) EVP_MD_CTX_free(md_ctx); return cmd_ret; } My current attempt to do this update is first creating an EVP_PKEY object which will now store the public key and inputting the same data from parent by using the EVP_PKEY_fromdata generation function. I build my OSSL_PARAMETERS using OSSL_PARAM_BLD
to which I push the data from parent. Lastly for the verification I am using the EVP_DigestVerifyFinal procedure. I create the digest using EVP_DigestVerifyInit and EVP_DigestVerifyUpdate and passing in the same data from cert that we were using in the 1.1.1
version of the function. I have tried different approaches to both creating the key and the verification procedure, but I cannot seem to get it to work. // OPENSSL 3.0 code SEV_ERROR_CODE AMDCert::amd_cert_validate_sig(const amd_cert *cert, const amd_cert *parent, ePSP_DEVICE_TYPE device_type) { SEV_ERROR_CODE cmd_ret = ERROR_INVALID_CERTIFICATE; hmac_sha_256 sha_digest_256; hmac_sha_512 sha_digest_384; SHA_TYPE algo = SHA_TYPE_256; uint8_t *sha_digest = NULL; size_t sha_length = 0; EVP_PKEY *rsa_pub_key = EVP_PKEY_new(); RSA *old_rsa_pub_key = NULL; BIGNUM *modulus = NULL; BIGNUM *pub_exp = NULL; EVP_PKEY_CTX *key_gen_ctx = NULL; uint32_t sig_len = cert->modulus_size/8; EVP_MD_CTX* verify_md_ctx = NULL; uint32_t digest_len = 0; uint8_t signature[AMD_CERT_KEY_BYTES_4K] = {0}; uint32_t fixed_offset = offsetof(amd_cert, pub_exp); // 64 bytes do { if (!cert || !parent) { cmd_ret = ERROR_INVALID_PARAM; break; } // Set SHA_TYPE to 256 bit or 384 bit depending on device_type if (device_type == PSP_DEVICE_TYPE_NAPLES) { algo = SHA_TYPE_256; sha_digest = sha_digest_256; sha_length = sizeof(hmac_sha_256); } else /*if (ROME/MILAN)*/ { algo = SHA_TYPE_384; sha_digest = sha_digest_384; sha_length = sizeof(hmac_sha_512); } // Memzero all the buffers memset(sha_digest, 0, sha_length); memset(signature, 0, sizeof(signature)); //Convert the parent to an RSA key to pass into EVP_DigesetVerify modulus = BN_lebin2bn((uint8_t *)&parent->modulus, parent->modulus_size/8, NULL); // n // New's up BigNum pub_exp = BN_lebin2bn((uint8_t *)&parent->pub_exp, parent->pub_exp_size/8, NULL); // e // Creating parameter build OSSL_PARAM_BLD *params_build = OSSL_PARAM_BLD_new(); if ( params_build == NULL ) { cout << "Init fails " << endl; } // Push modulus if ( !OSSL_PARAM_BLD_push_BN(params_build, "n", modulus) ) { cout << "Error: failed to push modulus into param build." << endl; break; } // Push pub_exp if ( !OSSL_PARAM_BLD_push_BN(params_build, "e", pub_exp) ) { cout << "Error: failed to push exponent into param build." << endl; break; } // Build parameters OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(params_build); if ( params == NULL ) { cout << "Error: building parameters." << endl; break; } // Free BLD struct OSSL_PARAM_BLD_free(params_build); // Create key_gen context key_gen_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL); //EVP_PKEY_keygen_init(pctx); if(EVP_PKEY_fromdata_init(key_gen_ctx) != 1) { cout << "failed to initialize key creation." << endl; break; } // Generate rsa public key if(EVP_PKEY_fromdata(key_gen_ctx, &rsa_pub_key, EVP_PKEY_PUBLIC_KEY, params) != 1) { cout << "key generation breaks" << endl; break; } // Free PARAM structure OSSL_PARAM_free(params); // Swap the bytes of the signature memcpy(signature, &cert->sig, parent->modulus_size/8); if (!sev::reverse_bytes(signature, parent->modulus_size/8)) break; // Create digest context verify_md_ctx = EVP_MD_CTX_create(); if (!verify_md_ctx) { cout << "Error allocating pkey context " << endl;; break; } if (EVP_DigestVerifyInit(verify_md_ctx, NULL, (algo == SHA_TYPE_256) ? EVP_sha256() : EVP_sha384(), NULL, rsa_pub_key) <= 0) { cout << "Init fails " << endl; break; } if (EVP_DigestVerifyUpdate(verify_md_ctx, cert, fixed_offset) <= 0) // Calls SHA256_UPDATE break; if (EVP_DigestVerifyUpdate(verify_md_ctx, &cert->pub_exp, cert->pub_exp_size/8) <= 0) break; if (EVP_DigestVerifyUpdate(verify_md_ctx, &cert->modulus, cert->modulus_size/8) <= 0) break; // Get Verify return int ret = EVP_DigestVerifyFinal(verify_md_ctx,signature,sig_len); if (ret == 0) { cout << "Verify digest fails" << endl; break; } else if (ret < 0) { cout << "Verify error" << endl; break; } cmd_ret = STATUS_SUCCESS; } while (0); // Free the keys and contexts if (rsa_pub_key) EVP_PKEY_free(rsa_pub_key); if (key_gen_ctx) EVP_PKEY_CTX_free(key_gen_ctx); if (verify_md_ctx) EVP_MD_CTX_free(verify_md_ctx); return cmd_ret; } Is this the correct way of creating RSA keys now? Where is my logic failing? Can the same type of procedure even be done on 3.0? Any advice would be really appreciated. Thank you in advance, Diego Gonzalez Villalobos Software System Designer I |
