Форумы на Хакер

Добро пожаловать! Это — архивная версия форумов на «Хакер.Ru». Она работает в режиме read-only.

Алгоритмы шифрование, Выручайте, пожалуйста?

Пользователи, просматривающие топик: none

Зашли как: Guest

Все форумы >> [Компилируемые языки] >> Алгоритмы шифрование, Выручайте, пожалуйста?

Имя

Сообщение

<< Старые топики Новые топики >>

Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-05-10 15:10:36.293333

kairat

Сообщений: 2
Оценки: 0
Присоединился: 2007-05-10 14:18:34.500000

Любой алгоритм с исходником (желательно на Delphi)

Post #: 1

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-05-10 15:13:15.966666

kairat

Сообщений: 2
Оценки: 0
Присоединился: 2007-05-10 14:18:34.500000

Любой алгоритм с исходником (желательно на Delphi). Заранее спосибо!

Post #: 2

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-05-10 15:33:38.693333

blacksun

Сообщений: 2360
Оценки: 0
Присоединился: 2006-09-27 03:05:59.350000

RC6:


 unit RC6;
 
 interface
 
 uses
   SysUtils, Classes;
 
 const
   Rounds    = 20;
   KeyLength = 2 * (Rounds + 2);
 
   BlockSize = 16;
   KeySize   = 16 * 4;
 
   P32       = $b7e15163;
   Q32       = $9e3779b9;
   lgw       = 5;
 
 type
   TRC6Block = array[1..4] of LongWord;
 
 var
   S      : array[0..KeyLength-1] of LongWord;
   Key    : string;
   KeyPtr : PChar;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Дополнительные функции
 
 procedure Initialize(AKey: string);          // Инициализация
 procedure CalculateSubKeys;                  // Подготовка подключей
 function EncipherBlock(var Block): Boolean;  // Шифрация блока (16 байт)
 function DecipherBlock(var Block): Boolean;  // Дешифрация блока
 
 ////////////////////////////////////////////////////////////////////////////////
 // Главные функции
 
 function EncryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;    // Зашифровать данные из одного потока в другой
 
 function DecryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;    // Расшифровать данные из одного потока в другой
 
 function EncryptStream(DataStream: TStream; Count: Int64;
   Key: string): Boolean;     // Зашифровать содержимое потока
 
 function DecryptStream(DataStream: TStream; Count: Int64;
   Key: string): Boolean;     // Расшифровать содержимое потока
 
 implementation
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function ROL(a, s: LongWord): LongWord;
 asm
   mov    ecx, s
   rol    eax, cl
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function ROR(a, s: LongWord): LongWord;
 asm
   mov    ecx, s
   ror    eax, cl
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure InvolveKey;
 var
   TempKey : string;
   i, j    : Integer;
   K1, K2  : LongWord;
 begin
  // Разворачивание ключа до длинны KeySize = 64
  TempKey := Key;
  i := 1;
  while ((Length(TempKey) mod KeySize) &lt;&gt; 0) do
    begin
      TempKey := TempKey + TempKey[i];
      Inc(i);
    end;
 
  i := 1;
  j := 0;
  while (i &lt; Length(TempKey)) do
    begin
      Move((KeyPtr+j)^, K1, 4);
      Move(TempKey[i], K2, 4);
      K1 := ROL(K1, K2) xor K2;
      Move(K1, (KeyPtr+j)^, 4);
      j := (j + 4) mod KeySize;
      Inc(i, 4);
    end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure CalculateSubKeys;
 var
   i, j, k : Integer;
   L       : array[0..15] of LongWord;
   A, B	 : LongWord;
 begin
  // Копирование ключа в L
  Move(KeyPtr^, L, KeySize);
 
  // Инициализация подключа S
  S[0] := P32;
  for i := 1 to KeyLength-1 do
    S[i] := S[i-1] + Q32;
 
  // Смешивание S с ключом
  i := 0;
  j := 0;
  A := 0;
  B := 0;
  for k := 1 to 3*KeyLength do
    begin
      A := ROL((S[i] + A + B), 3);
      S[i] := A;
      B := ROL((L[j] + A + B), (A + B));
      L[j] := B;
      i := (i + 1) mod KeyLength;
      j := (j + 1) mod 16;
    end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure Initialize(AKey: string);
 begin
  GetMem(KeyPtr, KeySize);
  FillChar(KeyPtr^, KeySize, #0);
  Key := AKey;
 
  InvolveKey;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function EncipherBlock(var Block): Boolean;
 var
   RC6Block : TRC6Block absolute Block;
   i	   : Integer;
   t, u	   : LongWord;
   Temp	   : LongWord;
 begin
  // Инициализация блока
  Inc(RC6Block[2], S[0]);
  Inc(RC6Block[4], S[1]);
 
  for i := 1 to Rounds do
    begin
      t := ROL((RC6Block[2] * (2*RC6Block[2] + 1)), lgw);
      u := ROL((RC6Block[4] * (2*RC6Block[4] + 1)), lgw);
      RC6Block[1] := ROL((RC6Block[1] xor t), u) + S[2*i];
      RC6Block[3] := ROL((RC6Block[3] xor u), t) + S[2*i+1];
 
      Temp := RC6Block[1];
      RC6Block[1] := RC6Block[2];
      RC6Block[2] := RC6Block[3];
      RC6Block[3] := RC6Block[4];
      RC6Block[4] := Temp;
    end;
 
  RC6Block[1] := RC6Block[1] + S[2*Rounds+2];
  RC6Block[3] := RC6Block[3] + S[2*Rounds+3];
 
  Result := TRUE;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function DecipherBlock(var Block): Boolean;
 var
   RC6Block : TRC6Block absolute Block;
   i	   : Integer;
   t, u	   : LongWord;
   Temp	   : LongWord;
 begin
  // Инициализация блока
  RC6Block[3] := RC6Block[3] - S[2*Rounds+3];
  RC6Block[1] := RC6Block[1] - S[2*Rounds+2];
 
  for i := Rounds downto 1 do
    begin
      Temp := RC6Block[4];
      RC6Block[4] := RC6Block[3];
      RC6Block[3] := RC6Block[2];
      RC6Block[2] := RC6Block[1];
      RC6Block[1] := Temp;
 
      u := ROL((RC6Block[4] * (2*RC6Block[4] + 1)),lgw);
      t := ROL((RC6Block[2] * (2*RC6Block[2] + 1)),lgw);
      RC6Block[3] := ROR((RC6Block[3]-S[2*i+1]), t) xor u;
      RC6Block[1] := ROR((RC6Block[1]-S[2*i]), u) xor t;
    end;
 
  Dec(RC6Block[4], S[1]);
  Dec(RC6Block[2], S[0]);
 
  Result := TRUE;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Реализация главных функций
 
 function EncryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;
 var
   Buffer   : TRC6Block;
   PrCount  : Int64;
   AddCount : Byte;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DestStream.CopyFrom(SourseStream, Count);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= BlockSize do
      begin
        SourseStream.Read(Buffer, BlockSize);
        EncipherBlock(Buffer);
        DestStream.Write(Buffer, BlockSize);
        Inc(PrCount, BlockSize);
      end;
 
    AddCount := Count - PrCount;
    if Count - PrCount &lt;&gt; 0 then
      begin
        SourseStream.Read(Buffer, AddCount);
        DestStream.Write(Buffer, AddCount);
      end;
  except
    Result := False;
  end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function DecryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;
 var
   Buffer   : TRC6Block;
   PrCount  : Int64;
   AddCount : Byte;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DestStream.CopyFrom(SourseStream, Count);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= BlockSize do
      begin
        SourseStream.Read(Buffer, BlockSize);
        DecipherBlock(Buffer);
        DestStream.Write(Buffer, BlockSize);
        Inc(PrCount, BlockSize);
      end;
 
    AddCount := Count - PrCount;
    if Count - PrCount &lt;&gt; 0 then
      begin
        SourseStream.Read(Buffer, AddCount);
        DestStream.Write(Buffer, AddCount);
      end;
  except
    Result := False;
  end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function EncryptStream(DataStream: TStream; Count: Int64; Key: string): Boolean;
 var
   Buffer   : TRC6Block;
   PrCount  : Int64;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DataStream.Seek(Count, soFromCurrent);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= BlockSize do
      begin
        DataStream.Read(Buffer, BlockSize);
        EncipherBlock(Buffer);
        DataStream.Seek(-BlockSize, soFromCurrent);
        DataStream.Write(Buffer, BlockSize);
        Inc(PrCount, BlockSize);
      end;
  except
    Result := False;
  end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function DecryptStream(DataStream: TStream; Count: Int64; Key: string): Boolean;
 var
   Buffer   : TRC6Block;
   PrCount  : Int64;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DataStream.Seek(Count, soFromCurrent);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= BlockSize do
      begin
        DataStream.Read(Buffer, BlockSize);
        DecipherBlock(Buffer);
        DataStream.Seek(-BlockSize, soFromCurrent);
        DataStream.Write(Buffer, BlockSize);
        Inc(PrCount, BlockSize);
      end;
  except
    Result := False;
  end;
 end;
 
 // Завершение главных функций ...
 ////////////////////////////////////////////////////////////////////////////////
 
 end.

IDEA:


 unit IDEA;
 
 interface
 
 uses
   SysUtils, Classes, Math;
 
 const
   Rounds    = 8;
   KeyLength = (Rounds * 6) + 4;
   Maxim     = 65537;
 
 type
   TIDEAKey   = array[0..KeyLength-1] of Word;
   TIDEABlock = array[1..4] of Word;
 
 var
   Z : TIDEAKey;
   K : TIDEAKey;
 
   FBlockSize  : Integer;
   FKey        : string;
   FBufferSize : Integer;
   FKeySize    : Integer;
   FKeyPtr     : PChar;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Дополнительные функции
 
 procedure Initialize(AKey: string);           // Инициализация
 procedure CalculateSubKeys;                   // Подготовка подключей
 function  EncipherBlock(var Block): Boolean;  // Шифрация блока (8 байт) 
 function  DecipherBlock(var Block): Boolean;  // Дешифрация блока
 
 ////////////////////////////////////////////////////////////////////////////////
 // Основные функции
 
 function EncryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;    // Зашифровать данные из одного потока в другой
   
 function DecryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;    // Расшифровать данные из одного потока в другой
 
 function EncryptStream(DataStream: TStream; Count: Int64;
   Key: string): Boolean;     // Зашифровать содержимое потока
 
 function DecryptStream(DataStream: TStream; Count: Int64;
   Key: string): Boolean;     // Расшифровать содержимое потока
 
 implementation
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function ROL(a, s: LongWord): LongWord;
 asm
   mov    ecx, s
   rol    eax, cl
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure InvolveKey;
 var
   TempKey : string;
   i, j    : Integer;
   K1, K2  : LongWord;
 begin
  // Разворачивание ключа до длинны 51 символ
  TempKey := FKey;
  i := 1;
  while ((Length(TempKey) mod FKeySize) &lt;&gt; 0) do
    begin
      TempKey := TempKey + TempKey[i];
      Inc(i);
    end;
 
  // Now shorten the key down to one KeySize block by combining the bytes
  i := 1;
  j := 0;
  while (i &lt; Length(TempKey)) do
    begin
      Move((FKeyPtr+j)^, K1, 4);
      Move(TempKey[i], K2, 4);
      K1 := ROL(K1, K2) xor K2;
      Move(K1, (FKeyPtr+j)^, 4);
      j := (j + 4) mod FKeySize;
      Inc(i, 4);
    end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 {$R-,Q-}
 procedure ExpandKeys;
 var
   i : Integer;
 begin
  // Копирование ключа в Z
  Move(FKeyPtr^, Z, FKeySize);
 
  // Генерация подключа зашифрование
  for i := 8 to KeyLength-1 do
    begin
      if (((i+2) mod 8) = 0) then Z[i] := (Z[i- 7] shl 9) xor (Z[i-14] shr 7)
        else if (((i+1) mod 8) = 0) then Z[i] := (Z[i-15] shl 9) xor (Z[i-14] shr 7)
 	 else Z[i] := (Z[i- 7] shl 9) xor (Z[i- 6] shr 7);
    end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure InvertKeys;
 type
   PWord	= ^Word;
 var
   j          : Integer;
   pz, pp     : PWord;
   t1, t2, t3 : Word;
 
 ////////////////////////////////////////
 
   function Inv(I: Integer): Integer;
   var
     n1, n2, q, r, b1, b2, t : Integer;
   begin
    if (I = 0) then
      Result := 0 else
        begin
          n1 := Maxim;
          n2 := I;
          b2 := 1;
          b1 := 0;
          repeat
          r := (n1 mod n2);
          q := (n1-r) div n2;
          if (r = 0) then
            begin
              if (b2 &lt; 0) then b2 := Maxim + b2;
            end else
                begin
                  n1 := n2;
                  n2 := r;
                  t  := b2;
                  b2 := b1 - q * b2;
                  b1 := t;
                end;
          until (r = 0);
          Result := b2;
        end;
   Result := (Result and $ffff);
   end;
 
 ////////////////////////////////////////
 
 begin
     pz := @Z;
     pp := @K;
     Inc(pp, KeyLength);
 
 //  t1 = inv(*Z++);
     t1 := Inv(pz^);
     Inc(pz);
 
 //  t2 = -*Z++;
     t2 := -pz^;
     Inc(pz);
 
 //  t3 = -*Z++;
     t3 := -pz^;
     Inc(pz);
 
 //  *--p = inv(*Z++);
     Dec(pp);
     pp^ := Inv(pz^);
     Inc(pz);
 
 //  *--p = t3;
     Dec(pp);
     pp^ := t3;
 
 //  *--p = t2;
     Dec(pp);
     pp^ := t2;
 
 //  *--p = t1;
     Dec(pp);
     pp^ := t1;
 
     for j := 1 to Rounds-1 do
       begin
 //      t1 = *Z++;
         t1 := pz^;
         Inc(pz);
 
 //      *--p = *Z++;
         Dec(pp);
         pp^ := pz^;
         Inc(pz);
 
 //      *--p = t1;
         Dec(pp);
         pp^ := t1;
 
 //      t1 = inv(*Z++);
         t1 := Inv(pz^);
         Inc(pz);
 
 //      t2 = -*Z++;
         t2 := -pz^;
         Inc(pz);
 
 //      t3 = -*Z++;
         t3 := -pz^;
         Inc(pz);
 
 //      *--p = inv(*Z++);
         Dec(pp);
         pp^ := Inv(pz^);
         Inc(pz);
 
 //      *--p = t2;
         Dec(pp);
         pp^ := t2;
 
 //      *--p = t3;
         Dec(pp);
         pp^ := t3;
 
 //      *--p = t1;
         Dec(pp);
         pp^ := t1;
       end;
 
 //  t1 = *Z++;
     t1 := pz^;
     Inc(pz);
 
 //  *--p = *Z++;
     Dec(pp);
     pp^ := pz^;
     Inc(pz);
 
 //  *--p = t1;
     Dec(pp);
     pp^ := t1;
 
 //  t1 = inv(*Z++);
     t1 := Inv(pz^);
     Inc(pz);
 
 //  t2 = -*Z++;
     t2 := -pz^;
     Inc(pz);
 
 //  t3 = -*Z++;
     t3 := -pz^;
     Inc(pz);
 
 //  *--p = inv(*Z++);
     Dec(pp);
     pp^ := Inv(pz^);
 
 //  *--p = t3;
     Dec(pp);
     pp^ := t3;
 
 //  *--p = t2;
     Dec(pp);
     pp^ := t2;
 
 //  *--p = t1;
     Dec(pp);
     pp^ := t1;
 end;
 {$R+,Q+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure CalculateSubKeys;
 begin
  ExpandKeys;
  InvertKeys;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 procedure Initialize(AKey: string);
 begin
  FBlockSize  := 8;
  FBufferSize := 2048;
  FKey        := AKey;
  FKeySize    := 32;
 
  FillChar(Z, SizeOf(Z), 0);
  FillChar(K, SizeOf(K), 0);
 
  GetMem(FKeyPtr, FKeySize);
  FillChar(FKeyPtr^, FKeySize, #0);
 
  InvolveKey;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 {$R-,Q-}
 procedure Cipher(var Block: TIDEABlock; const Keys: TIDEAKey);
 var
   x1, x2, x3, x4 : Word;
   t1, t2         : Word;
   pz             : ^Word;
   r	             : Integer;
 
 ////////////////////////////////////////
 
   function Mul(a,b: Word): Word;
   var
     p : LongWord;
   begin
    if (a &gt; 0) then
    begin
      if (b &gt; 0) then
      begin
        p := LongWord(a)*b;
        b := p and $ffff;
        a := p shr 16;
        Result := ((b - a) + Ord(b &lt; a));
      end else Result := 1 - a;
    end else Result := 1 - b;
   end;
 
 ////////////////////////////////////////
 
 begin
 //  x1 = *in++;  x2 = *in++;
     x1 := Block[1];
     x2 := Block[2];
 //  x3 = *in++;  x4 = *in;
     x3 := Block[3];
     x4 := Block[4];
 
     pz := @Keys;
     for r := 1 to Rounds do
       begin
 //      MUL(x1,*Z++);
         x1 := Mul(x1, pz^);
         Inc(pz);
 
 //      x2 += *Z++;
         x2 := x2 + pz^;
         Inc(pz);
 
 //      x3 += *Z++;
         x3 := x3 + pz^;
         Inc(pz);
 
 //      MUL(x4, *Z++);
         x4 := Mul(x4, pz^);
         Inc(pz);
 
 //      t2 = x1^x3;
         t2 := x1 xor x3;
 
 //      MUL(t2, *Z++);
         t2 := Mul(t2, pz^);
         Inc(pz);
 
 //      t1 = t2 + (x2^x4);
         t1 := t2 + (x2 xor x4);
 
 //      MUL(t1, *Z++);
         t1 := Mul(t1, pz^);
         Inc(pz);
 
 //      t2 = t1+t2;
         t2 := (t1 + t2);
 
 //      x1 ^= t1;
         x1 := x1 xor t1;
 
 //      x4 ^= t2;
         x4 := x4 xor t2;
 
 //      t2 ^= x2;
         t2 := t2 xor x2;
 
 //      x2 = x3^t1;
         x2 := x3 xor t1;
 
 //      x3 = t2;
         x3 := t2;
       end;
 
 //  MUL(x1, *Z++);
     x1 := Mul(x1, pz^);
     Inc(pz);
 
 //  *out++ = x1;
     Block[1] := x1;
 
 //  *out++ = x3 + *Z++;
     Block[2] := x3 + pz^;
     Inc(pz);
 
 //  *out++ = x2 + *Z++;
     Block[3] := x2 + pz^;
     Inc(pz);
 
 //  MUL(x4, *Z);
     x4 := Mul(x4, pz^);
 
 //  *out = x4;
     Block[4] := x4;
 end;
 {$R+,Q+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function EncipherBlock(var Block): Boolean;
 begin
  Cipher(TIDEABlock(Block), Z);
  Result := TRUE;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function DecipherBlock(var Block): Boolean;
 begin
  Cipher(TIDEABlock(Block), K);
  Result := TRUE;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Главные функции ...
 
 function EncryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;
 var
   Buffer   : TIDEABlock;
   PrCount  : Int64;
   AddCount : Byte;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DestStream.CopyFrom(SourseStream, Count);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= 8 do
      begin
        SourseStream.Read(Buffer, SizeOf(TIDEABlock));
        EncipherBlock(Buffer);
        DestStream.Write(Buffer, SizeOf(TIDEABlock));
        Inc(PrCount, 8);
      end;
 
    AddCount := Count - PrCount;
    if Count - PrCount &lt;&gt; 0 then
      begin
        SourseStream.Read(Buffer, AddCount);
        DestStream.Write(Buffer, AddCount);
      end;
  except
    Result := False;
  end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function DecryptCopy(DestStream, SourseStream : TStream; Count: Int64;
   Key : string): Boolean;
 var
   Buffer   : TIDEABlock;
   PrCount  : Int64;
   AddCount : Byte;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DestStream.CopyFrom(SourseStream, Count);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= 8 do
      begin
        SourseStream.Read(Buffer, SizeOf(TIDEABlock));
        DecipherBlock(Buffer);
        DestStream.Write(Buffer, SizeOf(TIDEABlock));
        Inc(PrCount, 8);
      end;
 
    AddCount := Count - PrCount;
    if Count - PrCount &lt;&gt; 0 then
      begin
        SourseStream.Read(Buffer, AddCount);
        DestStream.Write(Buffer, AddCount);
      end;
  except
    Result := False;
  end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function EncryptStream(DataStream: TStream; Count: Int64; Key: string): Boolean;
 var
   Buffer   : TIDEABlock;
   PrCount  : Int64;
   AddCount : Byte;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DataStream.Seek(Count, soFromCurrent);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= 8 do
      begin
        DataStream.Read(Buffer, SizeOf(TIDEABlock));
        EncipherBlock(Buffer);
        DataStream.Seek(-SizeOf(TIDEABlock), soFromCurrent);
        DataStream.Write(Buffer, SizeOf(TIDEABlock));
        Inc(PrCount, 8);
      end;
  except
    Result := False;
  end;
 end;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 function DecryptStream(DataStream: TStream; Count: Int64; Key: string): Boolean;
 var
   Buffer   : TIDEABlock;
   PrCount  : Int64;
 begin
  Result := True;
  try
    if Key = '' then
      begin
        DataStream.Seek(Count, soFromCurrent);
        Exit;
      end;
    Initialize(Key);
    CalculateSubKeys;
    PrCount := 0;
    while Count - PrCount &gt;= 8 do
      begin
        DataStream.Read(Buffer, SizeOf(TIDEABlock));
        DecipherBlock(Buffer);
        DataStream.Seek(-SizeOf(TIDEABlock), soFromCurrent);
        DataStream.Write(Buffer, SizeOf(TIDEABlock));
        Inc(PrCount, 8);
      end;
  except
    Result := False;
  end;
 end;
 
 // Завершение главных функций ...
 ////////////////////////////////////////////////////////////////////////////////
 
 end.

TEA:


 unit ucrypt;
 
 interface
 type
   TEAKey = array[0..3] of cardinal;
 
 //Use 64-bit aligned data size (8,16...) or else some data will be left unencrypted!
 procedure TEA_Encode(Input, Output: pointer; size: integer; key: TEAKey);
 procedure TEA_Decode(Input, Output: pointer; size: integer; key: TEAKey);
 
 implementation
 type
   TEAData = array[0..1] of cardinal;
   PTEAKey = ^TEAKey;
   PTEAData = ^TEAData;
 
 procedure TEA_Cipher(v: PTEAData; var w: PTEAData; k: PTEAKey);
 var
   y, z, sum, delta, n: Cardinal;
 begin
   y := (v)[0];
   z := (v)[1];
   sum := 0;
   delta := $9E3779B9;
   n := 32;
 
   while (n &gt; 0) do
   begin
     inc(y, (z shl 4 xor z shr 5) + z xor sum + (k)[sum and 3]);
     inc(sum, delta);
     inc(z, (y shl 4 xor y shr 5) + y xor sum + (k)[sum shr 11 and 3]);
     dec(n);
   end;
 
   (w)[0] := y;
   (w)[1] := z;
 end;
 
 procedure TEA_DeCipher(v: PTEAData; var w: PTEAData; k: PTEAKey);
 var
   y, z, sum, delta, n: Cardinal;
 begin
 
   y := v[0];
   z := v[1];
   sum := $0C6EF3720;
   delta := $9E3779B9;
   n := 32;
 
   while (n &gt; 0) do
   begin
     dec(z, (y shl 4 xor y shr 5) + y xor sum + k[sum shr 11 and 3]);
     dec(sum, delta);
     dec(y, (z shl 4 xor z shr 5) + z xor sum + k[sum and 3]);
     dec(n);
   end;
 
   w[0] := y;
   w[1] := z;
 
 end;
 
 procedure TEA_EnDec(encode: boolean; Input, Output: pointer; size: integer; key:
   TEAKey);
 var
   DataIn, DataOut: TEAData;
   DOut: PTEAData;
   i, sz: integer;
 begin
   DOut := @DataOut;
   sz := (size shr 3) shl 3;
   i := 0;
   repeat
     DataIn[0] := Cardinal((pointer(Cardinal(Input) + Cardinal(i)))^);
     DataIn[1] := Cardinal((pointer(Cardinal(Input) + Cardinal(i + 4)))^);
     if encode then
       TEA_Cipher(@DataIn, DOut, @key)
     else
       TEA_DECipher(@DataIn, DOut, @key);
     Cardinal(pointer(Cardinal(Output) + Cardinal(i))^) := DataOut[0];
     Cardinal(pointer(Cardinal(Output) + Cardinal(i + 4))^) := DataOut[1];
     inc(i, 8);
   until i &gt;= sz;
 
 end;
 
 procedure TEA_Encode(Input, Output: pointer; size: integer; key: TEAKey);
 begin
   TEA_EnDec(true, Input, Output, size, key);
 end;
 
 procedure TEA_Decode(Input, Output: pointer; size: integer; key: TEAKey);
 begin
   TEA_EnDec(false, Input, Output, size, key);
 end;
 
 end.

Post #: 3

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-06-23 18:12:24.413333

Void

Сообщений: 3
Оценки: 0
Присоединился: 2006-10-04 21:02:34.046666

Ищу реализацию AES, CAST5, RSA/DSA на C++, кто чем может помогите…

Post #: 4

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-06-23 18:15:58.413333

alexbozhko

Сообщений: 1024
Оценки: 0
Присоединился: 2005-11-24 13:35:34

torry.net
и там ищи

забираешь все, что маркируется как fws
реально много там всего.

Post #: 5

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-06-23 18:19:14.883333

blacksun

Сообщений: 2360
Оценки: 0
Присоединился: 2006-09-27 03:05:59.350000

Visual AES:
http://softsearch.ru/programs/95-338-visual-aes-download.shtml

остальное иши сам в гугле

Post #: 6

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-06-23 19:18:25.990000

blacksun

Сообщений: 2360
Оценки: 0
Присоединился: 2006-09-27 03:05:59.350000

Модули для делфи для шифрования:
http://www.team-x.ru/guru-exe/index.php?path=Sources%2FUnits+Includes%2FDelphi%2FCrypt/

Post #: 7

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2007-06-24 09:40:51.403333

Void

Сообщений: 3
Оценки: 0
Присоединился: 2006-10-04 21:02:34.046666

в мартовском номере Х была статья "Х-Лаба: реализация криптографического алгоритма AES ", на диске есть пример реализации, у кого есть этот номер скиньте на мыло плиз ентот пример…

мыло: v0id собатчко mail.ru

Post #: 8

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2010-08-11 15:21:32.400000

Julio

Сообщений: 3
Оценки: 0
Присоединился: 2010-08-11 12:06:44.970000

Товарищи, уже с неделю как ищу толковые исходники аглгоритма AES на C++. Буду очень благодарен, если кто-то мне скинет подобный исходник на мыло Purerogue@rambler.ru Кроме того меня интересует следующий вопрос: возможны ли другие эффективные варианты запонения S-Box в алгоритме?

Post #: 9

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2010-08-11 19:53:20.280000

Denaturat

Сообщений: 1741
Оценки: 453
Присоединился: 2008-10-27 20:50:06.380000

quote:

ORIGINAL: Julio

Товарищи, уже с неделю как ищу толковые исходники аглгоритма AES на C++

http://en.wikipedia.org/wiki/AES_implementations#C.2B.2B_library
http://www.hoozi.com/Articles/AESEncryption.htm

этого не хватило?

quote:

ORIGINAL: Julio

возможны ли

возможны

Post #: 10

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2010-08-12 11:02:47.770000

Julio

Сообщений: 3
Оценки: 0
Присоединился: 2010-08-11 12:06:44.970000

Спасибо за информацию! Я заинтересован генератором псевдослучайных чисел, хотел бы посмотреть, что из этого выйдет на базе AES… Тогда возникает вопрос, а как определить, что 1 вариант заполнения лучше другого? Даже если написать программу заполнения матрицы по всем правилам С-блоков случайным образом, перебрать все варианты по эффективности пользуясь каким-нибудь из тестов таких алгоритмов… или определять период псевдослучайной последовательности, то выполнение такой программы на долгое время заставит задуматься машину…Что вы думаете по этому поводу?

Post #: 11

RE: Алгоритмы шифрование, Выручайте, пожалуйста? - 2010-08-14 23:15:22.593333

Denaturat

Сообщений: 1741
Оценки: 453
Присоединился: 2008-10-27 20:50:06.380000

quote:

ORIGINAL: Julio

Что вы думаете по этому поводу?

что ты решаешь задачу не теми методами

http://gamesbyemail.com/News/DiceOMatic

Post #: 12

Страниц: [1]

Все форумы >> [Компилируемые языки] >> Алгоритмы шифрование, Выручайте, пожалуйста?

Связаться:
Вопросы по сайту / xakep@glc.ru

Предупреждение: использование полученных знаний в противозаконных целях преследуется по закону.