refactor to fix MINGW consistency

Maximilien Siavelis

2018-01-06 ec3965cbc675c4546185caa847cb83191e1a3fcb

refactor to fix MINGW consistency

 src/library/CMakeLists.txt

@@ -1,10 +1,6 @@
IF(WIN32)
    add_subdirectory("os/win")
ELSE(WIN32)
    add_subdirectory("os/linux")    
ENDIF(WIN32)
add_subdirectory("base") 
add_subdirectory("ini")   
add_subdirectory("os")
add_subdirectory("base")
add_subdirectory("ini")

ADD_LIBRARY(license++_static STATIC
    license++.cpp

 src/library/os/CMakeLists.txt

New file
@@ -0,0 +1,18 @@
IF(WIN32)
    ADD_LIBRARY(os STATIC
        os.c
        os-win.c)
ELSE(WIN32)
    ADD_LIBRARY(os STATIC
        os.c
        os-linux.c
        network_id.c)
ENDIF(WIN32)

target_link_libraries(
     os
     base
     ${EXTERNAL_LIBS}
)

install(TARGETS os ARCHIVE DESTINATION lib)

 src/library/os/linux/CMakeLists.txt

File was deleted

 src/library/os/network_id.c

File was renamed from src/library/os/linux/network_id.c
@@ -25,7 +25,7 @@
#include <string.h>
#include <stdio.h>

#include "../os.h"
#include "os.h"

/**
 *

 src/library/os/os-linux.c

File was renamed from src/library/os/linux/os-linux.c
@@ -1,29 +1,15 @@
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>

#include <valgrind/memcheck.h>
#include <paths.h>

#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include "../os.h"
#include "public-key.h"
#include "../../base/logger.h"
#include "os.h"
#include "../base/logger.h"

#include <openssl/evp.h>
#include <openssl/bio.h>
//#include <openssl/evp.h>
//#include <openssl/bio.h>
#include <openssl/pem.h>
#include <openssl/err.h>

#include <mntent.h>
#include <dirent.h>
#include <stdio.h>

#include <sys/utsname.h>
#ifdef USE_DBUS
@@ -310,79 +296,5 @@
    } else {
        result = FUNC_RET_ERROR;
    }
    return result;
}

static void free_resources(EVP_PKEY* pkey, EVP_MD_CTX* mdctx) {
    if (pkey) {
        EVP_PKEY_free(pkey);
    }
    if (mdctx) {
        EVP_MD_CTX_destroy(mdctx);
    }
}

FUNCTION_RETURN verifySignature(const char* stringToVerify,
        const char* signatureB64) {
    EVP_MD_CTX *mdctx = NULL;
    const char *pubKey = PUBLIC_KEY;
    int func_ret = 0;

    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) {
        LOG_ERROR("Error reading public key");
        return FUNC_RET_ERROR;
    }
    EVP_PKEY *pkey = EVP_PKEY_new();
    EVP_PKEY_assign_RSA(pkey, rsa);

    /*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[512];
    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())) {
        free_resources(pkey, mdctx);
        LOG_ERROR("Error creating context");
        return FUNC_RET_ERROR;
    }
    if (1 != EVP_DigestVerifyInit(mdctx, NULL, EVP_sha256(), NULL, pkey)) {
        LOG_ERROR("Error initializing digest");
        free_resources(pkey, mdctx);
        return FUNC_RET_ERROR;
    }
    int en = strlen(stringToVerify);
    func_ret = EVP_DigestVerifyUpdate(mdctx, stringToVerify, en);
    if (1 != func_ret) {
        LOG_ERROR("Error verifying digest %d", func_ret);
        free_resources(pkey, mdctx);
        return FUNC_RET_ERROR;
    }
    FUNCTION_RETURN result;
    func_ret = EVP_DigestVerifyFinal(mdctx, buffer, len);
    if (1 != func_ret) {
        LOG_ERROR("Error verifying digest %d", func_ret);
    }
    result = (1 == func_ret ? FUNC_RET_OK : FUNC_RET_ERROR);

    free_resources(pkey, mdctx);
    return result;
}

 src/library/os/os-win.c

File was renamed from src/library/os/win/os-win.c
@@ -1,18 +1,11 @@
#ifdef __MINGW32__

#include <windows.h>

#else

#ifdef _MSC_VER

#include <Windows.h>

#endif

#include <iphlpapi.h>

//definition of size_t

#include <stdlib.h>

#include <stdio.h>

//#include "../../base/base64.h"

#include "../../base/logger.h"

#include"../os.h"

#include "public-key.h"



#include "../base/logger.h"

#include "os.h"

#pragma comment(lib, "IPHLPAPI.lib")



unsigned char* unbase64(const char* ascii, int len, int *flen);



FUNCTION_RETURN getOsSpecificIdentifier(unsigned char identifier[6]) {

@@ -215,88 +208,3 @@
        free(hashStr);

    }

}



FUNCTION_RETURN verifySignature(const char* stringToVerify,

        const char* signatureB64) {

    //--------------------------------------------------------------------

    // Declare variables.

    //

    // hProv:           Cryptographic service provider (CSP). This example

    //                  uses the Microsoft Enhanced Cryptographic 
    //                  Provider.

    // hKey:            Key to be used. In this example, you import the 
    //                  key as a PLAINTEXTKEYBLOB.

    // dwBlobLen:       Length of the plaintext key.

    // pbKeyBlob:       Pointer to the exported key.

    BYTE pubKey[] = PUBLIC_KEY;



    HCRYPTPROV hProv = 0;

    HCRYPTKEY hKey = 0;

    HCRYPTHASH hHash = 0;

    DWORD dwSigLen;

    BYTE* sigBlob;



    //--------------------------------------------------------------------

    // Acquire a handle to the CSP.



    if (!CryptAcquireContext(&hProv,

    NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {

        // If the key container cannot be opened, try creating a new

        // container by specifying a container name and setting the 
        // CRYPT_NEWKEYSET flag.

        LOG_INFO("Error in AcquireContext 0x%08x \n", GetLastError());

        if (NTE_BAD_KEYSET == GetLastError()) {

            if (!CryptAcquireContext(&hProv, "license++verify",

                    MS_ENHANCED_PROV, PROV_RSA_FULL,

                    CRYPT_NEWKEYSET | CRYPT_VERIFYCONTEXT)) {

                LOG_ERROR("Error in AcquireContext 0x%08x \n", GetLastError());

                return FUNC_RET_ERROR;

            }

        } else {

            LOG_ERROR(" Error in AcquireContext 0x%08x \n", GetLastError());

            return FUNC_RET_ERROR;

        }

    }



    // Use the CryptImportKey function to import the PLAINTEXTKEYBLOB

    // BYTE array into the key container. The function returns a 
    // pointer to an HCRYPTKEY variable that contains the handle of

    // the imported key.

    if (!CryptImportKey(hProv, &pubKey[0], sizeof(pubKey), 0, 0, &hKey)) {

        LOG_ERROR("Error 0x%08x in importing the PublicKey \n", GetLastError());

        return FUNC_RET_ERROR;

    }



    if (CryptCreateHash(hProv, CALG_SHA1, 0, 0, &hHash)) {

        LOG_DEBUG("Hash object created.");

    } else {

        LOG_ERROR("Error in hash creation 0x%08x ", GetLastError());

        CryptReleaseContext(hProv, 0);

        return FUNC_RET_ERROR;

    }



    if (!CryptHashData(hHash, stringToVerify, (DWORD) strlen(stringToVerify), 0)) {

        LOG_ERROR("Error in hashing data 0x%08x ", GetLastError());

        CryptDestroyHash(hHash);

        CryptReleaseContext(hProv, 0);

        return FUNC_RET_ERROR;

    }

#ifdef _DEBUG

    LOG_DEBUG("Lenght %d, hashed Data: [%s]", strlen(stringToVerify), stringToVerify);

    printHash(&hHash);

#endif

    sigBlob = unbase64(signatureB64, (int) strlen(signatureB64), &dwSigLen);

    LOG_DEBUG("raw signature lenght %d", dwSigLen);

    if (!CryptVerifySignature(hHash, sigBlob, dwSigLen, hKey, NULL, 0)) {

        LOG_ERROR("Signature not validated!  0x%08x ", GetLastError());

        free(sigBlob);

        CryptDestroyHash(hHash);

        CryptReleaseContext(hProv, 0);

        return FUNC_RET_ERROR;

    }

    CryptDestroyHash(hHash);

    free(sigBlob);

    CryptReleaseContext(hProv, 0);

    return FUNC_RET_OK;

}




 src/library/os/os.c

New file
@@ -0,0 +1,195 @@
//#include <stdlib.h>
#include <stdio.h>
#include "../base/logger.h"
#include "os.h"
#include "public-key.h"

#ifndef _MSC_VER

#include <openssl/pem.h>

static void free_resources(EVP_PKEY* pkey, EVP_MD_CTX* mdctx) {
    if (pkey) {
        EVP_PKEY_free(pkey);
    }
    if (mdctx) {
        EVP_MD_CTX_destroy(mdctx);
    }
}

FUNCTION_RETURN verifySignature(const char* stringToVerify,
        const char* signatureB64) {
    EVP_MD_CTX *mdctx = NULL;
    const char *pubKey = PUBLIC_KEY;
    int func_ret = 0;

    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) {
        LOG_ERROR("Error reading public key");
        return FUNC_RET_ERROR;
    }
    EVP_PKEY *pkey = EVP_PKEY_new();
    EVP_PKEY_assign_RSA(pkey, rsa);

    /*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[512];
    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())) {
        free_resources(pkey, mdctx);
        LOG_ERROR("Error creating context");
        return FUNC_RET_ERROR;
    }
    if (1 != EVP_DigestVerifyInit(mdctx, NULL, EVP_sha256(), NULL, pkey)) {
        LOG_ERROR("Error initializing digest");
        free_resources(pkey, mdctx);
        return FUNC_RET_ERROR;
    }
    int en = strlen(stringToVerify);
    func_ret = EVP_DigestVerifyUpdate(mdctx, stringToVerify, en);
    if (1 != func_ret) {
        LOG_ERROR("Error verifying digest %d", func_ret);
        free_resources(pkey, mdctx);
        return FUNC_RET_ERROR;
    }
    FUNCTION_RETURN result;
    func_ret = EVP_DigestVerifyFinal(mdctx, buffer, len);
    if (1 != func_ret) {
        LOG_ERROR("Error verifying digest %d", func_ret);
    }
    result = (1 == func_ret ? FUNC_RET_OK : FUNC_RET_ERROR);

    free_resources(pkey, mdctx);
    return result;
}

#else

#include <iphlpapi.h>
#include <Windows.h>
#pragma comment(lib, "IPHLPAPI.lib")

static void printHash(HCRYPTHASH* hHash) {
    BYTE *pbHash;
    DWORD dwHashLen;
    DWORD dwHashLenSize = sizeof(DWORD);
    char* hashStr;
    unsigned int i;

    if (CryptGetHashParam(*hHash, HP_HASHSIZE, (BYTE *) &dwHashLen,
            &dwHashLenSize, 0)) {
        pbHash = (BYTE*) malloc(dwHashLen);
        hashStr = (char*) malloc(dwHashLen * 2 + 1);
        if (CryptGetHashParam(*hHash, HP_HASHVAL, pbHash, &dwHashLen, 0)) {
            for (i = 0; i < dwHashLen; i++) {
                sprintf(&hashStr[i * 2], "%02x", pbHash[i]);
            } LOG_DEBUG("Hash to verify: %s", hashStr);
        }
        free(pbHash);
        free(hashStr);
    }
}

FUNCTION_RETURN verifySignature(const char* stringToVerify,
        const char* signatureB64) {
    //--------------------------------------------------------------------
    // Declare variables.
    //
    // hProv:           Cryptographic service provider (CSP). This example
    //                  uses the Microsoft Enhanced Cryptographic 
    //                  Provider.
    // hKey:            Key to be used. In this example, you import the 
    //                  key as a PLAINTEXTKEYBLOB.
    // dwBlobLen:       Length of the plaintext key.
    // pbKeyBlob:       Pointer to the exported key.
    BYTE pubKey[] = PUBLIC_KEY;

    HCRYPTPROV hProv = 0;
    HCRYPTKEY hKey = 0;
    HCRYPTHASH hHash = 0;
    DWORD dwSigLen;
    BYTE* sigBlob;

    //--------------------------------------------------------------------
    // Acquire a handle to the CSP.

    if (!CryptAcquireContext(&hProv,
    NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
        // If the key container cannot be opened, try creating a new
        // container by specifying a container name and setting the 
        // CRYPT_NEWKEYSET flag.
        LOG_INFO("Error in AcquireContext 0x%08x \n", GetLastError());
        if (NTE_BAD_KEYSET == GetLastError()) {
            if (!CryptAcquireContext(&hProv, "license++verify",
                    MS_ENHANCED_PROV, PROV_RSA_FULL,
                    CRYPT_NEWKEYSET | CRYPT_VERIFYCONTEXT)) {
                LOG_ERROR("Error in AcquireContext 0x%08x \n", GetLastError());
                return FUNC_RET_ERROR;
            }
        } else {
            LOG_ERROR(" Error in AcquireContext 0x%08x \n", GetLastError());
            return FUNC_RET_ERROR;
        }
    }

    // Use the CryptImportKey function to import the PLAINTEXTKEYBLOB
    // BYTE array into the key container. The function returns a 
    // pointer to an HCRYPTKEY variable that contains the handle of
    // the imported key.
    if (!CryptImportKey(hProv, &pubKey[0], sizeof(pubKey), 0, 0, &hKey)) {
        LOG_ERROR("Error 0x%08x in importing the PublicKey \n", GetLastError());
        return FUNC_RET_ERROR;
    }

    if (CryptCreateHash(hProv, CALG_SHA1, 0, 0, &hHash)) {
        LOG_DEBUG("Hash object created.");
    } else {
        LOG_ERROR("Error in hash creation 0x%08x ", GetLastError());
        CryptReleaseContext(hProv, 0);
        return FUNC_RET_ERROR;
    }

    if (!CryptHashData(hHash, stringToVerify, (DWORD) strlen(stringToVerify), 0)) {
        LOG_ERROR("Error in hashing data 0x%08x ", GetLastError());
        CryptDestroyHash(hHash);
        CryptReleaseContext(hProv, 0);
        return FUNC_RET_ERROR;
    }
#ifdef _DEBUG
    LOG_DEBUG("Lenght %d, hashed Data: [%s]", strlen(stringToVerify), stringToVerify);
    printHash(&hHash);
#endif
    sigBlob = unbase64(signatureB64, (int) strlen(signatureB64), &dwSigLen);
    LOG_DEBUG("raw signature lenght %d", dwSigLen);
    if (!CryptVerifySignature(hHash, sigBlob, dwSigLen, hKey, NULL, 0)) {
        LOG_ERROR("Signature not validated!  0x%08x ", GetLastError());
        free(sigBlob);
        CryptDestroyHash(hHash);
        CryptReleaseContext(hProv, 0);
        return FUNC_RET_ERROR;
    }
    CryptDestroyHash(hHash);
    free(sigBlob);
    CryptReleaseContext(hProv, 0);
    return FUNC_RET_OK;
}
#endif

 src/library/os/win/CMakeLists.txt

File was deleted