Dario Sassi
198 lines
6.8 KiB
C++
198 lines
6.8 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 ;
|
|
}
|