PEM_read_bio_PUBKEY returns nullptr - c++

Question

I'll include my full code below as well as a sample run. In short, this is failing:
EVP_PKEY * pk = PEM_read_bio_PUBKEY(bioReadPublic, nullptr, nullptr, nullptr);
If I cut & paste a public key from examples found on the internet, it works. So I think the error has to do with how I'm producing the keys. But I can use the private key just fine (or at least I think I can).
When I cout them, both the public and private keys look okay.
Does anyone see what I'm doing wrong?
The code here, and a sample run to follow.
#include <iostream>
#include <iostream>
#include <openssl/bio.h>
#include <openssl/pem.h>
using std::cout;
using std::cerr;
using std::endl;
using std::string;
int main()
{
::RSA * rsa = nullptr;
::BIGNUM * bne = nullptr;
::BIO * bioPrivate = nullptr;
::BIO * bioPublic = nullptr;
::BIO * bioReadPublic = nullptr;
::BIO * bioReadPrivate = nullptr;
::RSA * privateRSA = nullptr;
::RSA * publicRSA = nullptr;
int bits = 2048;
try {
// This code produces the public/private keys.
rsa = RSA_new();
bne = BN_new();
BN_set_word(bne, RSA_F4);
RSA_generate_key_ex(rsa, bits, bne, NULL);
bioPrivate = BIO_new( BIO_s_mem() );
bioPublic = BIO_new( BIO_s_mem() );
PEM_write_bio_RSAPrivateKey( bioPrivate, rsa, nullptr, nullptr, 0, nullptr, nullptr );
PEM_write_bio_RSAPublicKey( bioPublic, rsa );
size_t privateLen = BIO_pending( bioPrivate );
size_t publicLen = BIO_pending( bioPublic );
// Oversized.
char privateBuffer[10000];
char publicBuffer[10000];
BIO_read(bioPrivate, privateBuffer, privateLen);
BIO_read(bioPublic, publicBuffer, publicLen);
privateBuffer[privateLen] = 0;
publicBuffer[publicLen] = 0;
string privateKey = privateBuffer;
string publicKey = publicBuffer;
cout << "Keys:\n"
<< privateKey << endl << endl
<< publicKey << endl << endl;
// And this is where I try to use them.
cout << "Try PEM_read\n";
bioReadPrivate = BIO_new_mem_buf( (void *)privateBuffer, privateLen );
bioReadPublic = BIO_new_mem_buf( (void *)publicBuffer, publicLen );
cout << "The private...\n";
privateRSA = PEM_read_bio_RSAPrivateKey(bioReadPrivate, nullptr, nullptr, nullptr);
if (privateRSA == nullptr) {
cout << "Failed to read private key\n";
}
cout << "The public...\n";
publicRSA = PEM_read_bio_RSAPublicKey(bioReadPublic, nullptr, nullptr, nullptr);
if (publicRSA == nullptr) {
cout << "Failed to read public key\n";
}
EVP_PKEY * pk = PEM_read_bio_PUBKEY(bioReadPublic, nullptr, nullptr, nullptr);
if (pk == nullptr) {
cout << "PEM_read_bio_PUBKEY failed\n";
}
}
catch (const std::exception &e) {
cerr << "Exception: " << e.what() << endl;
}
cout << "Done.\n";
if (privateRSA != nullptr) {
RSA_free(privateRSA);
}
if (publicRSA != nullptr) {
RSA_free(publicRSA);
}
if (bioReadPrivate != nullptr) {
BIO_free(bioReadPrivate);
}
if (bioReadPublic != nullptr) {
BIO_free(bioReadPublic);
}
if (bioPublic != nullptr) {
BIO_free(bioPublic);
}
if (bioPrivate != nullptr) {
BIO_free(bioPrivate);
}
if (bne != nullptr) {
BN_free(bne);
}
if (rsa != nullptr) {
RSA_free(rsa);
}
return 0;
}
Running it produces this output:
Keys:
-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEArqd1UmR+VYPByNJujunS5FhlkSgsuxiSTjWJCdNoUkdIcKxJ
6ZvNV6uQAkJdL3RgHBRmhrb2CBTkkYdJoB0HyY58AgTH25eJpW7aRmHMh6exzrSv
47MkKVuHVfLNw/RjA3cTDMMgg5SHg4bS8O9lXa9A3YIAUtTb3f4xhuYX8ZG64SzB
lhCruCRKubb1N7eSuqLpq8DJqMj842PEwEU5HfQhxWHU4KAK43Wkglq6BjkKYULR
0/cUm8hMK5WE63LJ0mSsU4sD9UdzpbPD1WO+KBPLX6C0O/z6fGmEIwEyjNmXomUE
tqOBhW+1tEvF9T/l5UF/a+RyQs4uPjqsuiBfrQIDAQABAoIBAH6FqSQK0Mo6LIPC
jXzSPohU0R8ar2zKHBK0DZYkpAoWwY99//1PdK3yBtzcHo1mDMnKrYsht5GbMQmL
q/ZlkWKd6Y+8zttxJ7HEYDNkXbpX7SMFGfYlrCiZuay1vAIcZC36cL5qDH/FdXX+
kYkgo5n+f0r4Biv7L1vd7RsATJAeAla8wz+SQ5TVyONMQ4KYvQFk4GrIOtkdvVjW
B+EMxNPRFdLBpGL0cAwwEMS71H30R+NqOogRWpok/gE4LTe3tohoNMr9UvRrQucG
xLLUMLlQFe+t2iys1oRLRbIsPbp8+Jb0LkPnEuz+rG86nyg5UnTyI2KSkW5GO2sP
1l+xUDECgYEA55JVMSOeQWFBfh1MySbOsbceGT/0ZPmrOEj0n2Sab59iJv/9B/W0
SlZ+nmZzDq7Zxkefaaq2+1uaqHzPstqJUPAuCvJV4dJ1dMX3gAhVxMiIyPR4KywZ
Wq22r7hWOggwQ8nt7YLhbXX0NG9MepHUpbYniGBH04y/Ff4kV/yMkKcCgYEAwRQM
5KZa2GNjcqRH+G+/DyjSml8cyv/HyA/bp5hsRUZJdNnuHK0Dl07IED31d3r023Mz
vBgwqZ0DNnfNvqebrtkeQE2MBgXBU5r8lZ/Xc1uzC5ClYxvjAMvR/GW9XpatqvZa
+tw/DeQ08htwc/yvKAlJwnp3AQRmDQyVwG+hI4sCgYAc7MBLZQGNdRJzKEHBFmHW
/OJ7kOt7+VuTqjkz96L6slPWPz9h0ST17BvguTdB7EEzbRrSXgqBFw4YYY6n7ngc
bgOyRlbH4DvfnCKwEVp1O/8p6q9f5SA9nVkmVcYfdYphzUU015ZEz+jy67wHy1Ne
Z4REmpIeMIRlwNrVSqxcHQKBgF3DMOew6Zj/2wGHSfQZwDzKZEvXOJJUWF6NZOwk
lx+lHHMEih+e3YmTFpDcpeHZ8iLH9S24yZj0yOSglWeq2W21vn0Xq5IZJWNGdrbq
oqRAudg57DcPCdQPJvBdL/NJVRka/d+pKW3Djvqr3JZW9XCJ4inxcu0ph616mRaU
nzo1AoGAbSMgdhMRq1x78LhI4zHklyonA55T5eO3Tk+tyXF513e9LmVTgVg6sCsj
pU+4/gMHa3oDn+LU1LsxuJU+xn/zHVFTjIYaw8+dLzHv7mVz3DpdeAVud3BRuHNu
kj7X7ZsRRCtGv8762B5YOdbAlXStc6i2JHLyWI1n7s324hm1f3c=
-----END RSA PRIVATE KEY-----
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEArqd1UmR+VYPByNJujunS5FhlkSgsuxiSTjWJCdNoUkdIcKxJ6ZvN
V6uQAkJdL3RgHBRmhrb2CBTkkYdJoB0HyY58AgTH25eJpW7aRmHMh6exzrSv47Mk
KVuHVfLNw/RjA3cTDMMgg5SHg4bS8O9lXa9A3YIAUtTb3f4xhuYX8ZG64SzBlhCr
uCRKubb1N7eSuqLpq8DJqMj842PEwEU5HfQhxWHU4KAK43Wkglq6BjkKYULR0/cU
m8hMK5WE63LJ0mSsU4sD9UdzpbPD1WO+KBPLX6C0O/z6fGmEIwEyjNmXomUEtqOB
hW+1tEvF9T/l5UF/a+RyQs4uPjqsuiBfrQIDAQAB
-----END RSA PUBLIC KEY-----
Try PEM_read
The private...
The public...
PEM_read_bio_PUBKEY failed
Done.

