API tools faq
paste
thenuke321

Untitled

thenuke321
Jan 15th, 2016
248
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 6.45 KB | None | 0 0
raw download clone embed print report
  1. class stringTeaCypher
  2. {
  3.     private:
  4.     void decodeXtea(unsigned int* v, unsigned int* w, unsigned int* k) {
  5.         register unsigned int v0=v[0], v1=v[1], i, sum=0xC6EF3720;
  6.         register unsigned int delta=0x9E3779B9;
  7.         for(i=0; i<32; i++) {
  8.             v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
  9.             sum -= delta;
  10.             v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);
  11.         }
  12.         w[0]=v0; w[1]=v1;
  13.     }
  14.     void encodeXtea(unsigned int* v, unsigned int* w, unsigned int* k) {
  15.         register unsigned int v0=v[0], v1=v[1], i, sum=0;
  16.         register unsigned int delta=0x9E3779B9;
  17.         for(i=0; i<32; i++) {
  18.            v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);
  19.             sum += delta;
  20.             v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
  21.         }
  22.         w[0]=v0; w[1]=v1;
  23.     }
  24.     void TeaDecode ( const std::string& str, const std::string& key, std::string* out )
  25.     {
  26.         unsigned int v[2];
  27.         unsigned int w[2];
  28.         unsigned int k[4];
  29.         unsigned int keybuffer [ 4 ];
  30.  
  31.         // Clear buffers
  32.         memset ( v, 0, sizeof(v) );
  33.         memset ( w, 0, sizeof(w) );
  34.         memset ( k, 0, sizeof(k) );
  35.         memset ( keybuffer, 0, sizeof(keybuffer) );
  36.         out->clear ();
  37.  
  38.         // Count the number of passes that we need
  39.         int numBlocks = str.length() / 4;
  40.         int numPasses = numBlocks - 1;
  41.  
  42.         if ( numPasses <= 0 )
  43.             return;
  44.  
  45.         // Process the key
  46.         int len = key.length ();
  47.         if ( len > 16 )
  48.             len = 16;
  49.         memcpy ( keybuffer, key.c_str(), len );
  50.         for ( int i = 0; i < 4; ++i )
  51.             k[i] = keybuffer[i];
  52.  
  53.         // Create a temporary buffer to store the result
  54.         unsigned char* buffer = new unsigned char [ numPasses * 4 + 4 ];
  55.         memset ( buffer, 0, numPasses * 4 + 4 );
  56.  
  57.         // Decode it!
  58.         const char* p = str.c_str();
  59.         v[1] = *(unsigned int*)&p[numPasses * 4];
  60.         for ( int i = 0; i < numPasses; ++i )
  61.         {
  62.             v[0] = *(unsigned int*)&p[(numPasses-i-1)*4];
  63.             decodeXtea ( &v[0], &w[0], &k[0] );
  64.             *(unsigned int*)&buffer[(numPasses-i-1)*4] = w[0];
  65.             v[1] = w[1];
  66.         }
  67.  
  68.         out->assign ( (char *)buffer, numPasses*4 );
  69.         delete [] buffer;
  70.     }
  71.     void TeaEncode ( const std::string& str, const std::string& key, std::string* out )
  72.     {
  73.         unsigned int v[2];
  74.         unsigned int w[2];
  75.         unsigned int k[4];
  76.         unsigned int keybuffer [ 4 ];
  77.  
  78.         // Clear buffers
  79.         memset ( v, 0, sizeof(v) );
  80.         memset ( w, 0, sizeof(w) );
  81.         memset ( k, 0, sizeof(k) );
  82.         memset ( keybuffer, 0, sizeof(keybuffer) );
  83.         out->clear ();
  84.  
  85.         // Process the key
  86.         int len = key.length ();
  87.         if ( len > 16 )
  88.             len = 16;
  89.         memcpy ( keybuffer, key.c_str(), len );
  90.         for ( int i = 0; i < 4; ++i )
  91.             k[i] = keybuffer[i];
  92.  
  93.         // Copy the input string to a buffer of size multiple of 4
  94.         int strbuflen = str.length ();
  95.         if ( strbuflen == 0 )
  96.             return;
  97.         if ( (strbuflen % 4) > 0 )
  98.             strbuflen += 4 - (strbuflen % 4);
  99.         unsigned char* strbuf = new unsigned char [ strbuflen ];
  100.         memset ( strbuf, 0, strbuflen );
  101.         memcpy ( strbuf, str.c_str(), str.length() );
  102.  
  103.         // Encode it!
  104.         v[1] = 0;
  105.         for ( int i = 0; i < strbuflen; i += 4 )
  106.         {
  107.             v[0] = *(unsigned int*)&strbuf[i];
  108.  
  109.             encodeXtea ( &v[0], &w[0], &k[0] );
  110.             out->append ( (char*)&w[0], 4 );
  111.  
  112.             v[1] = w[1];
  113.         }
  114.         out->append ( (char*)&v[1], 4 );
  115.  
  116.         delete [] strbuf;
  117.     }
  118.     public:
  119.     void encode(string inString,string key,string &out)
  120.     {
  121.         TeaEncode(inString,key,&out);
  122.     }
  123.     void decode(string inString,string key,string &out)
  124.     {
  125.         TeaDecode(inString,key,&out);
  126.     }
  127. };
  128. // The other stuff put into a class
  129. class Core
  130. {
  131.     private:
  132.     string theMainBuffer;      
  133.     vector <string> ram;   
  134.     long int encodeSize,decodeSize,bufferSize;
  135.     string mode;
  136.     string key;
  137.     size_t count;  
  138.         int getSizeOfString(string theString)
  139.         {
  140.             return theString.length();
  141.         }
  142.         void cores(int rRam)
  143.         {
  144.             string ramTemp("");
  145.             //stringAesCypher Code;
  146.             stringTeaCypher Code;
  147.  
  148.             if(mode == "E")
  149.             {
  150.                 Code.encode(ram[rRam],key,ramTemp);
  151.             }
  152.             if(mode == "D")
  153.             {
  154.                 Code.decode(ram[rRam],key,ramTemp);
  155.             }
  156.             ram[rRam] = ramTemp;
  157.         }
  158.         void startCores()
  159.         {
  160.             thread t1(&Core::cores,this,0);
  161.             thread t2(&Core::cores,this,1);
  162.             thread t3(&Core::cores,this,2);
  163.             thread t4(&Core::cores,this,3);
  164.             thread t5(&Core::cores,this,4);
  165.             thread t6(&Core::cores,this,5);
  166.             thread t7(&Core::cores,this,6);
  167.             thread t8(&Core::cores,this,7);
  168.             t1.join();
  169.             t2.join();
  170.             t3.join();
  171.             t4.join();
  172.             t5.join();
  173.             t6.join();
  174.             t7.join();
  175.             t8.join();
  176.         }
  177.         vector<std::string> splitBreak(const std::string& str)
  178.         {
  179.             for(int i = 0; i != 8; i++){ram[i] = "";}
  180.             std::size_t n = 8;
  181.             if( n < 2 ) return { str } ;
  182.  
  183.             std::vector<std::string> fragments;
  184.  
  185.             const auto min_sz = str.size() / n ;
  186.             const auto excess_chars = str.size() % n ;
  187.             const auto max_sz = min_sz + 1 ;
  188.  
  189.             // the first excess_chars fragments have one character more
  190.             for( std::size_t i = 0 ; i < excess_chars ; ++i ) fragments.push_back( str.substr( i*max_sz, max_sz ) ) ;
  191.             for( std::size_t i = excess_chars ; i < n ; ++i ) fragments.push_back( str.substr( excess_chars + i*min_sz, min_sz ) ) ;
  192.             return fragments ;
  193.         }  
  194.         void unsplitData()
  195.         {
  196.             theMainBuffer = "";        
  197.             for(int i = 0; i != 8; i++)
  198.             {
  199.                 theMainBuffer.append(ram[i]);
  200.                 ram[i] = "";
  201.             }                                                  
  202.         }
  203.     public:
  204.     Core();
  205.         void setMode(string theMode)
  206.         {
  207.             mode = theMode;
  208.         }
  209.         void setKey(string theKey)
  210.         {
  211.             key = theKey;
  212.         }
  213.         void readFile(string inputFileName,string outputFileName)
  214.         {
  215.             int theSize(0);
  216.             if(mode == "E"){theSize = encodeSize;}
  217.             if(mode == "D"){theSize = decodeSize;}
  218.             // Size and file streams
  219.             ifstream fileStreamIn(inputFileName,ios::binary);
  220.             ofstream fileStreamOut(outputFileName,ios::binary);
  221.                 // The main loop
  222.                 while(fileStreamIn)
  223.                 {
  224.                     fileStreamIn.read(&theMainBuffer.front(),theSize);// Reads
  225.                     count = fileStreamIn.gcount();// Read ammount
  226.                     theMainBuffer.resize(count);
  227.                     ram = splitBreak(theMainBuffer);
  228.                     startCores();
  229.                     unsplitData();
  230.                    
  231.                     fileStreamOut.write(theMainBuffer.c_str(),theMainBuffer.length()); // write
  232.                     cout << "Data in flow " << count << " Data encoder outflow " << theMainBuffer.length() << endl;
  233.                 }
  234.             fileStreamIn.close();
  235.             fileStreamOut.close();
  236.         }
  237.  
  238. };
  239.  
  240. Core::Core()
  241. {
  242.     encodeSize = 256;
  243.     decodeSize = 288;
  244.     /*
  245.     Tea Large
  246.     encodeSize = 100000000;
  247.     decodeSize = 100000032;
  248.     */
  249.     /*
  250.     AES
  251.     encodeSize = 100000000;
  252.     decodeSize = 100000128;
  253.     */
  254.     //bufferSize = 100000138;
  255.     bufferSize = 360;
  256.     ram.resize(8);
  257.     theMainBuffer.resize(bufferSize);
  258. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!