Реализовать шифрование по госту 28147-89

//#define _CRT_SECURE_NO_DEPRECATE
#include "stdafx.h"
#include <stdio.h>
#include <conio.h>
 
    // таблица замен
    int TableChange[8][16] = {
        4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3,
        14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9,
        5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11,
        7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3,
        6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2,
        4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14,
        13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12,
        1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12};
 
    //ключ
    unsigned long key[8] = {
        0x0FAD,
        0x32CE,
        0x5555,
        0xDEFC,
        0xABCF,
        0xBA42,
        0x2808,
        0x2701};
////////////////////////////////////////////////////////////////
 
    char fileInput[] = "input.txt";
    char fileOut[] = "out.txt";
    char fileOutDesh[] = "outDesh.txt";
    FILE *inputFile, *outFile;
    bool kratno = true; //кратно ли число символов 8
    int blockNum; //число блоков
    long sizeF; //размер файла
    int num;
    unsigned char sym;
    int iData[64], Junior[32], Elder[32], kKey[32], sum232[32], Nak[8], Nak1[32], F[32];
    int SavB[32];
    int rejim;
 
/////////////////////////////////////////////////////////////////
 
long Pow(int, int); //возведение в степень
long FileSize(FILE*); //определение размера файла
long NumberOfBlock(FILE*, long); //определение числа блоков
void InputData(int*); //заполнение блока входными данными
void ZapJuniorAndElder(); //заполнение блока младших и старших битов
void ZapKey(int*); //последовательность ключей
void SUM232(); //сумматор по модулю 2^32
void ZamenaS(); //поблочная замена
void ZapNak(); //заполнение накопителя
void ZapNak1(); //заполнение накопителя N1
void Sdvig11(); //сдвиг на 11 бит влево
void SUM2(int*); //сложение по модулю 2
void SaveB(); //переписываем младшие биты на место старших
void Finalize(); //склеивание блоков старших и младших битов
void ExportResult(int*); //вывод результата в файл
void RejimWork(); //запрос режима работы
 
/////////////////////////////////////////////////////////////////
 
 
int main(int argc, char** argv)
{
    printf("\t     GOST 28147-89\n\tMode simple replacement\n\nShifrovanie   -> 1\nDeshifrovanie -> 2\n");
    RejimWork(); //запрос режима работы приложения
 
    blockNum = NumberOfBlock(inputFile, sizeF);
    for(int i = 0; i < blockNum; i++) //Заполнение всех блоков iData:
    {
        InputData(&i);
        ZapJuniorAndElder();
        for (int j = 1; j <= 32; j++)     //Начало основного цикла:
        {         
            ZapKey(&j);             //Заполнение ключа K
 
                                    //Функция Фейстеля:
            SUM232();               //1) Сумматор по модулю 2^32
            ZapNak();               //2) Заполнение накопителя
            ZamenaS();              //3) Проход через узлы замен
            ZapNak1();              //4) Заполнение выходного накопителя
            Sdvig11();              //5) Сдвиг на 11 битов влево    
                                    //Конец функции Фейстеля.
 
            for(int k = 0; k < 32; k++)   //Сохраняем блок
                SavB[k] = Junior[k];
                
            SUM2(&j);                //Двоичное исключающее "или" для Bi и F. Результат сохраняем в At+1
            SaveB();                 //Младшие биты -> старшие биты 
        }                            //Конец основного цикла.            
        Finalize();                  //Склеивание блоков
        ExportResult(&i);            //Вывод результата в файл
    }
    return 0;
}
 
long Pow(int number, int stepen){
    long result = 1;
    for (int i = 0; i < stepen; i++)
    {
        result *= number;
    }
 
    return result;
}
 
long FileSize(FILE* stream)
{
    long length; //длина файла
    long curpos; //позиция курсора
 
    curpos = ftell(stream);
    fseek(inputFile, 0L, SEEK_END);
    length = ftell(stream);
    fseek(inputFile, curpos, SEEK_SET);
 
    return length;
}
 
long NumberOfBlock(FILE* inputStream, long sizeF)
{
    sizeF = FileSize(inputStream);
    int NumBlock = sizeF / 8;
 
    if (sizeF%8 != 0)
    {
        NumBlock++;
        kratno = false;
    }
 
    return NumBlock;
}
 
