#include <build_properties.h>
|
#include <private-key.h>
|
#include "license-generator.h"
|
#include "../base_lib/CryptoHelper.h"
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <iostream>
|
#include <string.h>
|
#include <iostream>
|
#include <string.h>
|
#include <boost/date_time.hpp>
|
#include <boost/program_options.hpp>
|
#include <boost/algorithm/string.hpp>
|
#include <boost/unordered_map.hpp>
|
#include <boost/assign.hpp>
|
#include <fstream>
|
#include <regex>
|
#include <boost/filesystem.hpp>
|
|
namespace fs = boost::filesystem;
|
namespace bt = boost::posix_time;
|
namespace po = boost::program_options;
|
|
using namespace std;
|
|
namespace license {
|
|
void LicenseGenerator::printHelp(const char* prog_name,
|
const po::options_description& options) {
|
cout << endl;
|
cout << prog_name << " Version " << PROJECT_VERSION << endl << ". Usage:"
|
<< endl;
|
cout << prog_name << " [options] product_name1 product_name2 ... " << endl
|
<< endl;
|
cout
|
<< " product_name1 ... = Product name. This string must match the one passed by the software."
|
<< endl;
|
cout << options << endl;
|
}
|
|
po::options_description LicenseGenerator::configureProgramOptions() {
|
po::options_description common("General options");
|
common.add_options()
|
("help,h", "print help message and exit.")
|
("verbose,v", "print more information.")
|
("output,o", po::value<string>(), "Output file name. If not specified the "
|
"license will be printed in standard output")
|
;
|
po::options_description licenseGeneration("License Generation");
|
licenseGeneration.add_options()
|
("private_key,p", po::value<string>(),
|
"Specify an alternate file for the primary key to be used. "
|
"If not specified the internal primary key will be used.")
|
("begin_date,b", po::value<string>(),
|
"Specify the start of the validity for this license. "
|
" Format YYYYMMDD. If not specified defaults to today")
|
("expire_date,e", po::value<string>(),
|
"Specify the expire date for this license. "
|
" Format YYYYMMDD. If not specified the license won't expire")
|
("client_signature,s", po::value<string>(),
|
"The signature of the pc that requires the license. "
|
"It should be in the format XXXX-XXXX-XXXX-XXXX."
|
" If not specified the license "
|
"won't be linked to a specific pc.")
|
("start_version,t", po::value<unsigned int>()->default_value(0
|
/*FullLicenseInfo.UNUSED_SOFTWARE_VERSION*/, "All Versions"),
|
"Specify the first version of the software this license apply to.")
|
("end_version,n", po::value<unsigned int>()->default_value(0
|
/*FullLicenseInfo.UNUSED_SOFTWARE_VERSION*/, "All Versions"),
|
"Specify the last version of the software this license apply to.")
|
("extra_data,x", po::value<string>(), "Specify extra data to be included into the license")
|
;
|
po::options_description visibleOptions;
|
visibleOptions.add(common).add(licenseGeneration);
|
return visibleOptions;
|
}
|
|
vector<FullLicenseInfo> LicenseGenerator::parseLicenseInfo(
|
const po::variables_map& vm) {
|
string begin_date = FullLicenseInfo::UNUSED_TIME;
|
string end_date = FullLicenseInfo::UNUSED_TIME;
|
if (vm.count("expire_date")) {
|
const std::string dt_end = vm["expire_date"].as<string>();
|
try {
|
end_date = normalize_date(dt_end);
|
char curdate[20];
|
time_t curtime = time(nullptr);
|
strftime(curdate, 20, "%Y-%m-%d", localtime(&curtime));
|
begin_date.assign(curdate);
|
} catch (const invalid_argument &e) {
|
cerr << endl << "End date not recognized: " << dt_end
|
<< " Please enter a valid date in format YYYYMMDD" << endl;
|
exit(2);
|
}
|
}
|
if (vm.count("begin_date")) {
|
const std::string begin_date_str = vm["begin_date"].as<string>();
|
try {
|
begin_date = normalize_date(begin_date_str);
|
} catch (invalid_argument &e) {
|
cerr << endl << "Begin date not recognized: " << begin_date_str
|
<< " Please enter a valid date in format YYYYMMDD" << endl;
|
//print_usage(vm);
|
exit(2);
|
}
|
}
|
string client_signature = "";
|
if (vm.count("client_signature")) {
|
client_signature = vm["client_signature"].as<string>();
|
cout << "cli sig:" << client_signature;
|
regex e("[A-Za-z0-9\\+/]{4}-[A-Za-z0-9\\+/]{4}-[A-Za-z0-9\\+/]{4}-[A-Za-z0-9\\+/]{4}");
|
cout << "\nregex:";
|
if (!regex_match(client_signature, e)) {
|
cerr << endl << "Client signature not recognized: "
|
<< client_signature
|
<< " Please enter a valid signature in format XXXX-XXXX-XXXX-XXXX"
|
<< endl;
|
exit(2);
|
}
|
}
|
string extra_data = "";
|
if (vm.count("extra_data")) {
|
extra_data = vm["extra_data"].as<string>();
|
}
|
unsigned int from_sw_version = vm["start_version"].as<unsigned int>();
|
unsigned int to_sw_version = vm["end_version"].as<unsigned int>();
|
if (vm.count("product") == 0) {
|
cerr << endl << "Parameter [product] not found. " << endl;
|
exit(2);
|
}
|
vector<string> products = vm["product"].as<vector<string>>();
|
vector<FullLicenseInfo> licInfo;
|
licInfo.reserve(products.size());
|
for (auto it = products.begin(); it != products.end(); it++) {
|
if (boost::algorithm::trim_copy(*it).length() > 0) {
|
licInfo.push_back(
|
FullLicenseInfo("", *it, "", PROJECT_INT_VERSION,
|
begin_date, end_date, client_signature,
|
from_sw_version, to_sw_version, extra_data));
|
}
|
}
|
return licInfo;
|
}
|
|
void LicenseGenerator::generateAndOutputLicenses(const po::variables_map& vm,
|
ostream& outputFile) {
|
vector<FullLicenseInfo> licenseInfo = parseLicenseInfo(vm);
|
const unique_ptr<CryptoHelper> helper = CryptoHelper::getInstance();
|
const char pkey[] = PRIVATE_KEY;
|
const size_t len = sizeof(pkey);
|
for (auto it = licenseInfo.begin(); it != licenseInfo.end(); ++it) {
|
const string license = it->printForSign();
|
const string signature = helper->signString((const void *)pkey,len,license);
|
it->license_signature = signature;
|
it->printAsIni(outputFile);
|
}
|
}
|
|
int LicenseGenerator::generateLicense(int argc, const char **argv) {
|
|
po::options_description visibleOptions = configureProgramOptions();
|
//positional options must be added to standard options
|
po::options_description allOptions;
|
allOptions.add(visibleOptions).add_options()("product",
|
po::value<vector<string>>(), "product names");
|
|
po::positional_options_description p;
|
p.add("product", -1);
|
|
po::variables_map vm;
|
po::store(
|
po::command_line_parser(argc, argv).options(allOptions).positional(
|
p).run(), vm);
|
po::notify(vm);
|
if (vm.count("help") || argc == 1) {
|
printHelp(argv[0], visibleOptions);
|
return 0;
|
}
|
|
if (vm.count("output")) {
|
const std::string fname = vm["output"].as<string>();
|
|
fstream ofstream(fname, std::ios::out | std::ios::app);
|
if (!ofstream.is_open()) {
|
cerr << "can't open file [" << fname << "] for output." << endl
|
<< " error: " << strerror( errno);
|
exit(3);
|
}
|
generateAndOutputLicenses(vm, ofstream);
|
ofstream.close();
|
} else {
|
generateAndOutputLicenses(vm, cout);
|
}
|
return 0;
|
}
|
|
const std::string formats[] = { "%4u-%2u-%2u", "%4u/%2u/%2u", "%4u%2u%2u" };
|
const size_t formats_n = 3;
|
|
string LicenseGenerator::normalize_date(const std::string& sDate) {
|
if(sDate.size()<8)
|
throw invalid_argument("Date string too small for known formats");
|
unsigned int year, month, day;
|
bool found = false;
|
for (size_t i = 0; i < formats_n && !found; ++i) {
|
const int chread = sscanf(sDate.c_str(),formats[i].c_str(),&year,&month,&day);
|
if(chread==3) {
|
found = true;
|
break;
|
}
|
}
|
if(!found)
|
throw invalid_argument("Date string did not match a known format");
|
ostringstream oss;
|
oss << year << "-" << setfill('0') << std::setw(2) << month << "-" << setfill('0') << std::setw(2) << day;
|
return oss.str();
|
}
|
}
|
