Egalware/EgtLock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
84fed1bda817b9bc9b3a186644e4babc2225d4db
EgtLock/MachineId.cpp
T
Dario Sassi 07e9914302 EgtLock 1.6g8 : 
- aggiunta gestione chiavi hardware OxySec
- spostati Base64 e Crc32 in General.
2015-07-29 07:03:48 +00:00

287 lines
9.8 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : MachineId.cpp Data : 08.09.14 Versione : 1.5i2
// Contenuto : Funzioni per gestione/calcolo Id macchina.
//
//
//
// Modifiche : 08.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//------------------ Include -------------------------------------------------
#include "stdafx.h"
#include "MachineId.h"
#include "Obfuscate.h"
#include "RegForMachineId.h"
#include "/EgtDev/Include/SELkMachineId.h"
#include "/EgtDev/Include/EgtBase64.h"
#include "/EgtDev/Include/EgtCrc32.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#define NOMINMAX
#include <windows.h>
#include <winioctl.h>
using namespace std ;
// ----------------- Funzioni locali -------------------------------------------------
static bool GetSN123FromRegistry( std::string& sSN1, std::string& sSN2, std::string& sSN3) ;
static bool GetSN123FromMachine( std::string& sSN1, std::string& sSN2, std::string& sSN3) ;
static void AdjustSN( const std::string& sSou, const char* szFill, std::string& sDest) ;
static DWORD GetPhysicalDriveSN( UINT nDriveNumber, std::string& sSerialNumber) ;
static DWORD GetDiskVolumeSN( const wchar_t* wszDisk, std::string& sSerialNumber) ;
static DWORD GetPseudoRandomSN( std::string& sSerialNumber) ;
//------------------------------------------------------------------------------------
bool
CalcMachineId( bool bForceNew)
{
// recupero i tre seriali dai dati di Registry
string sRegSN1, sRegSN2, sRegSN3 ;
GetSN123FromRegistry( sRegSN1, sRegSN2, sRegSN3) ;
// recupero i tre seriali dai dati macchina
string sMacSN1, sMacSN2, sMacSN3 ;
GetSN123FromMachine( sMacSN1, sMacSN2, sMacSN3) ;
// combino i seriali nel MachineId
string sSN1, sSN2, sSN3 ;
sSN1 = sMacSN1 ;
sSN2 = sMacSN2 ;
if ( bForceNew || sRegSN3.empty())
sSN3 = sMacSN3 ;
else
sSN3 = sRegSN3 ;
string sMachineId = sSN1 + "-" + sSN2 + "-" + sSN3 ;
// salvo il MachineId nel registry
if ( ! MixLockId( sMachineId))
return false ;
AddCrc32ToString( sMachineId) ;
string sB64 ;
if ( ! B64Encode( sMachineId, sB64))
return false ;
return SaveMachineIdOnReg( sB64) ;
}
//------------------------------------------------------------------------------------
bool
GetMachineId( string& sMachineId)
{
// recupero i tre seriali dai dati di Registry
string sRegSN1, sRegSN2, sRegSN3 ;
GetSN123FromRegistry( sRegSN1, sRegSN2, sRegSN3) ;
// recupero i tre seriali dai dati macchina
string sMacSN1, sMacSN2, sMacSN3 ;
GetSN123FromMachine( sMacSN1, sMacSN2, sMacSN3) ;
// verifico che i primi due seriali coincidano e il terzo di registro esista (quello di macchina non conta)
if ( sRegSN1 != sMacSN1 || sRegSN2 != sMacSN2 || sRegSN3.empty())
return false ;
// costruisco l'Id di macchina dai seriali
sMachineId = sRegSN1 + "-" + sRegSN2 + "-" + sRegSN3 ;
return true ;
}
//------------------------------------------------------------------------------------
bool
GetMachineId2( string& sMachineId)
{
string sAux ;
if ( ! GetMachineId( sAux))
return false ;
// Eseguo Mix + CRC32 + Base64.
// Equivale a ConvertLockIdToLockId2 ma non lo uso per evitare link a sw chiave.
if ( ! MixLockId( sAux))
return false ;
AddCrc32ToString( sAux) ;
return B64Encode( sAux, sMachineId) ;
}
//------------------------------------------------------------------------------------
static bool
GetSN123FromRegistry( string& sSN1, string& sSN2, string& sSN3)
{
// leggo MachineId da Registry
string sRegOffMachId ;
if ( ! LoadMachineIdFromReg( sRegOffMachId))
return false ;
// converto da forma offuscata (2) in forma chiara
// Equivale a ConvertLockId2ToLockId ma non lo uso per evitare link a sw chiave.
string sRegMachId ;
// eseguo decodifica da Base64
if ( ! B64Decode( sRegOffMachId, sRegMachId))
return false ;
// eseguo test e rimozione CRC32
if ( ! TestCrc32AndRemoveFromString( sRegMachId))
return false ;
// eseguo demixing
if ( ! MixLockId( sRegMachId))
return false ;
// divisione in seriali
sSN1 = sRegMachId.substr( 0, 6) ;
sSN2 = sRegMachId.substr( 7, 6) ;
sSN3 = sRegMachId.substr( 14, 6) ;
return true ;
}
//------------------------------------------------------------------------------------
static bool
GetSN123FromMachine( string& sSN1, string& sSN2, string& sSN3)
{
// recupero SN fisico del primo disco
string sDriveSN ;
DWORD dwRet = GetPhysicalDriveSN( 0, sDriveSN) ;
// verifico errore
bool bOk = ( dwRet == NO_ERROR && ! sDriveSN.empty()) ;
// calcolo stringa First Serial Number
AdjustSN( sDriveSN, "WCRTBAJYOI", sSN1) ;
// recupero SN di volume del primo disco
string sVolSN ;
dwRet = GetDiskVolumeSN( L"C:\\", sVolSN) ; ;
// verifico errore
bOk = bOk && ( dwRet == NO_ERROR && ! sVolSN.empty()) ;
// calcolo stringa Second Serial Number
AdjustSN( sVolSN, "6038149572", sSN2) ;
// recupero SN pseudo random
string sPRandSN ;
dwRet = GetPseudoRandomSN( sPRandSN) ; ;
// verifico errore
bOk = bOk && ( dwRet == NO_ERROR && ! sPRandSN.empty()) ;
// calcolo stringa Third Serial Number
AdjustSN( sPRandSN, "7438925160", sSN3) ;
return bOk ;
}
//------------------------------------------------------------------------------------
static void
AdjustSN( const string& sSou, const char* szFill, string& sDest)
{
static const int LEN_REF = 6 ;
int nLen = (int) sSou.length() ;
if ( nLen <= LEN_REF)
sDest = string( szFill).substr( 0, LEN_REF - nLen) + sSou ;
else if ( nLen == LEN_REF)
sDest = sSou ;
else
sDest = sSou.substr( sSou.length() - LEN_REF, LEN_REF) ;
}
//------------------------------------------------------------------------------------
static DWORD
GetPhysicalDriveSN( UINT nDriveNumber, string& sSerialNumber)
{
DWORD dwRet = NO_ERROR ;
sSerialNumber.clear() ;
// Format physical drive path (may be '\\.\PhysicalDrive0', '\\.\PhysicalDrive1' and so on).
const int DIM_BUFF = 15 ;
char szBuff[DIM_BUFF] ;
_itoa_s( nDriveNumber, szBuff, 10) ;
string sDrivePath = string( "\\\\.\\PhysicalDrive") + szBuff ;
// Get a handle to physical drive
HANDLE hDevice = ::CreateFileW( stringtoW( sDrivePath), 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL);
if ( hDevice == INVALID_HANDLE_VALUE)
return ::GetLastError() ;
// Set the input data structure
STORAGE_PROPERTY_QUERY storagePropertyQuery ;
ZeroMemory(&storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY)) ;
storagePropertyQuery.PropertyId = StorageDeviceProperty ;
storagePropertyQuery.QueryType = PropertyStandardQuery ;
// Get the necessary output buffer size
STORAGE_DESCRIPTOR_HEADER storageDescriptorHeader = {0} ;
DWORD dwBytesReturned = 0;
if ( ! ::DeviceIoControl( hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
&storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY),
&storageDescriptorHeader, sizeof(STORAGE_DESCRIPTOR_HEADER),
&dwBytesReturned, NULL)) {
dwRet = ::GetLastError() ;
::CloseHandle(hDevice) ;
return dwRet ;
}
// Alloc the output buffer
const DWORD dwOutBufferSize = storageDescriptorHeader.Size;
BYTE* pOutBuffer = new BYTE[dwOutBufferSize];
ZeroMemory(pOutBuffer, dwOutBufferSize);
// Get the storage device descriptor
if ( ! ::DeviceIoControl( hDevice, IOCTL_STORAGE_QUERY_PROPERTY,
&storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY),
pOutBuffer, dwOutBufferSize,
&dwBytesReturned, NULL)) {
dwRet = ::GetLastError() ;
delete [] pOutBuffer ;
::CloseHandle(hDevice) ;
return dwRet ;
}
// Now, the output buffer points to a STORAGE_DEVICE_DESCRIPTOR structure
// followed by additional info like vendor ID, product ID, serial number, and so on.
STORAGE_DEVICE_DESCRIPTOR* pDeviceDescriptor = (STORAGE_DEVICE_DESCRIPTOR*)pOutBuffer ;
const DWORD dwSerialNumberOffset = pDeviceDescriptor->SerialNumberOffset ;
if ( dwSerialNumberOffset != 0) {
// Finally, get the serial number
sSerialNumber = (char*)( pOutBuffer + dwSerialNumberOffset) ;
Trim( sSerialNumber) ;
}
// Do cleanup and return
delete []pOutBuffer;
::CloseHandle(hDevice);
return dwRet;
}
//-----------------------------------------------------------------------------
static DWORD
GetDiskVolumeSN( const wchar_t* wszDisk, string& sSerialNumber)
{
DWORD dwRet = NO_ERROR ;
sSerialNumber.clear() ;
// Verifico il numero di serie del volume indicato
DWORD dwSerNum, dwMaxLen, dwFSFlag ;
if ( GetVolumeInformationW( wszDisk, NULL, 0, &dwSerNum, &dwMaxLen, &dwFSFlag, NULL, 0)) {
const int DIM_BUFF = 30 ;
char szBuff[DIM_BUFF] ;
_ui64toa_s( (unsigned int) dwSerNum, szBuff, DIM_BUFF, 10) ;
sSerialNumber = szBuff ;
}
else {
dwRet = ::GetLastError() ;
}
return dwRet ;
}
//-----------------------------------------------------------------------------
static DWORD
GetPseudoRandomSN( string& sSerialNumber)
{
sSerialNumber.clear() ;
UINT nSN ;
DWORD dwRet = rand_s( &nSN) ;
if ( dwRet == NO_ERROR) {
const int DIM_BUFF = 30 ;
char szBuff[DIM_BUFF] ;
_ui64toa_s( nSN, szBuff, DIM_BUFF, 10) ;
sSerialNumber = szBuff ;
}
return dwRet ;
}
Reference in New Issue View Git Blame Copy Permalink