kmzi2_feistel

#include "feistel.h"

extern size_t errorTimeCounter;

namespace feistel
{
     const std::vector<int8_t> spPermutation{ 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 };

     std::vector<uint8_t> GetKey()
     {
          std::string sKey;
          std::vector<uint8_t> vKey;

          std::cout << "Enter key: ";
          std::cin >> sKey;

          for (char& e : sKey)
          {
               vKey.push_back(static_cast<uint8_t>(e));
          }

          return vKey;
     }

     std::vector<std::vector<uint8_t>> CreateRoundKeys(const std::vector<uint8_t>& key)
     {
          const size_t halfWay = key.size() / 2;
          std::vector<uint8_t> theta1(key.begin(), key.begin() + halfWay);
          std::vector<uint8_t> theta2(key.begin() + halfWay, key.end());

          return std::vector<std::vector<uint8_t>>{theta1, theta2, theta1, theta2};
     }

     std::vector<uint8_t> SPNetwork(const std::vector<uint8_t> x2,
          const std::vector<uint8_t> roundKey)
     {
          std::vector<uint8_t> spResult(2);

          // XOR
          for (size_t i = 0; i < 2; ++i)
          {
               spResult[i] = x2[i] ^ roundKey[i];
          }

          // S - block
          uint8_t buffer = 0x0;
          uint8_t s1Result, s2Result, s3Result, s4Result;

          s1Result = spPermutation[spResult[0] >> 4];
          s2Result = spPermutation[spResult[0] & 0xF];
          s3Result = spPermutation[spResult[1] >> 4];
          s4Result = spPermutation[spResult[1] & 0xF];

          buffer = s1Result;
          buffer <<= 4;
          buffer += s2Result;
          spResult[0] = buffer;

          buffer = s3Result;
          buffer <<= 4;
          buffer += s4Result;
          spResult[1] = buffer;

          // P - block
          uint16_t pResult = 0x0;
          uint16_t largeBuf = spResult[0];
          largeBuf <<= 8;
          largeBuf += spResult[1];

          for (int bit = 32768, j = 0; bit >= 1; bit /= 2, j++)
          {
               if ((bit & largeBuf) == bit)
               {
                    int idx = (13 * j + 1) % 16;
                    pResult |= 32768 >> idx;
               }
          }

          spResult[0] = pResult >> 8;
          spResult[1] = pResult & 0xFF;

          return spResult;
     }

     void MakeWhitening(const std::vector<uint8_t> enteredKey, std::vector<uint8_t>& encryptedBlock)
     {
          std::vector<uint8_t> whiteKey;

          const size_t halfWay = enteredKey.size() / 2;

          std::vector<uint8_t> theta1(enteredKey.begin(), enteredKey.begin() + halfWay);
          std::vector<uint8_t> theta2(enteredKey.begin() + halfWay, enteredKey.end());

          whiteKey.push_back(theta1[0] ^ theta2[0]);
          whiteKey.push_back(theta1[1] ^ theta2[1]);
          whiteKey.push_back(whiteKey[0]);
          whiteKey.push_back(whiteKey[1]);

          for (size_t i = 0; i < encryptedBlock.size(); ++i)
          {
               encryptedBlock[i] ^= whiteKey[i];
          }
     }

     std::vector<uint8_t> FeistelXOR(const std::vector<uint8_t> x1, const std::vector<uint8_t> x2,
          const std::vector<uint8_t> roundKey)
     {
          std::vector<uint8_t> spResult = SPNetwork(x2, roundKey);
          std::vector<uint8_t> xorResult(2);

          for (size_t i = 0; i < 2; ++i)
          {
               xorResult[i] = spResult[i] ^ x1[i];
          }

          return xorResult;
     }

     std::vector<uint8_t> FeistelNetwork(const std::vector<uint8_t> block,
          const std::vector<std::vector<uint8_t>>& roundKeys)
     {
          const size_t halfWay = block.size() / 2;
          size_t roundCounter = 0;
          std::vector<uint8_t> encryptedBlock;

          std::vector<uint8_t> x1(block.begin(), block.begin() + halfWay);
          std::vector<uint8_t> x2(block.begin() + halfWay, block.end());

          // X2 || (X1 ^ f(X2))
          for (auto &roundKey: roundKeys)
          {
               // Шаблон раунда
               encryptedBlock.insert(encryptedBlock.begin(), x2.begin(), x2.end());
               std::vector<uint8_t> xorResult = FeistelXOR(x1, x2, roundKey);
               encryptedBlock.insert(encryptedBlock.end(), xorResult.begin(), xorResult.end());

               if (roundCounter == 3 || roundCounter == ::errorTimeCounter)
               {
                    return encryptedBlock;
               }

               // Меняем x1 и x2
               x1.clear(); x2.clear();

               x1.insert(x1.begin(), encryptedBlock.begin(), encryptedBlock.end() - halfWay);
               x2.insert(x2.begin(), encryptedBlock.begin() + halfWay, encryptedBlock.end());
               encryptedBlock.clear();

               ++roundCounter;
          }

          return encryptedBlock;
     }


