Потоковый шифр Rivest Cipher 4. Особенности алгоритма

                             MB_OK | MB_ICONERROR);

    return;

  }

  if (Edit1->Text == "")

  {

    Edit1->Text = "DefaultPassPhrase";

  }

  HANDLE out = CreateFile(pTo.c_str(), GENERIC_WRITE, 0, NULL,

                        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

  if (out == INVALID_HANDLE_VALUE)

  {

    Memo1->Lines->Add("..ошибка!");

    Application->MessageBox(("Не удалось открыть выходной файл: "+pTo).c_str(), "  Ошибка",

                             MB_OK | MB_ICONERROR);

    CloseHandle(in);

    return;

  }

  unsigned char buffer[4096];

  DWORD readed, written;

  while (true)

  {

    ReadFile(in, buffer, 4096, &readed, NULL);

    if (readed == 0) break;

    Memo1->Lines->Add("Считан блок");

    for (int i=0; i<readed; i++)

      buffer[i] = RC4_Transform(buffer[i]);

    Memo1->Lines->Add("Обработано "+IntToStr(readed)+" байт");

    WriteFile(out, buffer, readed, &written, NULL);

    Memo1->Lines->Add("Записан блок");

  }

  CloseHandle(out);

  CloseHandle(in);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::aEncryptExecute(TObject *Sender)

{

  if (OpenDialog1->Execute())

  {

    AnsiString Srce = OpenDialog1->FileName;

    AnsiString Dest = Srce + ".rc4";

    Memo1->Lines->Add("Начало зашифрования");

    ProcessFile(Srce, Dest);

    Memo1->Lines->Add("Зашифрование окончено");

  }

}

//---------------------------------------------------------------------------

void __fastcall TForm1::aDecryptExecute(TObject *Sender)

{

  if (OpenDialog2->Execute())

  {

    AnsiString Srce = OpenDialog2->FileName;

    AnsiString Dest = ChangeFileExt(Srce, "");

    Memo1->Lines->Add("Начало расшифрования");

    ProcessFile(Srce, Dest);

    Memo1->Lines->Add("Расшифрование окончено");

  }

}

Основной  алгоритм

#include "RC4Unit.h"

unsigned char RC4_S[256];       // Основная матрица преобразования

int RC4_i;                      // Счетчик "i"

int RC4_j;                      // Счетчик "j"

//---------------------------------------------------------------------------

//---- Процедура  инициализации матрицы преобразования

//---------------------------------------------------------------------------

//---- Параметры:

//----    Key           - указатель  на массив ключевой информации

//----    KeyLength     - длина массива  ключевой информации

//---------------------------------------------------------------------------

void __fastcall RC4_InitKey(unsigned char* Key, int KeyLength)

{

  // Обнуляем счетчик "i"

  RC4_i = 0;

  // Обнуляем счетчик "j"

  RC4_j = 0;

  // Обнуляем матрицу

  for (int i=0; i<256; i++)

  {

    RC4_S[i] = i;

  }

  // Обнуляем  временный счетчик "j"

  int j=0;

  // Для  каждого элемента матрицы

  for (int i=0; i<256; i++)

  {

    // Изменяем временный счетчик "j" в соответствии с алгоритмом

    // с использованием ключевой информации

    j = (j + Key[i % KeyLength] + RC4_S[i]) % 256;

    // переставляем местами S[i] и S[j]

    unsigned char temp = RC4_S[i];

    RC4_S[i] = RC4_S[j];

    RC4_S[j] = temp;

  }

}

//---------------------------------------------------------------------------

//---- Процедура  основного преобразования алгоритма

//---------------------------------------------------------------------------

//---- Параметры:

//----    nextByte     - байт для преобразования

//---- Результат:

//----    преобразованный байт

//---------------------------------------------------------------------------

//---- Hint: если nextByte == 0 (по умолчанию), возвращается  сама маска

//---------------------------------------------------------------------------

unsigned char __fastcall RC4_Transform(unsigned char nextByte)

{

  // Изменяем  счетчик "i" в соответствии  с алгоритмом

  RC4_i = (RC4_i + 1) % 256;

  // Изменяем  счетчик "j" в соответствии  с алгоритмом

  RC4_j = (RC4_j + RC4_S[RC4_i]) % 256;

  // Переставляем местами S[i] и S[j]

  unsigned char temp = RC4_S[RC4_i];

  RC4_S[RC4_i] = RC4_S[RC4_j];

  RC4_S[RC4_j] = temp;

  // Определяем маску в соответствии с алгоритмом

  temp = (RC4_S[RC4_i] + RC4_S[RC4_j]) % 256;

  // Накладываем маску на исходный байт по XOR

  return nextByte ^ RC4_S[temp];

}