プログラマ専用SNS ミクプラ

コード:

#include <openssl/rsa.h>
#include <openssl/pem.h>

#include <iostream>
#include <iomanip>
#include <string>
#include <cstring>
using namespace std;

void print(BIO* pbio)
{
  string key;
  char buff[512];
  int readbytes;

  while((readbytes = BIO_gets(pbio, buff, sizeof(buff))) > 0) {
    key.append(buff, readbytes);
  }

  cout << key << endl;
}

bool generate_rsa_key()
{
    int ret = 0;

    BIGNUM* bignum;

    RSA* rsa;
    BIO* pbio_private;
    BIO* pbio_public;

    RSA* clone;
    BIO* pbio_clone;


    // 1. generate rsa key
    //-------------------------------------------------
    bignum = BN_new();
    ret = BN_set_word(bignum, RSA_F4);
    if(ret != 1) goto finally;

    rsa = RSA_new();
    ret = RSA_generate_key_ex(rsa, 2048, bignum, NULL);
    if(ret != 1) goto finally;
    //-------------------------------------------------


    // 2. get private key
    //-------------------------------------------------
    //BIO* pbio_private = BIO_new_file("private.pem", "w+");  //output to file
    pbio_private = BIO_new(BIO_s_mem());  //output to memory
    ret = PEM_write_bio_RSAPrivateKey(pbio_private, rsa, NULL, NULL, 0, NULL, NULL);
    if(ret != 1) goto finally;
    //-------------------------------------------------
    print(pbio_private);


    // 3.1. get public key
    //-------------------------------------------------
    //BIO* pbio_public = BIO_new_file("public.pem", "w+");  //output to file
    pbio_public = BIO_new(BIO_s_mem());  //output to memory
    ret = PEM_write_bio_RSAPublicKey(pbio_public, rsa);
    if(ret != 1) goto finally;
    //-------------------------------------------------
    print(pbio_public);


    // 3.2. get public key from the clone
    //-------------------------------------------------
    clone = RSA_new();

    // n copy
    clone->n = (BIGNUM*)malloc(sizeof(BIGNUM));
    memcpy(clone->n, rsa->n, sizeof(BIGNUM));
    clone->n->d = (BN_ULONG*)malloc(sizeof(BN_ULONG) * rsa->n->dmax);
    memcpy(clone->n->d, rsa->n->d, sizeof(BN_ULONG) * rsa->n->dmax);
    // e copy
    clone->e = (BIGNUM*)malloc(sizeof(BIGNUM));
    memcpy(clone->e, rsa->e, sizeof(BIGNUM));
    clone->e->d = (BN_ULONG*)malloc(sizeof(BN_ULONG) * rsa->e->dmax);
    memcpy(clone->e->d, rsa->e->d, sizeof(BN_ULONG) * rsa->e->dmax);

    pbio_clone = BIO_new(BIO_s_mem());  //output to memory
    ret = PEM_write_bio_RSAPublicKey(pbio_clone, clone);
    if(ret != 1) goto finally;
    //-------------------------------------------------
    print(pbio_clone);


    // 4. finally
    //-------------------------------------------------
finally:
    BIO_free_all(pbio_clone);
    BIO_free_all(pbio_public);
    BIO_free_all(pbio_private);
    RSA_free(clone);
    RSA_free(rsa);
    BN_free(bignum);

    return (ret == 1);
    //-------------------------------------------------
}

int main()
{
    generate_rsa_key();
    return 0;
}