Is it normal that public key generated from private key are different each time?

I have a C source code that generate a 2048 bit RSA key (it's working, no problem with it) :

int main(void)
{
    RSA *lptypRSA = NULL;
    BIGNUM *lptypBIGNUM = NULL;
    BIO *lptypBIOPublic = NULL;
    BIO *lptypBIOPrivate = NULL;

    lptypBIGNUM = BN_new();
    if (lptypBIGNUM == NULL) {
       exit(1);
    }

    if (BN_set_word(lptypBIGNUM, RSA_F4) != 1) {
       exit(2);
    }

    lptypRSA = RSA_new();
    if (lptypRSA == NULL) {
       exit(3);
    }
    
    if (RSA_generate_key_ex(lptypRSA, 2048, lptypBIGNUM, NULL) != 1) {
       exit(4);
    }

    /* Public key generation */
    lptypBIOPublic = BIO_new_file("/some/path/rsa_2048_public.key", "w");
    if (lptypBIOPublic == NULL) {
       exit(5);
    }
    
    if (PEM_write_bio_RSAPublicKey(lptypBIOPublic, lptypRSA) != 1) {
       exit(6);
    }

    /* Private key generation */
    lptypBIOPrivate = BIO_new_file("/some/path/rsa_2048_private.key", "w");
    if (lptypBIOPrivate == NULL) {
       exit(7);
    }
    
    if (PEM_write_bio_RSAPrivateKey(lptypBIOPrivate, lptypRSA, NULL, NULL, 0, NULL, NULL) != 1) {
       exit(8);
    }

    /* Free ressource */
    BIO_free_all(lptypBIOPrivate);
    BIO_free_all(lptypBIOPublic);
    BN_free(lptypBIGNUM);
    RSA_free(lptypRSA);

    exit(0);
}

(My libcrypto version is old (aix5.3) that's why I'm not using EVP_RSA_gen/PEM_write_PUBKEY/PEM_write_PrivateKey). I do a test and end up having those two files :

"/some/path/rsa_2048_private.key" :

"/some/path/rsa_2048_public.key"

Now, I want to test if I can get the public key from the private key if the public key is lost, so I use this shell command :

openssl rsa -in "/some/path/rsa_2048_private.key" -out "/some/path/rsa_2048_public.key" -pubout

I obtain this :

What surprise me is that the file content is different, but I still can decrypting with the new public key data that have been encrypted with the original (and now lost) public key.

I don't fully understand how RSA work (I'm not that good with math), but I read that one private key can only have one public key. Yet, I have what appear to be two different public key working with one private key.

Is it normal to not get the exact public key ? ~~If I redo the shell command, I end up with a third public key different from the two first yet still working.~~ I did my test wrong : If I redo a third public file with the shell command, it end up different from the first (generated via C code) but identical to the second (generated via shell)

Solution

PEM_write_bio_RSAPublicKey() writes the key in PKCS#1 format:

-----BEGIN RSA PUBLIC KEY-----

This contains just the modulus (n) and exponent (e);

openssl rsa -pubout or PEM_write_bio_PUBKEY() writes the key in X.509 SubjectPublicKeyInfo format:

-----BEGIN PUBLIC KEY-----

This wraps the PKCS#1 blob inside an ASN.1 structure that also includes info about the key algorithm (here, RSA). The base64 blobs differ because their ASN.1 structures differ, but they both contain the same modulus and exponent values. If you decode both, you'll find the same n and e inside.