Блог программистов

Здравствуйте, читатели блога программистов, сегодня я расскажу вам о недавно придуманном мною алгоритме шифрования данных при использовании, которого зашифрованные данные каждый раз получаются разными, при этом они никак не зависят от текущей даты, времени и других факторов. Изложенный в данной статье алгоритм идеально подходит для создания конфиденциальных каналов связи, при использовании которых критически важно, чтобы передаваемую информацию не мог узнать злоумышленник. Предупреждаю сразу: изложенный в данной статье алгоритм не претендует на звание самого лучшего, это всего лишь очередная вариация на тему шифрования данных, не исключено что он уже был придуман кем-то раньше.

  Итак, приступим! Первое что приходит в голову при шифровании данных это простая замена символов согласно некоторой таблице соответствия, а саму таблицу соответствия можно генерировать случайным образом. Недостаток этого метода очевиден: при относительно длинном размере зашифрованных данных, можно найти соответствие между исходными символами и замененными.
  Итак, простая замена символов не подходит. Вспоминается старый метод шифрования данных, которым наверно пользовались наши прадедушки. Например, есть два человека, которые хотят вести конфиденциальную переписку. У них есть две одинаковые книги. Каждый символ в передаваемом сообщении кодируется следующим образом: номер страницы, номер строки и номер символа в строке.
Таким образом, одна и та же буква может быть заменена несколькими разными цифровыми последовательностями. При правильном использовании такого метода шифрования возможность расшифровки передаваемых данных без искомой книги почти невозможна.
  А теперь вспомним первый алгоритм и сделаем выводы: таблиц соответствия должно быть несколько (не несколько, а много!). А заменять один символ мы будем не одним символом, а двумя: номером таблицы соответствия и номером заменяемого символа в таблице соответствия.
  Теперь перенесём алгоритм в проблематику информатики. Символом сообщения у нас будет байт. Байт может принимать значение 0-255, и заменён он может быть любым значением от нуля до 255. Таблицу соответствия будем называть кодовой страницей. Кодовых страниц у нас будет 256. Набор из 256 кодовых страниц будем называть книгой кодов. В результате при шифровке данных один байт исходных данных будет заменяться двумя: номером кодовой страницы и байтом соответствия на этой кодовой странице. При шифровке кодовая страница будет выбираться случайным образом, таким образом, каждый раз при шифровке один и тех же данных мы будем получать разные данные.
  Кодовая страница будет представлять собой массив из 256 байт. Чтобы получить байт-замену необходимо найти заменяемый байт в этом массиве. Индекс заменяемого байта и будет байтом-заменой. Например, у нас есть байт со значением 125, в кодовой странице он находится на 239 месте, следовательно, байт со значением 125 будет заменён байтом со значением 239. Поиск символа в 256 байтовом массиве это не очень быстрая операция, но зато операция расшифровки будет иметь довольно-таки высокую скорость.
  Как видно при использовании данного алгоритма размер данных увеличивается в два раза. При обеспечении конфиденциальности данных этот фактор не является решающим.
  Теория изложена, осталось написать программу, которая производит шифровку данных согласно вышеизложенному алгоритму.
  Для начала напишем функции, которые случайным образом будут генерировать кодовые страницы и книгу кодов.
  Функция CreateCodePage генерирует случайным образом кодовую страницу. Функция принимает один параметр – указатель на буфер.

void CreateCodePage(BYTE *Page)
{
    for (int i=1;i<256;i++)
    {
        int pos = rand()%256;
        if (Page[pos])
        {
            while ((Page[pos]) and (pos<255)) pos++;
            if (Page[pos])
            {
                pos=0;
                while ((Page[pos]) and (pos<255)) pos++;
            }
            Page[pos] = i;
        } else
        Page[pos]=i;
    }
}

Функция CreateCodeBookInBuffer создаёт 256 кодовых страниц, которые располагаются последовательно в буфере, указатель на который передаётся через единственный параметр.

void CreateCodeBookInBuffer(BYTE *Buffer)
{
    for (int i=0;i<256;i++)
    {
        CreateCodePage(Buffer+(i<<8));
    }
}

В данной функции непосвящённого программиста может сбить с толку битовый сдвиг влево на 8 бит. На месте битового сдвига должна стоять операция умножения на 256. Битовый сдвиг влево на 1 бит равносильно умножения на 2, на 2 бита равносильно умножению на 4, а сдвиг на 8 бит равносилен умножения на 256. Причина использования сдвига очень проста: операция битового сдвига производится быстрее, чем операция умножения, это знает любой, кто имеет опыт программирования на ассемблере.
  Функция CreateCodeBook создаёт книгу кодов и сохраняет её в файл.

bool CreateCodeBook(LPCTSTR FileName)
{
    BYTE* MemCodeBook = (BYTE*)VirtualAlloc(0, 0x10000, MEM_COMMIT + MEM_RESERVE, PAGE_READWRITE);
    CreateCodeBookInBuffer(MemCodeBook);

    HANDLE FH = CreateFile(FileName, GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS,0,0);
    if (FH==INVALID_HANDLE_VALUE) return false;
    DWORD Writed;
    WriteFile(FH,(void*)MemCodeBook,0x10000,&Writed,0);
    CloseHandle(FH);
    VirtualFree(MemCodeBook,0,MEM_RELEASE);
    return (Writed==0x10000);
}

  Итак, книгу кодов мы создали теперь надо написать функции, которые производят шифровку и расшифровку данных.

