refactor to fix MINGW consistency

Maximilien Siavelis

2018-01-06 ec3965cbc675c4546185caa847cb83191e1a3fcb

 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;

}