Форум АНТИЧАТ - шифрование

Форум АНТИЧАТ (https://forum.antichat.xyz/index.php)

- С/С++, C#, Delphi, .NET, Asm (https://forum.antichat.xyz/forumdisplay.php?f=24)

- - шифрование (https://forum.antichat.xyz/showthread.php?t=26385)

шифрование

здасте.
не подкинете код для зашифровки текста?
я в это деле новечок... попородробней плиз?
пасиба

Пример тупой шифровки xor'ом

Код:

For i:=1 to length(str) do str[i]:=chr(ord(str[i]) xor key);

Для подробного изучения темы советую посмотреть книжки по криптографии.

Вот из Книги "Делфи на примерах" (блокнот шифровальщик):
_http://antisploa.narod.ru/Chapter_07.rar

если хошь здеся лежит "почти" российский ГОСТ(стандарт шифрования)
#include <vcl.h>
#include <stdio.h>
#include <conio.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
union transform
{
unsigned __int64 X[4];
unsigned int _h[8];
unsigned short _s[16];
unsigned char ch[32];
}Y;
void crypt(unsigned int*n1,unsigned int*n2,unsigned long *k);
void multi(unsigned char*x,unsigned char *l);
void prisvUV(unsigned char *h,unsigned char *m);
void calc_key(unsigned char *u,unsigned char *v);
void A(unsigned char *u);
void preobr_KSI(transform*f,int kol);
void prost_zam(unsigned char*h);
void Hshag(unsigned char*h,unsigned char*m);
void k_sum(unsigned char*s1,unsigned char* s2);
int readM(unsigned char* m,FILE*f);

TForm1 *Form1;
unsigned char U[32]={0},V[32]={0},H[32]={0},W[32]={0},L[32]={0},E[32]={0};
unsigned char K[4][32]={0};
unsigned char M[32];
unsigned char C[3][32]={{0},{0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00,
0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff,
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff},{0}};

boolean openf=false;

static unsigned char tab[8][16] ={
0x4,0xA,0x9,0x2,0xD,0x8,0x0,0xE,0x6,0xB,0x1,0xC,0x 7,0xF,0x5,0x3,
0xE,0xB,0x4,0xC,0x6,0xD,0xF,0xA,0x2,0x3,0x8,0x1,0x 0,0x7,0x5,0x9,
0x5,0x8,0x1,0xD,0xA,0x3,0x4,0x2,0xE,0xF,0xC,0x7,0x 6,0x0,0x9,0xB,
0x7,0xD,0xA,0x1,0x0,0x8,0x9,0xF,0xE,0x4,0x6,0xC,0x B,0x2,0x5,0x3,
0x6,0xC,0x7,0x1,0x5,0xF,0xD,0x8,0x4,0xA,0x9,0xE,0x 0,0x3,0xB,0x2,
0x4,0xB,0xA,0x0,0x7,0x2,0x1,0xD,0x3,0x6,0x8,0x5,0x 9,0xC,0xF,0xE,
0xD,0xB,0x4,0x1,0x3,0xF,0x5,0x9,0x0,0xA,0xE,0x7,0x 6,0x8,0x2,0xC,
0x1,0xF,0xD,0x0,0x5,0x7,0xA,0x4,0x9,0x2,0x3,0xE,0x 6,0xB,0x8,0xC};
//---------------------------------------------------------------------------

void crypt(unsigned int*n1,unsigned int*n2,unsigned long *k)
{
unsigned int N1=*n1,N2=*n2,n=0;
int buf[8];
for(int i=0;i<32;i++)
{
if (i<24)
N1=N1+k[i%8];
else N1=N1+k[7-i%8];
for (int j=0;j<=7;j++)
{
n=N1>>(4*j);
n=n&0xF;
buf[j]=tab[j][n];
}
N1=0;
for(int j=0;j<=7;j++)
N1=N1^(buf[j]<<(4*j));
N1=(N1<<11)|(N1>>21);
N1=N1^N2;
N2=*n1;
*n1=N1;
}
*n2=*n1;*n1=N2;
}
//---------------------------------------------------------------------------

void multi(unsigned char*x,unsigned char *l)
{
int c=0;char y=8;
int k;
for (int j=0;j<4;j++)
{
k=l[j]+x[j]*y+c;
l[j]=k%256;
c=k/256;
}
l[4]=c;
};

void A(unsigned char *u);
//---------------------------------------------------------------------------
void prisvUV(unsigned char *h,unsigned char *m)
{
for(int i=0;i<32;i++)
{
U[i]=h[i];
V[i]=m[i];
}
}

//---------------------------------------------------------------------------
void calc_key(unsigned char *u,unsigned char *v)
{
for(int i=0;i<32;i++) {W[i]=u[i]^v[i];}
for(int i=0;i<=3;i++) {
for(int k=1;k<=8;k++) {
K[0][(i+1+4*(k-1))-1]=W[(8*i+k)-1];}}

for(int ii=0;ii<3;ii++)
{
A(U);
for(int j=0;j<32;j++) {U[j]=U[j]^C[ii][j];}
A(V);A(V);
for(int j=0;j<32;j++) {W[j]=U[j]^V[j];}
for(int i=0;i<=3;i++) {
for(int k=1;k<=8;k++) {
K[ii+1][(i+1+4*(k-1))-1]=W[(8*i+k)-1];}}
}
}

//---------------------------------------------------------------------------
void A(unsigned char *u){
transform temp,YY;
for (int i=0;i<32;i++) {temp.ch[i]=u[i];}
YY.X[3]=temp.X[0]^temp.X[1];
YY.X[2]=temp.X[3];
YY.X[1]=temp.X[2];
YY.X[0]=temp.X[1];
for (int i=0;i<32;i++) {u[i]=YY.ch[i];}
}

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

void preobr_KSI(transform*f,int kol)
{
short temp1=0;
for(int i=0;i<kol;i++)
{
temp1=f->_s[0]^f->_s[1]^f->_s[2]^f->_s[3]^f->_s[12]^f->_s[15];
for(int ii=0;ii<15;ii++) {f->_s[ii]=f->_s[ii+1];}
f->_s[15]=temp1;
}
}
//---------------------------------------------------------------------------

void prost_zam(unsigned char*h)
{
unsigned int N1=0,N2=0;
transform for_zam;
for(int i=0;i<32;i++) {for_zam.ch[i]=h[i];}
for(int i=0;i<4;i++)
{
N1=for_zam._h[i*2];
N2=for_zam._h[i*2+1];
crypt(&N1,&N2,((unsigned long*)K)+i*8);
Y._h[i*2]=N1;Y._h[i*2+1]=N2;
}
}
//----------------------------------------------------------------------------

void Hshag(unsigned char*h,unsigned char*m)
{
preobr_KSI(&Y,12);
for(int i=0;i<32;i++) {Y.ch[i]=Y.ch[i]^m[i];}
preobr_KSI(&Y,1);
for(int i=0;i<32;i++) {Y.ch[i]=Y.ch[i]^h[i];}
preobr_KSI(&Y,61);
for(int y=31;y>=0;y--) {h[y]=Y.ch[y];}
}
//----------------------------------------------------------------------------

void k_sum(unsigned char*s1,unsigned char* s2)
{
int k=0;
for(int i=0;i<32;i++)
{
k=k+s1[i]+s2[i];
s1[i]=k%256;
k=k/256;
}
}
//----------------------------------------------------------------------------

int readM(unsigned char* m,FILE*f)
{
int i;
for(i=0;i<32;i++)
{
m[i]=fgetc(f);
if(feof(f)) break;
}
if(i!=32)
for(int y=i;y<32;y++) {m[y]=0x00;}
return i;
}

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

__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)
{
if (openf)
{
int last=0;
FILE *f=fopen(OpenDialog1->FileName.c_str(),"rb");
fseek(f,0,SEEK_END);long int len=ftell(f);rewind(f);
multi((unsigned char*)&len,L);
int i=1;
do{
last=readM(M,f);
if(last==32&&i*32<len)
{prisvUV(H,M);
calc_key(U,V);
prost_zam(H);
Hshag(H,M);
k_sum(E,M);}
else
{
k_sum(E,M);
prisvUV(H,M);
calc_key(U,V);
prost_zam(H);
Hshag(H,M);
prisvUV(H,L);
calc_key(U,V);
prost_zam(H);
Hshag(H,L);
prisvUV(H,E);
calc_key(U,V);
prost_zam(H);
Hshag(H,E);
break;
}
i++;
}
while(1);
for(int i=31;i>=0;i--) {Edit1->Text=Edit1->Text+IntToHex(H[i],2);}
fcloseall();
}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::N2Click(TObject *Sender)
{
if(OpenDialog1->Execute())
openf=true;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::N3Click(TObject *Sender)
{
Form1->Close();
}
//---------------------------------------------------------------------------

разберешься сам? есть еще нормально написанный но я не помню куда его сунул....((((

в архиве лежит порядочно алгоритмов и тамже красиво реализованный ГОСТ, просто подключаешь класс и юзаешь... _http://vdv123.narod.ru/Temp.rar

Для выкладывания кодов используй тэг [code]

привожу пример криптографии MD5 На Delphi:

Код:

{ Вычисление хеш-суммы MD5 }



unit UMD5;



interface



uses Windows, SysUtils, Classes;



type

  { Тип TMD5Digest используется для получения

    результата функций вычисления хеш-суммы.

    Содержимое записи можно использовать

    как набор из 4 целых чисел, или как

    массив из 16 байт }

  PMD5Digest = ^TMD5Digest;

  TMD5Digest = record

    case Integer of

      0: (A, B, C, D: LongInt);

      1: (v: array[0..15] of Byte);

  end;



  // вычисление хеш-суммы для строки

function MD5String(const S: string): TMD5Digest;



// вычисление хеш-суммы для файла

function MD5File(const FileName: string): TMD5Digest;



// вычисление хеш-суммы для содержиого потока Stream

function MD5Stream(const Stream: TStream): TMD5Digest;



// вычисление хеш-суммы для произвольного буфера

function MD5Buffer(const Buffer; Size: Integer): TMD5Digest;



// преобразование хеш-суммы в строку из шестнадцатеричных цифр

function MD5DigestToStr(const Digest: TMD5Digest): string;



// сравнение двух хеш-сумм

function MD5DigestCompare(const Digest1, Digest2: TMD5Digest): Boolean;



implementation



type

  UINT4 = LongWord;



  PArray4UINT4 = ^TArray4UINT4;

  TArray4UINT4 = array[0..3] of UINT4;

  PArray2UINT4 = ^TArray2UINT4;

  TArray2UINT4 = array[0..1] of UINT4;

  PArray16Byte = ^TArray16Byte;

  TArray16Byte = array[0..15] of Byte;

  PArray64Byte = ^TArray64Byte;

  TArray64Byte = array[0..63] of Byte;



  PByteArray = ^TByteArray;

  TByteArray = array[0..0] of Byte;



  PUINT4Array = ^TUINT4Array;

  TUINT4Array = array[0..0] of UINT4;



  PMD5Context = ^TMD5Context;

  TMD5Context = record

    state: TArray4UINT4;

    count: TArray2UINT4;

    buffer: TArray64Byte;

  end;



const

  S11 = 7;

  S12 = 12;

  S13 = 17;

  S14 = 22;

  S21 = 5;

  S22 = 9;

  S23 = 14;

  S24 = 20;

  S31 = 4;

  S32 = 11;

  S33 = 16;

  S34 = 23;

  S41 = 6;

  S42 = 10;

  S43 = 15;

  S44 = 21;



var

  Padding: TArray64Byte =

  ($80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);



function _F(x, y, z: UINT4): UINT4;

begin

  Result := (((x) and (y)) or ((not x) and (z)));

end;



function _G(x, y, z: UINT4): UINT4;

begin

  Result := (((x) and (z)) or ((y) and (not z)));

end;



function _H(x, y, z: UINT4): UINT4;

begin

  Result := ((x) xor (y) xor (z));

end;



function _I(x, y, z: UINT4): UINT4;

begin

  Result := ((y) xor ((x) or (not z)));

end;



function ROTATE_LEFT(x, n: UINT4): UINT4;

begin

  Result := (((x) shl (n)) or ((x) shr (32 - (n))));

end;



procedure FF(var a: UINT4; b, c, d, x, s, ac: UINT4);

begin

  a := a + _F(b, c, d) + x + ac;

  a := ROTATE_LEFT(a, s);

  a := a + b;

end;



procedure GG(var a: UINT4; b, c, d, x, s, ac: UINT4);

begin

  a := a + _G(b, c, d) + x + ac;

  a := ROTATE_LEFT(a, s);

  a := a + b;

end;



procedure HH(var a: UINT4; b, c, d, x, s, ac: UINT4);

begin

  a := a + _H(b, c, d) + x + ac;

  a := ROTATE_LEFT(a, s);

  a := a + b;

end;



procedure II(var a: UINT4; b, c, d, x, s, ac: UINT4);

begin

  a := a + _I(b, c, d) + x + ac;

  a := ROTATE_LEFT(a, s);

  a := a + b;

end;



procedure MD5Encode(Output: PByteArray; Input: PUINT4Array; Len: LongWord);

var

  i, j: LongWord;

begin

  j := 0;

  i := 0;

  while j < Len do

  begin

    output[j] := Byte(input[i] and $FF);

    output[j + 1] := Byte((input[i] shr 8) and $FF);

    output[j + 2] := Byte((input[i] shr 16) and $FF);

    output[j + 3] := Byte((input[i] shr 24) and $FF);

    Inc(j, 4);

    Inc(i);

  end;

end;



procedure MD5Decode(Output: PUINT4Array; Input: PByteArray; Len: LongWord);

var

  i, j: LongWord;

begin

  j := 0;

  i := 0;

  while j < Len do

  begin

    Output[i] := UINT4(input[j]) or (UINT4(input[j + 1]) shl 8) or

      (UINT4(input[j + 2]) shl 16) or (UINT4(input[j + 3]) shl 24);

    Inc(j, 4);

    Inc(i);

  end;

end;



procedure MD5_memcpy(Output: PByteArray; Input: PByteArray; Len: LongWord);

begin

  Move(Input^, Output^, Len);

end;



procedure MD5_memset(Output: PByteArray; Value: Integer; Len: LongWord);

begin

  FillChar(Output^, Len, Byte(Value));

end;



procedure MD5Transform(State: PArray4UINT4; Buffer: PArray64Byte);

var

  a, b, c, d: UINT4;

  x: array[0..15] of UINT4;

begin

  a := State[0];

  b := State[1];

  c := State[2];

  d := State[3];

  MD5Decode(PUINT4Array(@x), PByteArray(Buffer), 64);



  FF(a, b, c, d, x[0], S11, $D76AA478);

  FF(d, a, b, c, x[1], S12, $E8C7B756);

  FF(c, d, a, b, x[2], S13, $242070DB);

  FF(b, c, d, a, x[3], S14, $C1BDCEEE);

  FF(a, b, c, d, x[4], S11, $F57C0FAF);

  FF(d, a, b, c, x[5], S12, $4787C62A);

  FF(c, d, a, b, x[6], S13, $A8304613);

  FF(b, c, d, a, x[7], S14, $FD469501);

  FF(a, b, c, d, x[8], S11, $698098D8);

  FF(d, a, b, c, x[9], S12, $8B44F7AF);

  FF(c, d, a, b, x[10], S13, $FFFF5BB1);

  FF(b, c, d, a, x[11], S14, $895CD7BE);

  FF(a, b, c, d, x[12], S11, $6B901122);

  FF(d, a, b, c, x[13], S12, $FD987193);

  FF(c, d, a, b, x[14], S13, $A679438E);

  FF(b, c, d, a, x[15], S14, $49B40821);



  GG(a, b, c, d, x[1], S21, $F61E2562);

  GG(d, a, b, c, x[6], S22, $C040B340);

  GG(c, d, a, b, x[11], S23, $265E5A51);

  GG(b, c, d, a, x[0], S24, $E9B6C7AA);

  GG(a, b, c, d, x[5], S21, $D62F105D);

  GG(d, a, b, c, x[10], S22, $2441453);

  GG(c, d, a, b, x[15], S23, $D8A1E681);

  GG(b, c, d, a, x[4], S24, $E7D3FBC8);

  GG(a, b, c, d, x[9], S21, $21E1CDE6);

  GG(d, a, b, c, x[14], S22, $C33707D6);

  GG(c, d, a, b, x[3], S23, $F4D50D87);



  GG(b, c, d, a, x[8], S24, $455A14ED);

  GG(a, b, c, d, x[13], S21, $A9E3E905);

  GG(d, a, b, c, x[2], S22, $FCEFA3F8);

  GG(c, d, a, b, x[7], S23, $676F02D9);

  GG(b, c, d, a, x[12], S24, $8D2A4C8A);



  HH(a, b, c, d, x[5], S31, $FFFA3942);

  HH(d, a, b, c, x[8], S32, $8771F681);

  HH(c, d, a, b, x[11], S33, $6D9D6122);

  HH(b, c, d, a, x[14], S34, $FDE5380C);

  HH(a, b, c, d, x[1], S31, $A4BEEA44);

  HH(d, a, b, c, x[4], S32, $4BDECFA9);

  HH(c, d, a, b, x[7], S33, $F6BB4B60);

  HH(b, c, d, a, x[10], S34, $BEBFBC70);

  HH(a, b, c, d, x[13], S31, $289B7EC6);

  HH(d, a, b, c, x[0], S32, $EAA127FA);

  HH(c, d, a, b, x[3], S33, $D4EF3085);

  HH(b, c, d, a, x[6], S34, $4881D05);

  HH(a, b, c, d, x[9], S31, $D9D4D039);

  HH(d, a, b, c, x[12], S32, $E6DB99E5);

  HH(c, d, a, b, x[15], S33, $1FA27CF8);

  HH(b, c, d, a, x[2], S34, $C4AC5665);



  II(a, b, c, d, x[0], S41, $F4292244);

  II(d, a, b, c, x[7], S42, $432AFF97);

  II(c, d, a, b, x[14], S43, $AB9423A7);

  II(b, c, d, a, x[5], S44, $FC93A039);

  II(a, b, c, d, x[12], S41, $655B59C3);

  II(d, a, b, c, x[3], S42, $8F0CCC92);

  II(c, d, a, b, x[10], S43, $FFEFF47D);

  II(b, c, d, a, x[1], S44, $85845DD1);

  II(a, b, c, d, x[8], S41, $6FA87E4F);

  II(d, a, b, c, x[15], S42, $FE2CE6E0);

  II(c, d, a, b, x[6], S43, $A3014314);

  II(b, c, d, a, x[13], S44, $4E0811A1);

  II(a, b, c, d, x[4], S41, $F7537E82);

  II(d, a, b, c, x[11], S42, $BD3AF235);

  II(c, d, a, b, x[2], S43, $2AD7D2BB);

  II(b, c, d, a, x[9], S44, $EB86D391);



  Inc(State[0], a);

  Inc(State[1], b);

  Inc(State[2], c);

  Inc(State[3], d);



  MD5_memset(PByteArray(@x), 0, SizeOf(x));

end;



procedure MD5Init(var Context: TMD5Context);

begin

  FillChar(Context, SizeOf(Context), 0);

  Context.state[0] := $67452301;

  Context.state[1] := $EFCDAB89;

  Context.state[2] := $98BADCFE;

  Context.state[3] := $10325476;

end;



procedure MD5Update(var Context: TMD5Context; Input: PByteArray; InputLen:

  LongWord);

var

  i, index, partLen: LongWord;



begin

  index := LongWord((context.count[0] shr 3) and $3F);

  Inc(Context.count[0], UINT4(InputLen) shl 3);

  if Context.count[0] < UINT4(InputLen) shl 3 then

    Inc(Context.count[1]);

  Inc(Context.count[1], UINT4(InputLen) shr 29);

  partLen := 64 - index;

  if inputLen >= partLen then

  begin

    MD5_memcpy(PByteArray(@Context.buffer[index]), Input, PartLen);

    MD5Transform(@Context.state, @Context.buffer);

    i := partLen;

    while i + 63 < inputLen do

    begin

      MD5Transform(@Context.state, PArray64Byte(@Input[i]));

      Inc(i, 64);

    end;

    index := 0;

  end

  else

    i := 0;

  MD5_memcpy(PByteArray(@Context.buffer[index]), PByteArray(@Input[i]), inputLen

    - i);

end;



procedure MD5Final(var Digest: TMD5Digest; var Context: TMD5Context);

var

  bits: array[0..7] of Byte;

  index, padLen: LongWord;

begin

  MD5Encode(PByteArray(@bits), PUINT4Array(@Context.count), 8);

  index := LongWord((Context.count[0] shr 3) and $3F);

  if index < 56 then

    padLen := 56 - index

  else

    padLen := 120 - index;

  MD5Update(Context, PByteArray(@PADDING), padLen);

  MD5Update(Context, PByteArray(@Bits), 8);

  MD5Encode(PByteArray(@Digest), PUINT4Array(@Context.state), 16);

  MD5_memset(PByteArray(@Context), 0, SizeOf(Context));

end;



function MD5DigestToStr(const Digest: TMD5Digest): string;

var

  i: Integer;

begin

  Result := '';

  for i := 0 to 15 do

    Result := Result + IntToHex(Digest.v[i], 2);

end;



function MD5String(const S: string): TMD5Digest;

begin

  Result := MD5Buffer(PChar(S)^, Length(S));

end;



function MD5File(const FileName: string): TMD5Digest;

var

  F: TFileStream;

begin

  F := TFileStream.Create(FileName, fmOpenRead);

  try

    Result := MD5Stream(F);

  finally

    F.Free;

  end;

end;



function MD5Stream(const Stream: TStream): TMD5Digest;

var

  Context: TMD5Context;

  Buffer: array[0..4095] of Byte;

  Size: Integer;

  ReadBytes: Integer;

  TotalBytes: Integer;

  SavePos: Integer;

begin

  MD5Init(Context);

  Size := Stream.Size;

  SavePos := Stream.Position;

  TotalBytes := 0;

  try

    Stream.Seek(0, soFromBeginning);

    repeat

      ReadBytes := Stream.Read(Buffer, SizeOf(Buffer));

      Inc(TotalBytes, ReadBytes);

      MD5Update(Context, @Buffer, ReadBytes);

    until (ReadBytes = 0) or (TotalBytes = Size);

  finally

    Stream.Seek(SavePos, soFromBeginning);

  end;

  MD5Final(Result, Context);

end;



function MD5Buffer(const Buffer; Size: Integer): TMD5Digest;

var

  Context: TMD5Context;

begin

  MD5Init(Context);

  MD5Update(Context, PByteArray(@Buffer), Size);

  MD5Final(Result, Context);

end;



function MD5DigestCompare(const Digest1, Digest2: TMD5Digest): Boolean;

begin

  Result := False;

  if Digest1.A <> Digest2.A then

    Exit;

  if Digest1.B <> Digest2.B then

    Exit;

  if Digest1.C <> Digest2.C then

    Exit;

  if Digest1.D <> Digest2.D then

    Exit;

  Result := True;

end;



end.

А ваще ищи в инете, там этого добра до фига)))
З.Ы. сохраняешль код в файл UMD5.pas и пропиываешь его в uses. Для шифрования делай так:)
LowerCase(MD5DigestToStr(MD5String('Здесь зашифрованная строка')))

при4ем тут мд5? 4ем просил бло4ный шифр