void CryptData(BYTE* CodeBook, BYTE *SourceBuff, int BuffSize, BYTE *DestBuff)
{
    BYTE CB, CCB;
    int CP;
    for(int i=0;i<BuffSize;i++)
    {
        CB = SourceBuff;
        CP = rand()%256;
        CCB =GetBytePos(CodeBook+(CP<<8),CB);
        DestBuff=CP;
        DestBuff[(i<<1)+1]=CCB;
    }
}

Функция элементарна: мы берём байт из исходных данных, генерируем случайным образом номер кодовой страницы, получаем индекс исходного байта на выбранной кодовой странице и записываем в результирующий буфер номер кодовой страницы и байт-замену на этой кодовой странице. Функция GetBytePos производит поиск байт в указанном буфере.
  Осталось написать функцию расшифровки, она ещё проще:

void DeCryptData(BYTE* CodeBook, BYTE *SourceBuff, BYTE *DestBuff, int BuffSize)
{
    BYTE CB, CCB;
    int CP;
    for(int i=0;i<BuffSize;i++)
    {
        CP=SourceBuff;
        CCB=SourceBuff[(i<<1)+1];
        CB = CodeBook[(CP<<8)+CCB];
        DestBuff=CB;
    }
}

Здесь тоже всё очень просто: извлекается два байта из исходных (зашифрованных) данных, первый байт это номер кодовой страницы второй это индекс на этой кодовой странице, в результирующий буфер заносится байт, находящийся на указанной кодовой странице по указанному индексу.
  Следующим шагом будет написание функций производящих шифрование файлов. Код функции, осуществляющий шифрование файлов тривиальный: считывается в память книга кодов, считывается в память исходный файл, зашифрованный данные записываются в результирующий файл.

bool CryptFile(LPCTSTR SourceFile, LPCTSTR DestFile, LPCTSTR CodeBookFile)
{
    HANDLE CBFH = CreateFile(CodeBookFile, GENERIC_READ, FILE_SHARE_READ,0,OPEN_EXISTING,0,0);
    if (CBFH==INVALID_HANDLE_VALUE) return false;
    int CBFS = GetFileSize(CBFH,0);
    if (CBFS!=0x10000)
    {
        CloseHandle(CBFH);
        return false;
    }

    HANDLE SFH = CreateFile(SourceFile, GENERIC_READ, FILE_SHARE_READ,0,OPEN_EXISTING,0,0);
    if (SFH==INVALID_HANDLE_VALUE) return false;
    HANDLE DFH = CreateFile(DestFile, GENERIC_WRITE, FILE_SHARE_READ,0,CREATE_ALWAYS,0,0);
    if (DFH==INVALID_HANDLE_VALUE) return false;


    BYTE* SourceBuff = (BYTE*)VirtualAlloc(0,BufferSize,MEM_COMMIT+MEM_RESERVE,PAGE_READWRITE);
    BYTE* DestBuff = (BYTE*)VirtualAlloc(0,BufferSize*2,MEM_COMMIT+MEM_RESERVE,PAGE_READWRITE);
    BYTE* CodeBook = (BYTE*)VirtualAlloc(0,0x10000,MEM_COMMIT+MEM_RESERVE,PAGE_READWRITE);

    DWORD Readed = 0;
    ReadFile(CBFH,CodeBook,0x10000,&Readed,0);
    CloseHandle(CBFH);

    DWORD Writed = 0;
    do
    {
        ReadFile(SFH,SourceBuff,BufferSize,&Readed,0);
        CryptData(CodeBook,SourceBuff,Readed,DestBuff);
        WriteFile(DFH,DestBuff,Readed*2,&Writed,0);

    }
    while (Readed==BufferSize);

    CloseHandle(SFH);
    CloseHandle(DFH);

    VirtualFree(SourceBuff,0,MEM_RELEASE);
    VirtualFree(DestBuff,0,MEM_RELEASE);
    VirtualFree(CodeBook,0,MEM_RELEASE);

    return true;
}

Следует подметить, что шифровка файла производится по порциям размером в 1 МБ, это обусловлено тем что при шифровке файлов большого размера (более 600 МБ), реальна ситуация нехватки виртуальной памяти. Функция расшифровки файлов аналогична вышеприведённой, приводить её здесь не имеет никакого смысла.
  Все вышеприведённые функции и вынесены в заголовочный файл (RDC.h), который вы можете подключить в своём проекте на С++. Также мною была создана DLL содержащая функции из RDC.h. Созданную DLL можно использовать в программах написанных на других языках. В качестве примера я написал программу на Delphi, которая производит шифрование файлов с использованием функций из RDC.DLL.
  Исходники RDC.DLL и программы производящей шифрование файлов с использованием RDC.DLL находятся в архиве, прилагающемся к данной статье.

Скачать исходники
1. Исходники RDC.DLL на С++ (CodeBlocks+MinGW)
2. Исходники программы использующей RDC.DLL (Delphi 7)

Вместо первого комментария:
Аббревиатура RDC расшифровывается следующим образом: Replace Data Crypt.