void InputData(int* x)
{
    int ostf = FileSize(inputFile)%8;
 
    if ((*x == blockNum - 1) && (!kratno)) //Если идёт последний блок и число символов в файле не кратно 8
    {
        for (int i = 0; i < ostf; i++)
        {
            sym = fgetc(inputFile); //считываем посимвольно
            num = sym; //запоминаем номер символа
 
            for (int j = 0; j < 8; j++) //Заполняем блок битами символов
            {
                if (num / Pow(2,7-j) >= 1)
                {
                    iData[8*i+j] = 1;
                    num -= Pow(2,7-j);
                }
                else
                    iData[8*i+j] = 0;
            }
        }
        for (int i = 8*(ostf%8); i < 64; i++)
            iData[i] = 0;
    }
    else
    {
        for(int i = 0; i < 8; i++)
        {
            sym = fgetc(inputFile); //считываем посимвольно
            num = sym; //запоминаем номер символа
            for(int j = 0; j < 8; j++) //Заполняем блок битами символов
            {
                if(num / Pow(2,7-j) >= 1)
                {
                    iData[8*i+j] = 1;
                    num -= Pow(2,7-j);
                }
                else
                    iData[8*i+j] = 0;
            }
        }
    }
}
 
void ZapJuniorAndElder() //Заполнение блоков старших и младших битов
{
    for (int i = 0; i < 32; i++)
    {
        Junior[i] = iData[32+i]; 
        Elder[i] = iData[i];
    }
}
 
void ZapKey(int *kkey)
{
    unsigned long kk = 0;
    if (rejim == 1)
    {
        if ((*kkey >= 25) && (*kkey <= 32))
            kk = key[7-(*kkey-1)%8];
        else
            kk = key[(*kkey-1)%8];
    }
    if (rejim == 2)
    {
        if((*kkey >= 1) && (*kkey <= 8))
            kk = key[(*kkey-1)%8];
        else
            kk = key[7-(*kkey-1)%8];
    }
    for (int i = 0; i < 32; i++) //переводим ключ в биты
    {
        if ((kk / Pow(2,31-i)) >= 1)
        {
            kKey[i] = 1;
            kk -= Pow(2,31-i);
        }
        else
            kKey[i] = 0;
    }
}
 
void SUM232()
{
    for (int c=0, i = 31; i >= 0; i--)
    {
        if ((Junior[i] + kKey[i] + c) < 2)
        {
            sum232[i] = Junior[i] + kKey[i] + c; 
            c = 1;
        }
        else
        {
            sum232[i] = Junior[i] + kKey[i] + c - 2; 
            c = 0;
        }
    }
}
 
void ZamenaS()
{
    int s;
    for (int i = 0; i < 8; i++)
    {
        s = Nak[i];
        Nak[i] = TableChange[i][s]; //"прогоняем" накопитель через таблицу замен
    }
}
 
void ZapNak()
{
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            if(sum232[31-4*i-j] == 1)
                    Nak[i] += Pow(2,j);
        }
    }
}
 
void ZapNak1()
{
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            if (Nak[i] / Pow(2,3-j) >= 1)
            {
                Nak1[4*i+j] = 1;
                Nak[i] -= Pow(2,3-j);
            }
            else
                Nak1[4*i+j] = 0;
        }
    }
 
}
 
void Sdvig11()
{
    for(int i = 0; i < 21; i++)
    {
        F[i] = Nak1[i+11];          //Сохраняем биты с 12 по 32
    }
    for(int i = 0; i < 11; i++)
    {
        F[i+21] = Nak1[i];          //Сохраняем биты с 1 по 11
    }
}
 
void SUM2(int *sum)
{
    for (int i = 0; i < 32; i++)
        Junior[i] = F[i] ^ Elder[i]; //исключающее "ИЛИ"
}
 
void SaveB()
{
    for (int i = 0; i < 32; i++)
    {
         Elder[i] = SavB[i]; //старшие биты становятся младшими
    }
}
 
void Finalize() //склеивание блоков
{
    for (int i = 0; i < 32; i++)
        iData[i] = Junior[i];
    for (int i = 32; i < 64; i++)
        iData[i] = Elder[i-32];
}
 
void ExportResult(int *x)
{
    int tmp;
    if((*x == blockNum-1) && (!kratno) && (rejim == 2))    //Если последний блок, некратно и режим расшифрования, то
        tmp = FileSize(inputFile)%8;                         //выводим первые d = FileSize(inputFile)%8 символов.
    else                                                   //Иначе
        tmp = 8;                                               // выводим 8 символов
    for(int i = 0; i < tmp; i++)
    {
        num = 0;
        for(int j = 0; j < 8; j++) //Преобразование из 8 бит в соответствующий символ
            if (iData[8*i+j] == 1)
                num += Pow(2,7-j); 
        sym = num;
        fprintf(outFile, "%c", sym);
    }
}
void RejimWork()
{
    char rej;
    do{
        rej = _getch(); //выбор режима работы
    }while ((rej != '1') && (rej != '2'));
 
    if (rej == '1') //режим шифрования
    {
        rejim = 1;
        inputFile = fopen(fileInput, "rb");
        outFile = fopen(fileOut, "wb");
    }
    if (rej == '2') //режим расшифровки
    {
        rejim = 2;
        inputFile = fopen(fileOut, "rb");
        outFile = fopen(fileOutDesh, "wb");
    }
}