Answer 1

Okay, this came down to one line of code.
The underlying JWT library I'm using does this:
EVP_PKEY * pk = PEM_read_bio_PUBKEY(bioReadPublic, nullptr, nullptr, nullptr);
Which means my public key needs to be compatible with doing that. So instead of using PEM_write_bio_RSAPublicKey, I have to use PEM_write_bio_RSA_PUBKEY like this:
PEM_write_bio_RSA_PUBKEY( bioPublic, rsa );
The resulting data is very slightly different. The public key looks like this:
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoMeN556vV68LEAQ1KE22
n6fHTCsVV1CwKMo8L6WvCMD13xNs72MwA+FNNOZUTg2+2HvaH7ZnwNgLPeY/O+Rc
vTBLI90qGxAubGYnvp+76hNROzXQfLFlTQdGiu2vF0oiCU00EDKM4xzL8iOf7H8A
aw9f6S0Y9UiaZAMJ0CLXwv6yWLvxHgNGiJ1Z3VGrUnW16K9EGyoNMYARPiJqSMaG
Grw26SUBzA485zzZfiIgnruriuiBQPp9dL5vvGAvRFODCcj45Jqpo25hTSADQTw3
kUUQ5WRRy2Din1VAEWJflCUMAf+VowODoglZP5YOSkf8lsBlVpekroWNFVaQehs3
MwIDAQAB
-----END PUBLIC KEY-----
If you go back to my original post, you'll see the format is just slightly different. BEGIN RSA PUBLIC KEY vs BEGIN PUBLIC KEY. I don't know if there are more differences, because of course every time I run it, it generates new keys, and I haven't looked further.