     void EncryptFunction(const std::vector<uint8_t>& plainText, std::vector<uint8_t>& cipherText)
     {
          std::vector<uint8_t> enteredKey = GetKey();
          std::vector<std::vector<uint8_t>> roundKeys(4);

          roundKeys = CreateRoundKeys(enteredKey);

          for (size_t i = 0; i <= plainText.size() - 4 - (plainText.size()) % 4; i += 4)
          {
               std::vector<uint8_t> bufBlock = { plainText[i], plainText[i + 1],
                    plainText[i + 2], plainText[i + 3] };

               std::vector<uint8_t> encryptedBlock = FeistelNetwork(bufBlock, roundKeys);

               MakeWhitening(enteredKey, encryptedBlock);

               cipherText.insert(cipherText.end(), encryptedBlock.begin(), encryptedBlock.end());
          }

          size_t szAddBlock = 32;

          if (plainText.size() % 4 != 0)
          {
               szAddBlock = plainText.size() % 4;
               std::vector<uint8_t> bufBlock(plainText.end() - szAddBlock, plainText.end());

               while (bufBlock.size() != 4)
               {
                    bufBlock.push_back(static_cast<uint8_t>(0));
               }
               std::vector<uint8_t> encryptedBlock = FeistelNetwork(bufBlock, roundKeys);

               MakeWhitening(enteredKey, encryptedBlock);

               cipherText.insert(cipherText.end(), encryptedBlock.begin(), encryptedBlock.end());

               szAddBlock *= 8;
          }

          std::vector<uint8_t> addBlock(4);
          addBlock[0] = szAddBlock >> 24;
          addBlock[1] = (szAddBlock >> 16) & 0xFF;
          addBlock[2] = (szAddBlock >> 8) & 0xFF;
          addBlock[3] = szAddBlock & 0xFF;

          std::vector<uint8_t> encryptedBlock = FeistelNetwork(addBlock, roundKeys);

          MakeWhitening(enteredKey, encryptedBlock);

          cipherText.insert(cipherText.end(), encryptedBlock.begin(), encryptedBlock.end());

     }

     void DecryptFunction(std::vector<uint8_t>& plainText, const std::vector<uint8_t>& cipherText)
     {
          std::vector<uint8_t> enteredKey = GetKey();
          std::vector<std::vector<uint8_t>> roundKeys(4);

          roundKeys = CreateRoundKeys(enteredKey);
          std::reverse(roundKeys.begin(), roundKeys.end());

          //Decryption
          for (size_t i = 0; i <= cipherText.size() - 4; i+=4)
          {
               std::vector<uint8_t> encryptedBlock = { cipherText[i], cipherText[i + 1],
                    cipherText[i + 2], cipherText[i + 3] };

               MakeWhitening(enteredKey, encryptedBlock);

               std::swap(encryptedBlock[0], encryptedBlock[2]);
               std::swap(encryptedBlock[1], encryptedBlock[3]);

               encryptedBlock = FeistelNetwork(encryptedBlock, roundKeys);

               std::swap(encryptedBlock[0], encryptedBlock[2]);
               std::swap(encryptedBlock[1], encryptedBlock[3]);

               if (i == cipherText.size() - 4)
               {
                    size_t szAddBlock = 0;
                    for (size_t j = 0; j < 4; ++j)
                    {
                         szAddBlock += encryptedBlock[j];
                         szAddBlock <<= 8;
                    }
                    szAddBlock /= 8;

                    if (szAddBlock == 4)
                         return;

                    for (size_t j = 0; j < szAddBlock; ++j)
                    {
                         plainText.pop_back();
                    }
                    return;
               }
               plainText.insert(plainText.end(), encryptedBlock.begin(), encryptedBlock.end());
          }

     }



} ///< namespace feistel