#include <paths.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <cstring>
|
#include <string>
|
#include <system_error>
|
#include <unistd.h>
|
#include <sstream>
|
#include <sys/ioctl.h>
|
#include <sys/stat.h>
|
#include "../os.hpp"
|
#include "../../base/public-key.h"
|
#include <openssl/evp.h>
|
#include <openssl/bio.h>
|
#include <openssl/pem.h>
|
#include <openssl/err.h>
|
#include <iostream>
|
namespace license {
|
|
using namespace std;
|
|
vector<AdapterInfo> OsFunctions::getAdapterInfos() {
|
return vector<AdapterInfo>();
|
}
|
vector<DiskInfo> OsFunctions::getDiskInfos() {
|
struct stat filename_stat, mount_stat;
|
static char discard[1024];
|
char device[64], name[64], type[64];
|
FILE *mounts = fopen(_PATH_MOUNTED, "r");
|
|
while (fscanf(mounts, "%64s %64s %64s %1024[^\n]", device, name, type,
|
discard) != EOF) {
|
if (stat(device, &mount_stat) != 0)
|
continue;
|
if (filename_stat.st_dev == mount_stat.st_rdev)
|
fprintf(stderr, "device: %s; name: %s; type: %s\n", device, name,
|
type);
|
}
|
|
return vector<DiskInfo>();
|
}
|
|
string OsFunctions::getModuleName() {
|
char path[2048] = { 0 };
|
string strPath;
|
string result;
|
pid_t pid = getpid();
|
const string pidstr = to_string(((long) pid));
|
strPath = string("/proc/") + pidstr + "/exe";
|
const char * proc_path = strPath.c_str();
|
int ch = readlink(proc_path, path, 2048);
|
if (ch != -1) {
|
path[ch] = '\0';
|
result = string(path);
|
} else {
|
throw runtime_error(
|
string("Can't find: ") + strPath + " proc filesystem mounted?");
|
}
|
return result;
|
}
|
|
string OsFunctions::getUserHomePath() {
|
return "";
|
}
|
|
bool OsFunctions::verifySignature(const char* stringToVerify,
|
const char* signatureB64) {
|
EVP_MD_CTX *mdctx = NULL;
|
|
char *pubKey = PUBLIC_KEY
|
;
|
|
BIO* bio = BIO_new_mem_buf((void*) (pubKey), strlen(pubKey));
|
RSA *rsa = PEM_read_bio_RSAPublicKey(bio, NULL, NULL, NULL);
|
BIO_free(bio);
|
if (rsa == NULL) {
|
cout<<"cippa!"<<endl;
|
throw new logic_error("Error reading public key");
|
}
|
EVP_PKEY *pkey = EVP_PKEY_new();
|
|
cout << "test:" <<EVP_PKEY_assign_RSA(pkey, rsa)<<endl;
|
|
/*BIO* bo = BIO_new(BIO_s_mem());
|
BIO_write(bo, pubKey, strlen(pubKey));
|
RSA *key = 0;
|
PEM_read_bio_RSAPublicKey(bo, &key, 0, 0);
|
BIO_free(bo);*/
|
|
//RSA* rsa = EVP_PKEY_get1_RSA( key );
|
//RSA * pubKey = d2i_RSA_PUBKEY(NULL, <der encoded byte stream pointer>, <num bytes>);
|
unsigned char buffer[129];
|
BIO* b64 = BIO_new(BIO_f_base64());
|
BIO* encoded_signature = BIO_new_mem_buf((void *) signatureB64,
|
strlen(signatureB64));
|
BIO* biosig = BIO_push(b64, encoded_signature);
|
BIO_set_flags(biosig, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer
|
unsigned int len = BIO_read(biosig, (void *) buffer, strlen(signatureB64));
|
//Can test here if len == decodeLen - if not, then return an error
|
buffer[len] = 0;
|
|
BIO_free_all(biosig);
|
|
/* Create the Message Digest Context */
|
if (!(mdctx = EVP_MD_CTX_create())) {
|
throw new logic_error("Error creating context");
|
}
|
if (1 != EVP_DigestVerifyInit(mdctx, NULL, EVP_sha256(), NULL, pkey)) {
|
throw new logic_error("Error initializing digest");
|
}
|
int en=strlen(stringToVerify);
|
if (1
|
!= EVP_DigestVerifyUpdate(mdctx, stringToVerify,
|
en)) {
|
throw new logic_error("Error initializing digest");
|
}
|
bool result;
|
int res= EVP_DigestVerifyFinal(mdctx, buffer, len);
|
if (1 == res) {
|
result = true;
|
} else {
|
result = false;
|
}
|
if (pkey) {
|
EVP_PKEY_free(pkey);
|
}
|
if (mdctx) {
|
EVP_MD_CTX_destroy(mdctx);
|
}
|
return result;
|
}
|
|
void OsFunctions::initialize() {
|
static bool initialized = false;
|
if (!initialized) {
|
initialized = true;
|
ERR_load_ERR_strings();
|
ERR_load_crypto_strings();
|
OpenSSL_add_all_algorithms();
|
}
|
}
|
|
VIRTUALIZATION OsFunctions::getVirtualization() {
|
//http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
|
//
|
bool rc = true;
|
/*__asm__ (
|
"push %edx\n"
|
"push %ecx\n"
|
"push %ebx\n"
|
"mov %eax, 'VMXh'\n"
|
"mov %ebx, 0\n" // any value but not the MAGIC VALUE
|
"mov %ecx, 10\n"// get VMWare version
|
"mov %edx, 'VX'\n"// port number
|
"in %eax, dx\n"// read port on return EAX returns the VERSION
|
"cmp %ebx, 'VMXh'\n"// is it a reply from VMWare?
|
"setz [rc] \n"// set return value
|
"pop %ebx \n"
|
"pop %ecx \n"
|
"pop %edx \n"
|
);*/
|
|
return NONE;
|
}
|
|
}
|
