/*
|
* LicenseSigner.cpp
|
*
|
* Created on: Apr 6, 2014
|
* Author: devel
|
*/
|
|
#include "LicenseSigner.h"
|
#include "private-key.h"
|
#include <stdexcept>
|
#include <string.h>
|
#include <openssl/evp.h>
|
#include <openssl/bio.h>
|
#include <openssl/pem.h>
|
#include <openssl/err.h>
|
#include <iostream>
|
#include <cmath>
|
|
namespace license {
|
using namespace std;
|
|
LicenseSigner::LicenseSigner() {
|
|
}
|
|
LicenseSigner::LicenseSigner(const std::string& alternatePrimaryKey) {
|
}
|
|
string LicenseSigner::Opensslb64Encode(size_t slen, unsigned char* signature) {
|
/*
|
FILE* stream = fmemopen(*buffer, encodedSize+1, "w");
|
*/
|
//bio = BIO_new_fp(stdout, BIO_NOCLOSE);
|
/*int encodedSize = 4 * ceil(slen / 3);
|
char* buffer = (char*) (malloc(encodedSize + 1));
|
memset(buffer,0,encodedSize+1);*/
|
BIO* mem_bio = BIO_new(BIO_s_mem());
|
BIO* b64 = BIO_new(BIO_f_base64());
|
BIO* bio1 = BIO_push(b64, mem_bio);
|
BIO_set_flags(bio1, BIO_FLAGS_BASE64_NO_NL);
|
BIO_write(bio1, signature, slen);
|
BIO_flush(bio1);
|
char* charBuf;
|
int sz = BIO_get_mem_data(mem_bio, &charBuf);
|
string signatureStr;
|
signatureStr.assign(charBuf, sz);
|
BIO_free_all(bio1);
|
return signatureStr;
|
}
|
|
string LicenseSigner::signString(const string& license) {
|
ERR_load_ERR_strings();
|
ERR_load_crypto_strings();
|
OpenSSL_add_all_algorithms();
|
size_t slen;
|
unsigned char* signature;
|
signature = NULL;
|
/* Create the Message Digest Context */
|
EVP_MD_CTX* mdctx = EVP_MD_CTX_create();
|
if (!mdctx) {
|
throw logic_error("Message digest creation context");
|
}
|
const char *private_key = PRIVATE_KEY;
|
BIO* bio = BIO_new_mem_buf((void*) (private_key), strlen(private_key));
|
EVP_PKEY *pktmp = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL);
|
BIO_free(bio);
|
/*Initialise the DigestSign operation - SHA-256 has been selected
|
* as the message digest function in this example */
|
if (1 != EVP_DigestSignInit(mdctx, NULL, EVP_sha256(), NULL, pktmp)) {
|
EVP_MD_CTX_destroy(mdctx);
|
}
|
/* Call update with the message */
|
if (EVP_DigestSignUpdate(mdctx, license.c_str(), license.length()) != 1) {
|
EVP_MD_CTX_destroy(mdctx);
|
throw logic_error("Message signing exception");
|
}
|
/* Finalise the DigestSign operation */
|
/* First call EVP_DigestSignFinal with a NULL sig parameter to obtain the length of the
|
* signature. Length is returned in slen */
|
if (EVP_DigestSignFinal(mdctx, NULL, &slen) != 1) {
|
EVP_MD_CTX_destroy(mdctx);
|
throw logic_error("Message signature finalization exception");
|
}
|
/* Allocate memory for the signature based on size in slen */
|
if (!(signature = (unsigned char *) OPENSSL_malloc(
|
sizeof(unsigned char) * slen))) {
|
EVP_MD_CTX_destroy(mdctx);
|
throw logic_error("Message signature memory allocation exception");
|
}
|
/* Obtain the signature */
|
if (1 != EVP_DigestSignFinal(mdctx, signature, &slen)) {
|
OPENSSL_free(signature);
|
EVP_MD_CTX_destroy(mdctx);
|
throw logic_error("Message signature exception");
|
}
|
/*
|
FILE* stream = fmemopen(*buffer, encodedSize+1, "w");
|
*/
|
//bio = BIO_new_fp(stdout, BIO_NOCLOSE);
|
/*int encodedSize = 4 * ceil(slen / 3);
|
char* buffer = (char*) (malloc(encodedSize + 1));
|
memset(buffer,0,encodedSize+1);*/
|
string signatureStr = Opensslb64Encode(slen, signature);
|
/*
|
* BIO *bio, *b64;
|
char message[] = "Hello World \n";
|
b64 = BIO_new(BIO_f_base64());
|
bio = BIO_new_fp(stdout, BIO_NOCLOSE);
|
bio = BIO_push(b64, bio);
|
BIO_write(bio, message, strlen(message));
|
BIO_flush(bio);
|
BIO_free_all(bio);
|
Read Base64 encoded data from standard input and write the decoded data to standard output:
|
|
BIO *bio, *b64, *bio_out;
|
char inbuf[512];
|
int inlen;
|
b64 = BIO_new(BIO_f_base64());
|
bio = BIO_new_fp(stdin, BIO_NOCLOSE);
|
bio_out = BIO_new_fp(stdout, BIO_NOCLOSE);
|
bio = BIO_push(b64, bio);
|
while((inlen = BIO_read(bio, inbuf, 512)) > 0)
|
BIO_write(bio_out, inbuf, inlen);
|
BIO_free_all(bio);
|
*/
|
/* Clean up */
|
//free(buffer);
|
if (signature)
|
OPENSSL_free(signature);
|
|
if (mdctx)
|
EVP_MD_CTX_destroy(mdctx);
|
return signatureStr;
|
}
|
|
void LicenseSigner::signLicense(FullLicenseInfo& licenseInfo) {
|
string license = licenseInfo.printForSign();
|
string signature = signString(license);
|
licenseInfo.license_signature = signature;
|
}
|
|
LicenseSigner::~LicenseSigner() {
|
|
}
|
|
} /* namespace license */
|
