Extracting the encoded public key from RSA key pair in openssl 3

Using the following code I am trying to generate a pair of RSA key and then trying to extract the public key. Based on the output the key generation process is successful.
Although calling the EVP_PKEY_get1_encoded_public_key based on the openssl man page
<https://www.openssl.org/docs/man3.0/man3/EVP_PKEY_get1_encoded_public_key.html>
seems to be correct But the function always fails to extract the public key. Can any one point it out where I am making mistake.

#include <openssl/bn.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <stdio.h>

void print_hex(const char *label, const unsigned char *data, size_t length) {
  printf("%s:\n", label);
  for (size_t i = 0; i < length; ++i) {
    printf("%02X", data[i]);
  }
  printf("\n");
}

int main() {

  // Generate RSA key pair
  EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
  if (!ctx) {
    printf("Failed to create EVP_PKEY_CTX.\n");
    return 1;
  }

  if (EVP_PKEY_keygen_init(ctx) <= 0) {
    printf("Failed to initialize EVP_PKEY_CTX.\n");
    return 1;
  }

  if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0) {
    printf("Failed to set RSA key size.\n");
    return 1;
  }

  EVP_PKEY *keypair = NULL;
  if (EVP_PKEY_keygen(ctx, &keypair) <= 0) {
    printf("Failed to generate RSA key pair.\n");
    return 1;
  }

  // Extract RSA public key modulus
  unsigned char *pubkey;
  size_t pubkey_len;

  pubkey_len = EVP_PKEY_get1_encoded_public_key(keypair, &pubkey);

  if (pubkey_len == 0) {
    printf("Failed to get encoded public key length.\n");
    EVP_PKEY_CTX_free(ctx);
    EVP_PKEY_free(keypair);
    return 1;
  }

  // Print the raw key component
  print_hex("Encoded Public Key", pubkey, pubkey_len);

  // Cleanup
  free(pubkey);
  EVP_PKEY_CTX_free(ctx);
  EVP_PKEY_free(keypair);

  return 0;
}

From the man page: "this currently only works for [algorithms] that support key exchange" by which it apparently actually means key agreeement, namely (FF)DH EC(DH) XDH. RSA does not support key agreement and thus not this API.

To get the RSA public key in "SPKI" encoding (often called X.509 although that's actually ambiguous, and the default for most OpenSSL commandline operations that use a publickey object, as well as a lot of things built on, derived from, or designed to be compatible with OpenSSL, and also used by Java crypto) use i2d_PUBKEY and for
the simpler but rarely used PKCS1 encoding use i2d_PublicKey, something like:

#if SPKI
  pubkey_len = i2d_PUBKEY (keypair, NULL);
  pubkey = malloc(pubkey_len); unsigned char *ptr = pubkey;
  i2d_PUBKEY (keypair, &ptr);
#else
  pubkey_len = i2d_PublicKey (keypair, NULL);
  pubkey = malloc(pubkey_len); unsigned char *ptr = pubkey;
  i2d_PublicKey (keypair, &ptr);
#endif

Although ASN.1 (DER) encodings can vary in length a little, it is possible to predict the size of these encodings within a few bytes just from knowing the key 'size' in bits which you hardcoded, so instead of dynamic allocation you can just declare say unsigned char pubkey [256+16] for PKCS1 or [256+48] for SPKI. I didn't bother.

But in either case your comment 'Extract the RSA modulus' is wrong; the publickey does not consist solely of the modulus but at minimum the modulus and public exponent. The PKCS1 form is actually just those two values in ASN.1 as a SEQUENCE of two INTEGERs; the SPKI form adds an 'AlgorithmIdentifier' which for this case (classic RSA) is only a little more than an ASN.1 Object Identifier (OID) specifying that it is RSA, plus an OCTETSTRING wrapping around the PKCS1 encoding, in a second SEQUENCE.

And, although you didn't ask, these encoding routines (and similar decoding routines for input) were the same on all OpenSSL versions back to 0.9.early, although the keypair generation API was different before 1.0.0.