EgtLock/Obfuscate.cpp

//----------------------------------------------------------------------------
//  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
MixLockId( 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
ScrambleLockId( 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 ;
}