Необработанное исключение

#include <fstream>
 
const int block_size = 8;
const int char_size = 8;
const int conversions = 8;
const int row = 4;
const int sizeB = 6;
const int col = 16;
const int rounds_count = 16;
const int key_len = 48;
const int Gcount = 56;
 
void GetCode(char c, int* block);
char GetChar(int* block);
int* LoadMatrix(char* path, int size);
int*** LoadFuncConversion();
int** LoadKey();
void Encryption(int* block, int** keys, int* ext, int*** conv, int* perm2);
int* EncrypFunc(int* right, int* key, int* ext, int*** conv, int* perm2);
 
#define ENC
 
int main(int argc, char* argv[])
{
#ifdef ENC
    std::ifstream in("opentext.txt", std::ios::binary);
    std::ofstream out("enc.txt", std::ios::binary);
#else
    std::ifstream in("enc.txt", std::ios::binary);
    std::ofstream out("dec.txt", std::ios::binary);
#endif
 
    if (in.is_open())
    {
        // Узнаем количество символов в исходном сообщении
        in.seekg(0, in.end);
        int length = static_cast<int>(in.tellg());
        in.seekg(0, in.beg);
 
        // Считываем все перестановки из файлов
        int* init = LoadMatrix("init.txt", block_size * char_size);
        int* fin = LoadMatrix("final.txt", block_size * char_size);
        int* perm2 = LoadMatrix("perm2.txt", block_size * char_size / 2);
 
        // Считываем расширитель из файла
        int* ext = LoadMatrix("exten.txt", key_len);
 
        // Считываем функции преобразования из файла
        int*** conv = LoadFuncConversion();
 
        // Считываем ключ из файла
        int** keys = LoadKey();
 
        // Работаем только с блоками по 8 символов (64 бита)
        while (length >= block_size)
        {
            // Читаем очередную порцию
            char* block = new char[block_size];
            in.read(block, block_size);
 
            // Заполняем блок двоичным представлением
            int size = block_size * char_size;
            int* working_block = new int[size];
            for (int i = 0; i < block_size; ++i)
            {
                GetCode(block[i], &working_block[i * char_size]);
            }
 
            // Начальная перестановка
            int* temp = new int[size];
            memcpy(temp, working_block, size * sizeof(int));
            for (int i = 0; i < size; ++i)
            {
                working_block[i] = temp[init[i] - 1];
            }
            delete[] temp;
 
            // Шифрование
            Encryption(working_block, keys, ext, conv, perm2);
 
            // Конечная перестановка
            temp = new int[size];
            memcpy(temp, working_block, size * sizeof(int));
            for (int i = 0; i < size; ++i)
            {
                working_block[i] = temp[fin[i] - 1];
            }
            delete[] temp;
 
            // Вывод шифротекста в файл
            for (int i = 0; i < block_size; ++i)
            {
                out << GetChar(&working_block[i * char_size]);
            }
 
            delete[] working_block;
            delete[] block;
 
            length -= block_size;
        }
 
        // Если последний блок меньше чем 64 бита
        if (length)
        {
            char* block = new char[length];
            in.read(block, length);
 
            // Заполняем массив двоичным представлением
            int* working_block = new int[length * char_size];
            for (int i = 0; i < length; ++i)
            {
                GetCode(block[i], &working_block[i * char_size]);
            }
 
            // Вывод шифротекста в файл
            for (int i = 0; i < length; ++i)
            {
                out << GetChar(&working_block[i * char_size]);
            }
 
            delete[] working_block;
            delete[] block;
        }
 
        delete[] init;
        delete[] fin;
        delete[] perm2;
        delete[] ext;
        for (int i = 0; i < conversions; ++i)
        {
            for (int j = 0; j < row; ++j)
            {
                delete[] conv[i][j];
            }
            delete[] conv[i];
        }
        delete[] conv;
        for (int i = 0; i < rounds_count; ++i)
        {
            delete[] keys[i];
        }
        delete[] keys;
    }
 
    out.close();
    in.close();
 
    return 0;
}
 
void GetCode(char c, int* block)
{
    for (int i = 0; i < char_size; ++i)
    {
        block[char_size - i - 1] = (c & static_cast<int>(pow(2.0, i))) ? 1 : 0;
    }
}
 
char GetChar(int* block)
{
    char c = 0;
    for (int i = 0; i < char_size; ++i)
    {
        c += block[i] * static_cast<char>(pow(2.0, char_size - i - 1));
    }
    return c;
}
 
int* LoadMatrix(char* path, int size)
{
    std::ifstream in(path, std::ios::in);
    int* temp = new int[size];
    for (int i = 0; i < size; ++i)
    {
        in >> temp[i];
    }
    in.close();
    return temp;
}
 
int*** LoadFuncConversion()
{
    std::ifstream in("convers.txt", std::ios::in);
    int*** conv = new int**[conversions];
    for (int i = 0; i < conversions; ++i)
    {
        conv[i] = new int*[row];
        for (int j = 0; j < row; ++j)
        {
            conv[i][j] = new int[col];
            for (int k = 0; k < col; ++k)
            {
                in >> conv[i][j][k];
            }
        }
    }
    in.close();
    return conv;
}
 
