EgtLock 1.5i2 :
- primo rilascio.
This commit is contained in:
Dario Sassi
+117
@@ -0,0 +1,117 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : Base64.cpp Data : 08.09.14 Versione : 1.5i2
|
||||
// Contenuto : Funzioni per codifica/decodifica Base64.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 08.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
//------------------ Include -------------------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include "/EgtDev/Include/SELkBase64.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
//--------------------- Base64 Encoding/Decoding Tables -----------------------
|
||||
static char EncB64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ;
|
||||
static char DecB64[] = "|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq" ;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// encodeblock - encode 3 8-bit binary bytes as 4 '6-bit' characters
|
||||
//-----------------------------------------------------------------------------
|
||||
void
|
||||
encodeblock( unsigned char in[], string& sB64Dest, int len)
|
||||
{
|
||||
sB64Dest.push_back( EncB64[ in[0] >> 2 ]) ;
|
||||
sB64Dest.push_back( EncB64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ]) ;
|
||||
sB64Dest.push_back( (unsigned char) (len > 1 ? EncB64[ ((in[1] & 0x0f) << 2) |
|
||||
((in[2] & 0xc0) >> 6) ] : '=')) ;
|
||||
sB64Dest.push_back( (unsigned char) (len > 2 ? EncB64[ in[2] & 0x3f ] : '=')) ;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// encode - base64 encode a stream, adding padding if needed
|
||||
//-----------------------------------------------------------------------------
|
||||
bool
|
||||
B64Encode( const string& sSou, string& sB64Dest)
|
||||
{
|
||||
// sorgente e dstinazione devono essere diversi
|
||||
if ( &sSou == &sB64Dest)
|
||||
return false ;
|
||||
// eseguo conversione
|
||||
sB64Dest.clear() ;
|
||||
sB64Dest.reserve( (int) ( ceil( sSou.length() / 3.) * 4)) ;
|
||||
unsigned char in[3] ;
|
||||
for ( size_t j = 0 ; j < sSou.length() ;) {
|
||||
int len = 0 ;
|
||||
for ( size_t i = 0 ; i < 3 ; i++) {
|
||||
if ( j < sSou.length()) {
|
||||
in[i] = (unsigned char) sSou[j] ;
|
||||
++ len ;
|
||||
++ j ;
|
||||
}
|
||||
else
|
||||
in[i] = 0 ;
|
||||
}
|
||||
if ( len > 0)
|
||||
encodeblock( in, sB64Dest, len) ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// decodeblock - decode 4 '6-bit' characters into 3 8-bit binary bytes
|
||||
//-----------------------------------------------------------------------------
|
||||
void
|
||||
decodeblock( char in[], string& sDest)
|
||||
{
|
||||
sDest.push_back( ( in[0] << 2 | in[1] >> 4)) ;
|
||||
sDest.push_back( ( in[1] << 4 | in[2] >> 2)) ;
|
||||
sDest.push_back( ( in[2] << 6 | in[3] >> 0)) ;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
bool
|
||||
B64Decode( const string& sB64Sou, string& sDest)
|
||||
{
|
||||
// sorgente e dstinazione devono essere diversi
|
||||
if ( &sB64Sou == &sDest)
|
||||
return false ;
|
||||
// eseguo conversione
|
||||
sDest.clear() ;
|
||||
sDest.reserve( sB64Sou.length()) ;
|
||||
int phase = 0 ;
|
||||
char in[4] = { '\0', '\0', '\0', '\0'} ;
|
||||
for ( size_t i = 0 ; i < sB64Sou.length() ; ++ i) {
|
||||
int c = (int) sB64Sou[i] ;
|
||||
if ( c == '=') {
|
||||
decodeblock( in, sDest) ;
|
||||
if ( in[3] == '\0')
|
||||
sDest.pop_back() ;
|
||||
if ( in[2] == '\0')
|
||||
sDest.pop_back() ;
|
||||
break ;
|
||||
}
|
||||
int nVal ;
|
||||
char* p = strchr( EncB64, c) ;
|
||||
if ( p != nullptr)
|
||||
nVal = char( p - EncB64) ;
|
||||
in[phase] = (( c < 43 || c > 122) ? -1 : (int) DecB64[ c - 43]) ;
|
||||
if ( in[phase] != 0 )
|
||||
in[phase] = ((in[phase] == (int)'$') ? -1 : in[phase] - 62) ;
|
||||
if ( in[phase] != -1 ) {
|
||||
phase = (phase + 1) % 4 ;
|
||||
if ( phase == 0) {
|
||||
decodeblock( in, sDest) ;
|
||||
in[0] = in[1] = in[2] = in[3] = '\0' ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : Crc32.cpp Data : 08.09.14 Versione : 1.5i2
|
||||
// Contenuto : Funzioni per calcolo CRC32.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 08.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
|
||||
//------------------ Include -------------------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include "/EgtDev/Include/SELkCrc32.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void
|
||||
AddCrc32ToString( string& sVal)
|
||||
{
|
||||
// calcolo CRC32 e lo aggiungo in coda
|
||||
unsigned int nCrc32 = GetCrc32( 0, sVal.length(), sVal.c_str()) ;
|
||||
sVal.push_back( ( nCrc32 & 0xff000000) >> 24) ;
|
||||
sVal.push_back( ( nCrc32 & 0x00ff0000) >> 16) ;
|
||||
sVal.push_back( ( nCrc32 & 0x0000ff00) >> 8) ;
|
||||
sVal.push_back( ( nCrc32 & 0x000000ff) >> 0) ;
|
||||
// la stringa può contenere caratteri speciali, va condificata in base64
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
TestCrc32AndRemoveFromString( string& sVal)
|
||||
{
|
||||
// almeno 4 char
|
||||
if ( sVal.length() < 4)
|
||||
return false ;
|
||||
// stringa con CRC32 negli ultimi 4 char
|
||||
unsigned int nReadCrc32 = (unsigned char) sVal.back() ;
|
||||
sVal.pop_back() ;
|
||||
nReadCrc32 += (((unsigned char) sVal.back()) << 8) ;
|
||||
sVal.pop_back() ;
|
||||
nReadCrc32 += (((unsigned char) sVal.back()) << 16) ;
|
||||
sVal.pop_back() ;
|
||||
nReadCrc32 += (((unsigned char) sVal.back()) << 24) ;
|
||||
sVal.pop_back() ;
|
||||
unsigned int nCalcCrc32 = GetCrc32( 0, sVal.length(), sVal.c_str()) ;
|
||||
// test
|
||||
return ( nReadCrc32 == nCalcCrc32) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
TestCrc32OfString( const string& sVal)
|
||||
{
|
||||
// almeno 4 char
|
||||
int nLen = (int) sVal.length() ;
|
||||
if ( nLen < 4)
|
||||
return false ;
|
||||
// stringa con CRC32 negli ultimi 4 char
|
||||
unsigned int nReadCrc32 = (unsigned char) sVal[nLen-1] ;
|
||||
nReadCrc32 += (((unsigned char) sVal[nLen-2]) << 8) ;
|
||||
nReadCrc32 += (((unsigned char) sVal[nLen-3]) << 16) ;
|
||||
nReadCrc32 += (((unsigned char) sVal[nLen-4]) << 24) ;
|
||||
unsigned int nCalcCrc32 = GetCrc32( 0, nLen - 4, sVal.c_str()) ;
|
||||
// test
|
||||
return ( nReadCrc32 == nCalcCrc32) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
unsigned int
|
||||
GetCrc32( unsigned int current_remainder, size_t count, const void* p)
|
||||
{
|
||||
/*
|
||||
CRC32_TABLE[] is a table for a byte-wise 32-bit CRC calculation
|
||||
using the generator polynomial:
|
||||
x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
|
||||
*/
|
||||
static unsigned int CRC32_TABLE[256] = {
|
||||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
|
||||
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
|
||||
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
|
||||
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
|
||||
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
|
||||
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
|
||||
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
|
||||
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
|
||||
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
|
||||
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
|
||||
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
|
||||
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
|
||||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
|
||||
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
|
||||
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
|
||||
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
|
||||
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
|
||||
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
|
||||
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
|
||||
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
|
||||
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
|
||||
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
|
||||
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
|
||||
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
|
||||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
|
||||
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
|
||||
0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
|
||||
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
|
||||
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
|
||||
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
|
||||
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
|
||||
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
|
||||
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
|
||||
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
|
||||
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
|
||||
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
|
||||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
|
||||
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
|
||||
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
|
||||
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
|
||||
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
|
||||
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
|
||||
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
|
||||
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
|
||||
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
|
||||
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
|
||||
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
|
||||
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
|
||||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
|
||||
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
|
||||
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
|
||||
0x2d02ef8d
|
||||
};
|
||||
|
||||
if ( count > 0 && p != nullptr) {
|
||||
|
||||
const unsigned char* b = (const unsigned char*) p ;
|
||||
|
||||
current_remainder ^= 0xffffffff ;
|
||||
while ( count >= 8) {
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
count -= 8 ;
|
||||
}
|
||||
|
||||
while ( count > 0) {
|
||||
current_remainder = CRC32_TABLE[((int)current_remainder ^ (*b++)) & 0xff] ^ (current_remainder >> 8) ;
|
||||
-- count ;
|
||||
}
|
||||
|
||||
current_remainder ^= 0xffffffff ;
|
||||
}
|
||||
|
||||
return current_remainder ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 11.00
|
||||
# Visual Studio 2010
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EgtLock", "EgtLock.vcxproj", "{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Debug|x64 = Debug|x64
|
||||
Release|Win32 = Release|Win32
|
||||
Release|x64 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Debug|x64.Build.0 = Debug|x64
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Release|Win32.Build.0 = Release|Win32
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Release|x64.ActiveCfg = Release|x64
|
||||
{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}.Release|x64.Build.0 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
+196
@@ -0,0 +1,196 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{DD7F3502-6761-4B6D-BE79-B2DF4A5FC426}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>EgtLock</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>false</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>false</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<OutDir>$(SolutionDir)$(Configuration)$(PlatformArchitecture)\</OutDir>
|
||||
<IntDir>$(Configuration)$(PlatformArchitecture)\</IntDir>
|
||||
<TargetName>S$(ProjectName)D$(PlatformArchitecture)</TargetName>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<OutDir>$(SolutionDir)$(Configuration)$(PlatformArchitecture)\</OutDir>
|
||||
<IntDir>$(Configuration)$(PlatformArchitecture)\</IntDir>
|
||||
<TargetName>S$(ProjectName)R$(PlatformArchitecture)</TargetName>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<OutDir>$(SolutionDir)$(Configuration)$(PlatformArchitecture)\</OutDir>
|
||||
<IntDir>$(Configuration)$(PlatformArchitecture)\</IntDir>
|
||||
<TargetName>S$(ProjectName)D$(PlatformArchitecture)</TargetName>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<OutDir>$(SolutionDir)$(Configuration)$(PlatformArchitecture)\</OutDir>
|
||||
<IntDir>$(Configuration)$(PlatformArchitecture)\</IntDir>
|
||||
<TargetName>S$(ProjectName)R$(PlatformArchitecture)</TargetName>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>Use</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
|
||||
<MinimalRebuild>false</MinimalRebuild>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
<PostBuildEvent>
|
||||
<Command>copy $(TargetDir)$(TargetName).pdb \EgtDev\Lib\
|
||||
copy $(TargetDir)$(TargetName).lib \EgtDev\Lib\</Command>
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>Use</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
|
||||
<MinimalRebuild>false</MinimalRebuild>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
<PostBuildEvent>
|
||||
<Command>copy $(TargetDir)$(TargetName).pdb \EgtDev\Lib\
|
||||
copy $(TargetDir)$(TargetName).lib \EgtDev\Lib\</Command>
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>Use</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
|
||||
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
<PostBuildEvent>
|
||||
<Command>copy $(TargetDir)$(TargetName).lib \EgtDev\Lib\</Command>
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>Use</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
|
||||
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
<PostBuildEvent>
|
||||
<Command>copy $(TargetDir)$(TargetName).lib \EgtDev\Lib\</Command>
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\Include\SELkBase64.h" />
|
||||
<ClInclude Include="..\Include\SELkCrc32.h" />
|
||||
<ClInclude Include="..\Include\SELkKeyProc.h" />
|
||||
<ClInclude Include="..\Include\SELkMachineId.h" />
|
||||
<ClInclude Include="MachineId.h" />
|
||||
<ClInclude Include="Obfuscate.h" />
|
||||
<ClInclude Include="RegForMachineId.h" />
|
||||
<ClInclude Include="stdafx.h" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="Base64.cpp" />
|
||||
<ClCompile Include="MachineId.cpp" />
|
||||
<ClCompile Include="Crc32.cpp" />
|
||||
<ClCompile Include="Obfuscate.cpp" />
|
||||
<ClCompile Include="KeyProc.cpp" />
|
||||
<ClCompile Include="RegForMachineId.cpp" />
|
||||
<ClCompile Include="stdafx.cpp">
|
||||
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
|
||||
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
|
||||
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
|
||||
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,66 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup>
|
||||
<Filter Include="File di origine">
|
||||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
|
||||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="File di intestazione">
|
||||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
|
||||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="File di risorse">
|
||||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
|
||||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="stdafx.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\Include\SELkBase64.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\Include\SELkCrc32.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="MachineId.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="RegForMachineId.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="Obfuscate.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\Include\SELkMachineId.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\Include\SELkKeyProc.h">
|
||||
<Filter>File di intestazione</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="stdafx.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="Base64.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="Crc32.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="Obfuscate.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="RegForMachineId.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="MachineId.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="KeyProc.cpp">
|
||||
<Filter>File di origine</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
+190
@@ -0,0 +1,190 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : KeyProc.cpp Data : 10.09.14 Versione : 1.5i2
|
||||
// Contenuto : Funzioni per la gestione della chiave.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 10.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
|
||||
//------------------ Include -------------------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include <time.h>
|
||||
#include "Obfuscate.h"
|
||||
#include "/EgtDev/Include/EGnStringUtils.h"
|
||||
#include "/EgtDev/Include/SELkKeyProc.h"
|
||||
#include "/EgtDev/Include/SELkMachineId.h"
|
||||
#include "/EgtDev/Include/SELkCrc32.h"
|
||||
#include "/EgtDev/Include/SELkBase64.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static const int MIN_DAYS = 16326 ; // giorni al 13/09/2014 dal 1/1/1970
|
||||
static const int N_STEP = 7 ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
MakeKey( int nProd, int nVer, int nLev, int nExpDays,
|
||||
unsigned int nOpt1, unsigned int nOpt2, int nOptExpDays,
|
||||
const string& sScramKey, string& sKey)
|
||||
{
|
||||
// inizializzo parte pseudorandom
|
||||
srand( nVer + nLev) ;
|
||||
// preparo la stringa da criptare
|
||||
string sClearKey ;
|
||||
sClearKey += ToString( ( rand() % 9), 1) ;
|
||||
sClearKey += ToString( nProd, 4) ;
|
||||
sClearKey += ToString( nVer, 2) ;
|
||||
sClearKey += ToString( nLev, 2) ;
|
||||
sClearKey += ToString( ( rand() % 9), 1) ;
|
||||
sClearKey += ToString( nExpDays, 6) ;
|
||||
sClearKey += ToString( ( rand() % 9), 1) ;
|
||||
sClearKey += " " ;
|
||||
sClearKey[17] = ( nOpt1 >> 0) & 0xFF ;
|
||||
sClearKey[18] = ( nOpt1 >> 8) & 0xFF ;
|
||||
sClearKey[19] = ( nOpt1 >> 16) & 0xFF ;
|
||||
sClearKey[20] = ( nOpt1 >> 24) & 0xFF ;
|
||||
sClearKey += " " ;
|
||||
sClearKey[21] = ( nOpt2 >> 0) & 0xFF ;
|
||||
sClearKey[22] = ( nOpt2 >> 8) & 0xFF ;
|
||||
sClearKey[23] = ( nOpt2 >> 16) & 0xFF ;
|
||||
sClearKey[24] = ( nOpt2 >> 24) & 0xFF ;
|
||||
sClearKey += ToString( ( rand() % 9), 1) ;
|
||||
sClearKey += ToString( nOptExpDays, 6) ;
|
||||
// eseguo la cifratura
|
||||
string sMidKey = sClearKey ;
|
||||
if ( ! ScrambleData( sMidKey, sScramKey, N_STEP))
|
||||
return false ;
|
||||
// aggiungo Crc32
|
||||
AddCrc32ToString( sMidKey) ;
|
||||
// trasformo in Base64
|
||||
return B64Encode( sMidKey, sKey) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
ReadKey( const string& sKey, const string& sScramKey,
|
||||
int& nProd, int& nVer, int& nLev, int& nExpDays,
|
||||
unsigned int& nOpt1, unsigned int& nOpt2, int& nOptExpDays)
|
||||
{
|
||||
// decodifico da Base64
|
||||
string sClearKey ;
|
||||
if ( ! B64Decode( sKey, sClearKey))
|
||||
return false ;
|
||||
// verifico e tolgo CRC32
|
||||
if ( ! TestCrc32AndRemoveFromString( sClearKey))
|
||||
return false ;
|
||||
// eseguo la decifratura
|
||||
if ( ! UnScrambleData( sClearKey, sScramKey, N_STEP))
|
||||
return false ;
|
||||
// verifico la lunghezza della stringa risultante
|
||||
if ( sClearKey.length() != 32)
|
||||
return false ;
|
||||
// leggo le varie parti
|
||||
if ( ! FromString( sClearKey.substr( 1, 4), nProd))
|
||||
return false ;
|
||||
if ( ! FromString( sClearKey.substr( 5, 2), nVer))
|
||||
return false ;
|
||||
if ( ! FromString( sClearKey.substr( 7, 2), nLev))
|
||||
return false ;
|
||||
if ( ! FromString( sClearKey.substr( 10, 6), nExpDays))
|
||||
return false ;
|
||||
nOpt1 = sClearKey[17] | ( ((unsigned char)sClearKey[18]) << 8) |
|
||||
( ((unsigned char)sClearKey[19]) << 16) | ( ((unsigned char)sClearKey[20]) << 24) ;
|
||||
nOpt2 = sClearKey[21] | ( ((unsigned char)sClearKey[22]) << 8) |
|
||||
( ((unsigned char)sClearKey[23]) << 16) | ( ((unsigned char)sClearKey[24]) << 24) ;
|
||||
if ( ! FromString( sClearKey.substr( 26, 6), nOptExpDays))
|
||||
return false ;
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static int
|
||||
VerifyKey( const string& sKey, int nProd, int nVer, int nLev,
|
||||
int& nKProd, int& nKVer, int& nKLev, int& nKExpDays,
|
||||
unsigned int& nKOpt1, unsigned int& nKOpt2, int& nKOptExpDays)
|
||||
{
|
||||
// creo la chiave di scramble
|
||||
string sMachId2 ;
|
||||
if ( ! GetMachineId2( sMachId2))
|
||||
return KEY_ERR_MACHID ;
|
||||
string sScramKey ;
|
||||
if ( ! ConvertMachineId2ToScramKey( sMachId2, sScramKey))
|
||||
return KEY_ERR_SCRAMKEY ;
|
||||
// recupero le informazioni nella chiave
|
||||
if ( ! ReadKey( sKey, sScramKey,
|
||||
nKProd, nKVer, nKLev, nKExpDays,
|
||||
nKOpt1, nKOpt2, nKOptExpDays))
|
||||
return KEY_ERR_KEYDECODE ;
|
||||
// verifico dati prodotto
|
||||
if ( nProd != nKProd)
|
||||
return KEY_ERR_PROD ;
|
||||
if ( nVer > nKVer)
|
||||
return KEY_ERR_VER ;
|
||||
if ( nLev > nKLev)
|
||||
return KEY_ERR_LEV ;
|
||||
// verifico scadenza
|
||||
int nDays = GetCurrDay() ;
|
||||
if ( nDays < MIN_DAYS)
|
||||
return KEY_ERR_WRONG_TIME ;
|
||||
if ( nDays > nKExpDays)
|
||||
return KEY_ERR_TIME ;
|
||||
|
||||
return KEY_OK ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
int
|
||||
VerifyKey( const string& sKey, int nProd, int nVer, int nLev)
|
||||
{
|
||||
int nKProd, nKVer, nKLev, nKExpDays ;
|
||||
unsigned int nKOpt1, nKOpt2 ;
|
||||
int nKOptExpDays ;
|
||||
return VerifyKey( sKey, nProd, nVer, nLev,
|
||||
nKProd, nKVer, nKLev, nKExpDays,
|
||||
nKOpt1, nKOpt2, nKOptExpDays) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
int
|
||||
GetKeyLevel( const string& sKey, int nProd, int nVer, int nLev,
|
||||
int& nKLev, int& nKExpDays)
|
||||
{
|
||||
int nKProd, nKVer ;
|
||||
unsigned int nKOpt1, nKOpt2 ;
|
||||
int nKOptExpDays ;
|
||||
return VerifyKey( sKey, nProd, nVer, nLev,
|
||||
nKProd, nKVer, nKLev, nKExpDays,
|
||||
nKOpt1, nKOpt2, nKOptExpDays) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
int
|
||||
GetKeyOptions( const string& sKey, int nProd, int nVer, int nLev,
|
||||
unsigned int& nKOpt1, unsigned int& nKOpt2, int& nKOptExpDays)
|
||||
{
|
||||
int nKProd, nKVer, nKLev, nKExpDays ;
|
||||
return VerifyKey( sKey, nProd, nVer, nLev,
|
||||
nKProd, nKVer, nKLev, nKExpDays,
|
||||
nKOpt1, nKOpt2, nKOptExpDays) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
int
|
||||
GetCurrDay( void)
|
||||
{
|
||||
time_t nClock = time( nullptr) ; // secondi da 00:00:00 1/1/1970 in UTC
|
||||
long nDelta ; // offset tra UTC e tempo locale (nDelta = T_UTC - T_LOC)
|
||||
_tzset() ;
|
||||
if ( _get_timezone( &nDelta) != 0) // con errore nessun offset
|
||||
nDelta = 0 ;
|
||||
int nDays = int( ( nClock - nDelta) / ( 24 * 3600)) ; // (24*3600) secondi in un giorno
|
||||
|
||||
return nDays ;
|
||||
}
|
||||
+319
@@ -0,0 +1,319 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// 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 <windows.h>
|
||||
#include <winioctl.h>
|
||||
#include "MachineId.h"
|
||||
#include "RegForMachineId.h"
|
||||
#include "Obfuscate.h"
|
||||
#include "/EgtDev/Include/SELkBase64.h"
|
||||
#include "/EgtDev/Include/SELkCrc32.h"
|
||||
#include "/EgtDev/Include/EGnStringUtils.h"
|
||||
#include "/EgtDev/Include/EGnStringConverter.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
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 ( ! MixMachineId( 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, il terzo di macchina non conta
|
||||
if ( sRegSN1 != sMacSN1 || sRegSN2 != sMacSN2)
|
||||
return false ;
|
||||
|
||||
// costruisco l'Id di macchina dai seriali
|
||||
sMachineId = sRegSN1 + "-" + sRegSN2 + "-" + sRegSN3 ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
bool
|
||||
GetMachineId2( string& sMachineId)
|
||||
{
|
||||
// recupero id in chiaro
|
||||
string sAux ;
|
||||
if ( ! GetMachineId( sAux))
|
||||
return false ;
|
||||
// eseguo Mix + CRC32 + Base64
|
||||
if ( ! MixMachineId( sAux))
|
||||
return false ;
|
||||
AddCrc32ToString( sAux) ;
|
||||
return B64Encode( sAux, sMachineId) ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
bool
|
||||
GetMachineId3( string& sMachineId)
|
||||
{
|
||||
// recupero id in chiaro
|
||||
string sAux ;
|
||||
if ( ! GetMachineId( sAux))
|
||||
return false ;
|
||||
// eseguo Mix + Scramble + CRC32 + Base64
|
||||
if ( ! MixMachineId( sAux))
|
||||
return false ;
|
||||
if ( ! ScrambleMachineId( sAux))
|
||||
return false ;
|
||||
AddCrc32ToString( sAux) ;
|
||||
return B64Encode( sAux, sMachineId) ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
bool
|
||||
ConvertMachineId2ToMachineId( const string& sMachId2, string& sMachId)
|
||||
{
|
||||
// eseguo decodifica da Base64
|
||||
if ( ! B64Decode( sMachId2, sMachId))
|
||||
return false ;
|
||||
// eseguo test e rimozione CRC32
|
||||
if ( ! TestCrc32AndRemoveFromString( sMachId))
|
||||
return false ;
|
||||
// eseguo demixing
|
||||
if ( ! MixMachineId( sMachId))
|
||||
return false ;
|
||||
return true ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
bool
|
||||
ConvertMachineId2ToScramKey( const string& sMachId2, string& sScramKey)
|
||||
{
|
||||
// eseguo decodifica da Base64
|
||||
if ( ! B64Decode( sMachId2, sScramKey))
|
||||
return false ;
|
||||
// eseguo test e rimozione CRC32
|
||||
if ( ! TestCrc32AndRemoveFromString( sScramKey))
|
||||
return false ;
|
||||
// eseguo scramble
|
||||
if ( ! ScrambleMachineId( sScramKey))
|
||||
return false ;
|
||||
// aggiungo CRC32
|
||||
AddCrc32ToString( sScramKey) ;
|
||||
return true ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
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
|
||||
string sRegMachId ;
|
||||
if ( ! ConvertMachineId2ToMachineId( sRegOffMachId, sRegMachId))
|
||||
return false ;
|
||||
// divisione in seriali
|
||||
sSN1 = sRegMachId.substr( 0, 6) ;
|
||||
sSN2 = sRegMachId.substr( 7, 6) ;
|
||||
sSN3 = sRegMachId.substr( 14, 6) ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
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 ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
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) ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
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 ;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
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 ;
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : MachineId.cpp Data : 10.09.14 Versione : 1.5i2
|
||||
// Contenuto : Dichiarazione funzioni locali per gestione/calcolo Id macchina.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 10.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include "/EgtDev/Include/SELkMachineId.h"
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------
|
||||
bool GetSN123FromRegistry( std::string& sSN1, std::string& sSN2, std::string& sSN3) ;
|
||||
bool GetSN123FromMachine( std::string& sSN1, std::string& sSN2, std::string& sSN3) ;
|
||||
void AdjustSN( const std::string& sSou, const char* szFill, std::string& sDest) ;
|
||||
DWORD GetPhysicalDriveSN( UINT nDriveNumber, std::string& sSerialNumber) ;
|
||||
DWORD GetDiskVolumeSN( const wchar_t* wszDisk, std::string& sSerialNumber) ;
|
||||
DWORD GetPseudoRandomSN( std::string& sSerialNumber) ;
|
||||
+197
@@ -0,0 +1,197 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : Obfuscate.cpp Data : 08.09.14 Versione : 1.5i2
|
||||
// Contenuto : Funzioni per generare o eliminare confusione.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 08.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
|
||||
//------------------ Include -------------------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include "Obfuscate.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static const int LEN = 20 ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static char CharScramble( char cVal, char cOp) ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
MixMachineId( string& sMachineId)
|
||||
{
|
||||
// la stringa deve contenere 20 caratteri
|
||||
if ( sMachineId.length() != LEN)
|
||||
return false ;
|
||||
// eseguo miscelazione
|
||||
swap( sMachineId[7], sMachineId[14]) ;
|
||||
swap( sMachineId[1], sMachineId[8]) ;
|
||||
swap( sMachineId[2], sMachineId[16]) ;
|
||||
swap( sMachineId[10], sMachineId[17]) ;
|
||||
swap( sMachineId[4], sMachineId[11]) ;
|
||||
swap( sMachineId[5], sMachineId[19]) ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
ScrambleMachineId( string& sMachineId)
|
||||
{
|
||||
// la stringa deve contenere 20 caratteri
|
||||
if ( sMachineId.length() != LEN)
|
||||
return false ;
|
||||
// eseguo scrambling locale con caratteri fissi
|
||||
sMachineId[0] = CharScramble( sMachineId[0], '!') ;
|
||||
sMachineId[1] = CharScramble( sMachineId[1], 'g') ;
|
||||
sMachineId[2] = CharScramble( sMachineId[2], '}') ;
|
||||
sMachineId[3] = CharScramble( sMachineId[3], ')') ;
|
||||
sMachineId[4] = CharScramble( sMachineId[4], '<') ;
|
||||
sMachineId[5] = CharScramble( sMachineId[5], 'R') ;
|
||||
sMachineId[6] = CharScramble( sMachineId[6], '+') ;
|
||||
sMachineId[7] = CharScramble( sMachineId[7], 'c') ;
|
||||
sMachineId[8] = CharScramble( sMachineId[8], '?') ;
|
||||
sMachineId[9] = CharScramble( sMachineId[9], ':') ;
|
||||
sMachineId[10] = CharScramble( sMachineId[10], 'q') ;
|
||||
sMachineId[11] = CharScramble( sMachineId[11], 'H') ;
|
||||
sMachineId[12] = CharScramble( sMachineId[12], '%') ;
|
||||
sMachineId[13] = CharScramble( sMachineId[13], 'B') ;
|
||||
sMachineId[14] = CharScramble( sMachineId[14], 'f') ;
|
||||
sMachineId[15] = CharScramble( sMachineId[15], '&') ;
|
||||
sMachineId[16] = CharScramble( sMachineId[16], 't') ;
|
||||
sMachineId[17] = CharScramble( sMachineId[17], '{') ;
|
||||
sMachineId[18] = CharScramble( sMachineId[18], '@') ;
|
||||
sMachineId[19] = CharScramble( sMachineId[19], 'K') ;
|
||||
// eseguo scrambling
|
||||
for ( int i = 0 ; i < LEN ; ++ i) {
|
||||
int j = ((i - 1) >= 0 ? ( i - 1) : LEN - 1) ;
|
||||
sMachineId[i] = CharScramble( sMachineId[i], sMachineId[j]) ;
|
||||
}
|
||||
// sposto i caratteri
|
||||
for ( int i = 0 ; i < LEN ; ++ i) {
|
||||
int j = abs( ( (unsigned char)sMachineId[i] + 3 * i) % LEN) ;
|
||||
swap( sMachineId[i], sMachineId[j]) ;
|
||||
}
|
||||
// eseguo scrambling
|
||||
for ( int i = 0 ; i < LEN ; ++ i) {
|
||||
int j = ((i - 1) >= 0 ? ( i - 1) : LEN - 1) ;
|
||||
sMachineId[i] = CharScramble( sMachineId[i], sMachineId[j]) ;
|
||||
}
|
||||
// sposto i caratteri
|
||||
for ( int i = 0 ; i < LEN ; ++ i) {
|
||||
int j = abs( ( (unsigned char)sMachineId[i] + 3 * i) % LEN) ;
|
||||
swap( sMachineId[i], sMachineId[j]) ;
|
||||
}
|
||||
// eseguo scrambling
|
||||
for ( int i = 0 ; i < LEN ; ++ i) {
|
||||
int j = ((i - 1) >= 0 ? ( i - 1) : LEN - 1) ;
|
||||
sMachineId[i] = CharScramble( sMachineId[i], sMachineId[j]) ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
char
|
||||
CharScramble( char cVal, char cOp)
|
||||
{
|
||||
unsigned char cTmp = cVal ;
|
||||
// eseguo XOR bit a bit
|
||||
cTmp ^= cOp ;
|
||||
// limito il risultato tra 33 e 126 compresi
|
||||
if ( cTmp < 33)
|
||||
cTmp += 94 ;
|
||||
else if ( cTmp > 220)
|
||||
cTmp -= 188 ;
|
||||
else if ( cTmp > 126)
|
||||
cTmp -= 94 ;
|
||||
return cTmp ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// LenMask e Step devono essere primi tra loro e senza sottomultipli in comune :
|
||||
// con LenMask = 24, Step è bene sia 7 o 11, Step 9 non è efficiente.
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
ScrambleData( string& sData, const string& sMask, const int nStep)
|
||||
{
|
||||
// recupero la lunghezza delle due stringhe
|
||||
int nDLen = (int) sData.length() ;
|
||||
int nMLen = (int) sMask.length() ;
|
||||
// la maschera deve avere lunghezza non nulla
|
||||
if ( nMLen <= 0)
|
||||
return false ;
|
||||
// lo step deve essere positivo
|
||||
if ( nStep <= 0)
|
||||
return false ;
|
||||
// eseguo XOR e SUM-MOD tra i caratteri della stringa
|
||||
const int KVAL[] = {17,11,7,5,3,1} ;
|
||||
for ( int k = 0 ; k <= 6 - 1 ; ++ k) {
|
||||
for ( int i = 0 ; i <= nDLen - 1 ; ++ i) {
|
||||
int j = i + KVAL[k] ;
|
||||
if ( j < 0)
|
||||
j += nDLen ;
|
||||
else if ( j > nDLen - 1)
|
||||
j -= nDLen ;
|
||||
if ( ( k % 2) == 1)
|
||||
sData[i] ^= sData[j] ;
|
||||
else {
|
||||
int nTmp = (unsigned int)sData[i] + (unsigned int) sData[j] ;
|
||||
sData[i] = ( nTmp <= 255 ? nTmp : nTmp - 256) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// eseguo XOR bit a bit percorrendo la maschera a step ciclicamente
|
||||
for ( int i = 0 ; i < nDLen ; ++ i) {
|
||||
int j = ( i * nStep) % nMLen ;
|
||||
sData[i] ^= sMask[j] ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
UnScrambleData( string& sData, const string& sMask, const int nStep)
|
||||
{
|
||||
// recupero la lunghezza delle due stringhe
|
||||
int nDLen = (int) sData.length() ;
|
||||
int nMLen = (int) sMask.length() ;
|
||||
// la maschera deve avere lunghezza non nulla
|
||||
if ( nMLen <= 0)
|
||||
return false ;
|
||||
// lo step deve essere positivo
|
||||
if ( nStep <= 0)
|
||||
return false ;
|
||||
// eseguo XOR bit a bit percorrendo la maschera a step ciclicamente
|
||||
for ( int i = 0 ; i < nDLen ; ++ i) {
|
||||
int j = ( i * nStep) % nMLen ;
|
||||
sData[i] ^= sMask[j] ;
|
||||
}
|
||||
// eseguo XOR tra i caratteri della stringa
|
||||
const int KVAL[] = {17,11,7,5,3,1} ;
|
||||
for ( int k = 6 - 1 ; k >= 0 ; -- k) {
|
||||
for ( int i = nDLen - 1 ; i >= 0 ; -- i) {
|
||||
int j = i + KVAL[k] ;
|
||||
if ( j < 0)
|
||||
j += nDLen ;
|
||||
else if ( j > nDLen - 1)
|
||||
j -= nDLen ;
|
||||
if ( ( k % 2) == 1)
|
||||
sData[i] ^= sData[j] ;
|
||||
else {
|
||||
int nTmp = int( (unsigned int) sData[i]) - (unsigned int) sData[j] ;
|
||||
sData[i] = ( nTmp >= 0 ? nTmp : nTmp + 256) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : Obfuscate.h Data : 08.09.14 Versione : 1.5i2
|
||||
// Contenuto : Dichiarazione funzioni per Mix e Scramble.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 08.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
bool MixMachineId( std::string& sMachineId) ;
|
||||
bool ScrambleMachineId( std::string& sMachineId) ;
|
||||
bool ScrambleData( std::string& sData, const std::string& sMask, const int nStep) ;
|
||||
bool UnScrambleData( std::string& sData, const std::string& sMask, const int nStep) ;
|
||||
@@ -0,0 +1,97 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : RegForMachineId.cpp Data : 08.09.14 Versione : 1.5i2
|
||||
// Contenuto : Funzioni per salvataggio e lettura MachineId da Registry.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 08.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
//------------------ Include -------------------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include <windows.h>
|
||||
#include "RegForMachineId.h"
|
||||
#include "/EgtDev/Include/EGnStringConverter.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
#define RKEY_EGT_POS L"Software\\EgalTech\\Position"
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
LONG CreateAndSetKey( HKEY hKey, const wchar_t* wszSubKey, const wchar_t* wszValName, const wchar_t* wszVal) ;
|
||||
LONG GetKey( HKEY hKey, const wchar_t* wszSubKey, const wchar_t* wszValName, wchar_t* wszVal, DWORD* pdwLen) ;
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
bool
|
||||
SaveMachineIdOnReg( const string& sMachineId)
|
||||
{
|
||||
return ( CreateAndSetKey( HKEY_CURRENT_USER, RKEY_EGT_POS, L"", stringtoW( sMachineId)) == ERROR_SUCCESS) ;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
bool
|
||||
LoadMachineIdFromReg( string& sMachineId)
|
||||
{
|
||||
const int LEN_BUF = 50 ;
|
||||
wcharBuffer wBuffer( LEN_BUF) ;
|
||||
DWORD dwLen = LEN_BUF ;
|
||||
if ( GetKey( HKEY_CURRENT_USER, RKEY_EGT_POS, L"", wBuffer.data(), &dwLen) == ERROR_SUCCESS) {
|
||||
wBuffer.terminate( dwLen) ;
|
||||
sMachineId = wcharBtoA( wBuffer) ;
|
||||
return true ;
|
||||
}
|
||||
else {
|
||||
sMachineId.clear() ;
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
LONG
|
||||
CreateAndSetKey( HKEY hKey, const wchar_t* wszSubKey, const wchar_t* wszValName, const wchar_t* wszVal)
|
||||
{
|
||||
// creazione della chiave
|
||||
HKEY hSubKey ;
|
||||
LONG lResult = ::RegCreateKeyExW( hKey, wszSubKey, 0, NULL, REG_OPTION_NON_VOLATILE,
|
||||
KEY_WRITE | KEY_READ, NULL,
|
||||
&hSubKey, NULL) ;
|
||||
if ( lResult != ERROR_SUCCESS)
|
||||
return lResult ;
|
||||
|
||||
// assegnazione del valore
|
||||
lResult = ::RegSetValueExW( hSubKey, wszValName, 0, REG_SZ, (LPBYTE) wszVal, (DWORD) 2 * lstrlen( wszVal) + 2) ;
|
||||
|
||||
// rilascio l'handle alla chiave
|
||||
::RegCloseKey( hSubKey) ;
|
||||
|
||||
return lResult ;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
LONG
|
||||
GetKey( HKEY hKey, const wchar_t* wszSubKey, const wchar_t* wszValName, wchar_t* wszVal, DWORD* pdwLen)
|
||||
{
|
||||
// apro la chiave
|
||||
HKEY hSubKey ;
|
||||
LONG lResult = ::RegOpenKeyExW( hKey, wszSubKey, 0, KEY_READ, &hSubKey) ;
|
||||
if ( lResult != ERROR_SUCCESS)
|
||||
return lResult ;
|
||||
|
||||
// leggo il valore
|
||||
*pdwLen *= 2 ;
|
||||
lResult = ::RegQueryValueExW( hSubKey, wszValName, NULL, NULL, (LPBYTE) wszVal, pdwLen) ;
|
||||
*pdwLen /= 2 ;
|
||||
|
||||
// rilascio l'handle alla chiave
|
||||
::RegCloseKey( hSubKey) ;
|
||||
|
||||
return lResult ;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2014-2014
|
||||
//----------------------------------------------------------------------------
|
||||
// File : RegForMachineId.cpp Data : 10.09.14 Versione : 1.5i2
|
||||
// Contenuto : Dichiarazione funzioni per salvataggio/lettura MachineId da Registry.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 10.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
//-------------------------------------------------------------------------------
|
||||
bool SaveMachineIdOnReg( const std::string& sMachineId) ;
|
||||
bool LoadMachineIdFromReg( std::string& sMachineId) ;
|
||||
@@ -0,0 +1,8 @@
|
||||
// stdafx.cpp : file di origine che include solo le inclusioni standard
|
||||
// EgtLock.pch sarà l'intestazione precompilata
|
||||
// stdafx.obj conterrà le informazioni sui tipi precompilati
|
||||
|
||||
#include "stdafx.h"
|
||||
|
||||
// TODO: fare riferimento alle intestazioni aggiuntive necessarie in STDAFX.H
|
||||
// e non in questo file
|
||||
@@ -0,0 +1,29 @@
|
||||
// stdafx.h : file di inclusione per file di inclusione di sistema standard
|
||||
// o file di inclusione specifici del progetto utilizzati di frequente, ma
|
||||
// modificati raramente
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "/EgtDev/Include/EgtTargetVer.h"
|
||||
|
||||
// in Debug riconoscimento memory leakage
|
||||
#define _CRT_RAND_S
|
||||
#if defined( _DEBUG)
|
||||
#define _CRTDBG_MAP_ALLOC
|
||||
#include <stdlib.h>
|
||||
#include <crtdbg.h>
|
||||
#else
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
// in Debug controllo iteratori
|
||||
#if defined( _DEBUG)
|
||||
#define _SECURE_SCL 1
|
||||
#else
|
||||
#define _SECURE_SCL 0
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// TODO: fare riferimento qui alle intestazioni aggiuntive richieste dal programma
|
||||
Reference in New Issue
Block a user