#include "KeyCode.h" #include "lib/utils/AuthToken.h" #include "lib/utils/datetime.h" #include "lib/utils/crypto/CryptoInit.h" #include "lib/utils/crypto/PrivateKey.h" #include "lib/utils/crypto/PublicKey.h" #include "lib/utils/crypto/KeyCodeHelper.h" #include "lib/logging/logging.h" #include "lib/os/os.h" #include "lib/utils/bts_assert.h" #include "lib/utils/helper_macros.h" #include "lib/config/config.h" #include "lib/config/protos/keycode.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace bts { namespace cmd { using namespace std; using namespace datetime; using namespace bts::api::auth; using namespace bts::crypto; using namespace bts::config; std::string KeyCode::helpstr () { std::ostringstream oss; oss << "\n" << "ENCODE -keyfile:[keyfile] -pass:password -users: -expiration:<2020-05-18> [-ip:] [-port:] [-allow_concurrent]\n " << "DECODE -keyfile:[keyfile] -pass:password -source:[file] \n " << "KEYGEN -keyfile:[keyfile_prefix]\n " << "CHECKIPS \n "; return oss.str(); } int checkips() { auto ipmap = bts::os::host_ips(); for(const auto& x: ipmap) std::cout << x.first << " => " << x.second << std::endl; return 0; } std::string parse_date (std::string const &date) { auto the_date = bts::datetime::parse_iso_date_time_string(date); return bts::datetime::iso_date_time_string(the_date); } void get_cmd(const std::vector& args, std::string& keyfile, std::string& pass, std::string& users, std::string& expiration, std::string* source = nullptr, std::string* ip = nullptr, std::string* port = nullptr, bool* allow_concurrent = nullptr) { for(size_t i = 1; i < args.size(); i++) { size_t pass_pos = args[i].find("-pass:"); if(pass_pos != args[i].npos) pass = args[i].substr(pass_pos+6); size_t file_pos = args[i].find("-keyfile:"); if(file_pos != args[i].npos) keyfile = args[i].substr(file_pos+9); size_t u_pos = args[i].find("-users:"); if(u_pos != args[i].npos) users = args[i].substr(u_pos+7); size_t e_pos = args[i].find("-expiration:"); if(e_pos != args[i].npos) expiration = parse_date (args[i].substr(e_pos+12)); size_t pay_pos = args[i].find("-source:"); if(source && pay_pos != args[i].npos) *source = args[i].substr(pay_pos+8); size_t i_pos = args[i].find("-ip:"); if(ip && i_pos != args[i].npos) *ip = args[i].substr(i_pos+4); size_t p_pos = args[i].find("-port:"); if(port && p_pos != args[i].npos) *port = args[i].substr(p_pos+6); size_t c_pos = args[i].find("-allow_concurrent"); if(allow_concurrent && c_pos != args[i].npos) *allow_concurrent = true; } } int keygen(const std::vector& args) { std::string keyfile, pass, users, expiration; get_cmd(args, keyfile, pass, users, expiration); if(keyfile != "") { PrivateKeyPtr priv = PrivateKey::create(2048, AlgoType::RSA); std::string n1 = (keyfile + "_private.pem"), n2 = (keyfile + "_public.pem"); //I can't get anything but DES to work here. priv->write_file(n1, CipherType::DES); priv->public_key()->write_file(n2); std::cout << "Key pair generated " << n1 << " and " << n2 << std::endl; return 0; } else { std::cout << KeyCode::helpstr(); return -1; } } // int Logon::digest(const std::vector& args) // { // std::string pass, keyfile, payload, user, expiration, extra_data; // get_cmd(args, pass, keyfile, payload, user, expiration, extra_data); // if(extra_data != "") // { // unsigned int len; // //unsigned char* digest; // //Digest::allocate_array(&digest, &len); // //Digest::compute_digest(reinterpret_cast(payload.c_str()), payload.size(), digest, &len); // std::string digest = Digest::compute_digest(extra_data); // len = digest.size(); // UNUSED(len); // std::cout << std::endl << std::endl; // //for(size_t i = 0; i < len; i++) // // printf("%02x", digest[i]); // std::cout << digest; // std::cout << std::endl << std::endl; // return 0; // } // else // { // std::cout << help(); // return -1; // } // } void write_keycode(const std::string& users, const std::string& expiration, const std::string& ip, const std::string& port, bool concurrent, bts::config::KeyCode& kc) { std::ostringstream out_stream; auto nusers = (uint32_t) std::atoi(users.c_str()); auto expir = bts::datetime::parse_iso_date_time_string(expiration); auto expir_ll = bts::datetime::ptime_to_ll(expir); auto now = bts::datetime::ll_now(); kc.set_nusers(nusers); kc.set_expiration(expir_ll); kc.set_generation_time(now); bts_assert_msg(ip != "127.0.0.1", "you can't generate a keycode for loopback, just leave the parameter blank"); kc.set_ip(ip); kc.set_port(port); kc.set_allow_concurrent(concurrent); } void eraseAllSubStr(std::string& mainStr, const std::string& toErase) { size_t pos = std::string::npos; // Search for the substring in string in a loop untill nothing is found while ((pos = mainStr.find(toErase) )!= std::string::npos) { // If found then erase it from string mainStr.erase(pos, toErase.length()); } } int encrypt(const std::string& keyfile, const std::string& pass, const std::string& users, const std::string& expiration, const std::string& ip, const std::string& port, bool concurrent) { std::string protobuf; if(keyfile == "") { std::cout << KeyCode::helpstr(); return -1; } else { std::string kc_string; std::stringstream oss, encrypted; CachedPassword cache(pass); PrivateKeyPtr key = PrivateKey::read_file(keyfile, &cache); bts::config::KeyCode kc; write_keycode(users, expiration, ip, port, concurrent, kc); if(google::protobuf::TextFormat::PrintToString(kc, &kc_string)) { oss << kc_string; key->encrypt(oss, encrypted); } else return -1; //int ret = openssl::RSA_private_encrypt(sz-1, pay, &buffer[0], key->pkey.rsa, RSA_PKCS1_PADDING); EncryptedKeyCode ekc; auto kcstr = encrypted.str(); eraseAllSubStr(kcstr,"-----BEGIN BTS-----\n"); eraseAllSubStr(kcstr, "\n-----END BTS-----\n"); kcstr.erase( std::remove(kcstr.begin(), kcstr.end(), '\n'), kcstr.end() ); //kcstr = boost::replace_all_copy(kcstr, "\n", "\\n"); ekc.set_keycode(kcstr); std::string pb; google::protobuf::TextFormat::PrintToString(ekc, &pb); std::cout << std::endl << std::endl; std::cout << "#nusers: " << users << std::endl; std::cout << "#allow concurrent : " << (kc.allow_concurrent() ? "true" : "false") << std::endl; std::cout << "#expires: " << datetime::simple_date_time_string(datetime::ll_to_ptime(kc.expiration())) << " " << std::to_string(kc.expiration()) << std::endl; std::cout << "#generation_time: " << datetime::simple_date_time_string(datetime::ll_to_ptime(kc.generation_time())) << " " << std::to_string(kc.generation_time()) << std::endl; std::cout << "EncryptedKeyCode {" << std::endl; std::cout << " value {" << std::endl; std::cout << " " << pb; std::cout << " }" << std::endl; std::cout << "}" << std::endl; std::cout << std::endl << std::endl; return 0; } } int encode(const std::vector& args) { std::string keyfile, pass, users, expiration, ip, port; bool concurrent = false; get_cmd(args, keyfile, pass, users, expiration, nullptr, &ip, &port, &concurrent); return encrypt(keyfile, pass, users, expiration, ip, port, concurrent); } int decode(const std::vector& args) { std::string keyfile, pass, users, expiration, source; get_cmd(args, keyfile, pass, users, expiration, &source); if(keyfile != "") { PublicKeyPtr pub = bts::crypto::PublicKey::read_file(keyfile); if(pub && source != "") { //KeycodePayloadHelper helper; bts::config::EncryptedKeyCode ekc; std::fstream fs(source); //google::protobuf::io::IstreamInputStream pay_stream(&fs); //google::protobuf::TextFormat::Parse(&pay_stream, &ekc); std::string str((std::istreambuf_iterator(fs)), std::istreambuf_iterator()); config::internal::initialize_for_test(str); ekc = config::get(); std::cout << std::endl << std::endl; bts::config::KeyCode kc; std::string string_out; bts::crypto::decrypt_keycode(*pub, ekc, &kc); google::protobuf::TextFormat::PrintToString(kc, &string_out); std::cout << string_out << std::endl; } //int ret = openssl::RSA_public_decrypt(sz, data, &buffer[0], key->pkey.rsa, RSA_PKCS1_PADDING); std::cout << std::endl << std::endl; return 0; } else { std::cout << KeyCode::helpstr(); return -1; } } int KeyCode::execute(const std::vector& args) { CryptoInit::initialize(); if(args.size() > 0) { if(boost::to_lower_copy(args[0]) == "keycode" || boost::to_lower_copy(args[0]) == "encode") { return encode(args); } if(boost::to_lower_copy(args[0]) == "keygen") { return keygen(args); } if(boost::to_lower_copy(args[0]) == "decode") { return decode(args); } if(boost::to_lower_copy(args[0]) == "checkips") { return checkips(); } } std::cout << help() << std::endl; return -1; } std::string KeyCode::help () { return helpstr(); } }}