int** LoadKey()
{
    std::ifstream in("key.txt", std::ios::binary);
    std::ifstream shift("shift.txt", std::ios::in);
    std::ifstream permG("permG.txt", std::ios::in);
    std::ifstream kp("keyPerm.txt", std::ios::in);
 
    // Считываем ключ из файла
    char* block = new char[block_size];
    in.read(block, block_size);
    
    // Переводим в двоичное представление
    int* key = new int[block_size * char_size];
    for (int i = 0; i < block_size; ++i)
    {
        GetCode(block[i], &key[i * char_size]);
    }
    delete[] block;
 
    // Перестановка G
    int* G = new int[Gcount];
    for (int i = 0; i < Gcount; ++i)
    {
        int index;
        permG >> index;
        G[i] = key[index - 1];
    }
    delete[] key;
 
    // Разбиваем на левую и правую части
    int size = Gcount / 2;
    int* left = new int[size];
    int* right = new int[size];
    for (int i = 0; i < size; ++i)
    {
        left[i] = G[i];
        right[i] = G[size + i];
    }
 
    // Запоминаем правило перестановки KP
    int* kp_ = new int[key_len];
    for (int i = 0; i < key_len; ++i)
    {
        kp >> kp_[i];
    }
 
    // Заполняем массив ключей
    int** keys = new int*[rounds_count];
    for (int i = 0; i < rounds_count; ++i)
    {
        // Считываем сдвиг
        int shift_;
        shift >> shift_;
 
        // Выполняем циклический сдвиг влево
        int* tmp_l = new int[shift_];
        int* tmp_r = new int[shift_];
        for (int j = 0; j < shift_; ++j)
        {
            tmp_l[j] = left[j];
            tmp_r[j] = right[j];
        }
        for (int j = shift_; j < size; ++j)
        {
            left[j - shift_] = left[j];
            right[j - shift_] = right[j];
        }
        for (int j = 0; j < shift_; ++j)
        {
            left[size - shift_ + j] = tmp_l[j];
            right[size - shift_ + j] = tmp_r[j];
        }
        delete[] tmp_l;
        delete[] tmp_r;
 
        // Перестановка KP - формирование i-го ключа
        for (int j = 0; j < size; ++j)
        {
            G[j] = left[j];
            G[size + j] = right[j];
        }       
        keys[i] = new int[key_len];
        for (int j = 0; j < key_len; ++j)
        {
            keys[i][j] = G[kp_[j] - 1];
        }
    }
 
    delete[] kp_;
    delete[] G;
    delete[] left;
    delete[] right;
    kp.close();
    permG.close();
    shift.close();
    in.close();
 
    return keys;
}
 
void Encryption(int* block, int** keys, int* ext, int*** conv, int* perm2)
{
    // Формируем левую и правую части
    int size = block_size * char_size / 2;
    int* left = new int[size];
    int* right = new int[size];
    for (int i = 0; i < size; ++i)
    {
        left[i] = block[i];
        right[i] = block[size + i];
    }
 
#ifdef ENC
    // Выполняем 15 раундов с перемешиванием
    for (int i = 0; i < rounds_count - 1; ++i)
    {
        // Функция шифрования
        int* func = EncrypFunc(right, keys[i], ext, conv, perm2);
 
        // Подстановка новых битов
        for (int j = 0; j < size; ++j)
        {
            int transfer = right[j];
            right[j] = left[j] ^ func[j];
            left[j] = transfer;
        }
 
        delete[] func;
    }
 
    // Последний раунд без перемешивания
    int* func = EncrypFunc(right, keys[rounds_count - 1], ext, conv, perm2);
 
    for (int j = 0; j < size; ++j)
    {
        left[j] ^= func[j];
    }
    delete[] func;
#else
    // Первый раунд без перемешивания
    int* func = EncrypFunc(right, keys[rounds_count - 1], ext, conv, perm2);
 
    for (int j = 0; j < size; ++j)
    {
        left[j] ^= func[j];
    }
    delete[] func;
 
    // Следующие 15 раундов с перемешиванием
    for (int i = 0; i < rounds_count - 1; ++i)
    {
        // Функция шифрования
        int* func = EncrypFunc(left, keys[rounds_count - i - 2], ext, conv, perm2);
 
        // Подстановка новых битов
        for (int j = 0; j < size; ++j)
        {
            int transfer = left[j];
            left[j] = right[j] ^ func[j];
            right[j] = transfer;
        }
 
        delete[] func;
    }
#endif
 
    // Формируем зашифрованный блок
    for (int i = 0; i < size; ++i)
    {
        block[i] = left[i];
        block[size + i] = right[i];
    }
 
    delete[] right;
    delete[] left;
}
 
int* EncrypFunc(int* right, int* key, int* ext, int*** conv, int* perm2)
{
    // Расширение блока с 32 бит до 48 бит
    int* block = new int[key_len];
    for (int i = 0; i < key_len; ++i)
    {
        block[i] = right[ext[i] - 1];
    }
 
    // Преобразование расширеннного блока и ключа в подблоки
    int** B = new int*[conversions];
    for (int i = 0; i < conversions; ++i)
    {
        B[i] = new int[sizeB];
        for (int j = 0; j < sizeB; ++j)
        {
            B[i][j] = block[i * sizeB + j] ^ key[i * sizeB + j];
        }
    }
    delete[] block;
 
    // Преобразование подблоков в 32-битную последовательность
    int size = block_size * char_size / 2;
    int* temp = new int[size];
    for (int i = 0; i < conversions; ++i)
    {
        int r, c;
        r = B[i][0] * 2 + B[i][5];
        c = B[i][1] * 8 + B[i][2] * 4 + B[i][3] * 2 + B[i][4];
        int s = conv[i][r][c];
        temp[i * 4] = s / 8;
        s %= 8;
        temp[i * 4 + 1] = s / 4;
        s %= 4;
        temp[i * 4 + 2] = s / 2;
        s %= 2;
        temp[i * 4 + 3] = s;
    }
 
    for (int i = 0; i < conversions; ++i)
    {
        delete[] B[i];
    }
    delete[] B;
 
    // Перестановка P2
    int* func = new int[size];
    for (int i = 0; i < size; ++i)
    {
        func[i] = temp[perm2[i] - 1];
    }
    delete[] temp;
 
    return func;
}