Основы криптографии

*

* This should be inlined for maximum speed

*/

#if __GNUC__

__inline__

#endif

static word32

f(word32 x)

{

/* Do substitutions */

#if 0

/* This is annoyingly slow */

x = k8[x>>28 & 15] << 28 | k7[x>>24 & 15] << 24 |

k6[x>>20 & 15] << 20 | k5[x>>16 & 15] << 16 |

k4[x>>12 & 15] << 12 | k3[x>> 8 & 15] << 8 |

k2[x>> 4 & 15] << 4 | k1[x & 15];

#else

/* This is faster */

x = k87[x>>24 & 255] << 24 | k65[x>>16 & 255] << 16 |

k43[x>> 8 & 255] << 8 | k21[x & 255];

#endif

/* Rotate left 11 bits */

return x<<11 | x>>(32-11);

}

/*

* The GOST standard defines the input in terms of bits 1..64, with

* bit 1 being the lsb of in[0] and bit 64 being the msb of in[1].

*

* The keys are defined similarly, with bit 256 being the msb of key[7].

*/

void

gostcrypt(word32 const in[2], word32 out[2], word32 const key[8])

{

register word32 n1, n2; /* As named in the GOST */

n1 = in[0];

n2 = in[1];

/* Instead of swapping halves, swap names each round */

n2 ^= f(n1+key[0]);

n1 ^= f(n2+key[1]);

n2 ^= f(n1+key[2]);

n1 ^= f(n2+key[3]);

n2 ^= f(n1+key[4]);

n1 ^= f(n2+key[5]);

n2 ^= f(n1+key[6]);

n1 ^= f(n2+key[7]);

n2 ^= f(n1+key[0]);

n1 ^= f(n2+key[1]);

n2 ^= f(n1+key[2]);

n1 ^= f(n2+key[3]);

n2 ^= f(n1+key[4]);

n1 ^= f(n2+key[5]);

n2 ^= f(n1+key[6]);

n1 ^= f(n2+key[7]);

n2 ^= f(n1+key[0]);

n1 ^= f(n2+key[1]);

n2 ^= f(n1+key[2]);

n1 ^= f(n2+key[3]);

n2 ^= f(n1+key[4]);

n1 ^= f(n2+key[5]);

n2 ^= f(n1+key[6]);

n1 ^= f(n2+key[7]);

n2 ^= f(n1+key[7]);

n1 ^= f(n2+key[6]);

n2 ^= f(n1+key[5]);

n1 ^= f(n2+key[4]);

n2 ^= f(n1+key[3]);

n1 ^= f(n2+key[2]);

n2 ^= f(n1+key[1]);

n1 ^= f(n2+key[0]);

/* There is no swap after the last round */

out[0] = n2;

out[1] = n1;

}

/*

* The key schedule is somewhat different for decryption.

* (The key table is used once forward and three times backward.)

* You could define an expanded key, or just write the code twice,

* as done here.

*/

void

gostdecrypt(word32 const in[2], word32 out[2], word32 const key[8])

{

register word32 n1, n2; /* As named in the GOST */

n1 = in[0];

n2 = in[1];

n2 ^= f(n1+key[0]);

n1 ^= f(n2+key[1]);

n2 ^= f(n1+key[2]);

n1 ^= f(n2+key[3]);

n2 ^= f(n1+key[4]);

n1 ^= f(n2+key[5]);

n2 ^= f(n1+key[6]);

n1 ^= f(n2+key[7]);

n2 ^= f(n1+key[7]);

n1 ^= f(n2+key[6]);

n2 ^= f(n1+key[5]);

n1 ^= f(n2+key[4]);

n2 ^= f(n1+key[3]);

n1 ^= f(n2+key[2]);

n2 ^= f(n1+key[1]);

n1 ^= f(n2+key[0]);

n2 ^= f(n1+key[7]);

n1 ^= f(n2+key[6]);

n2 ^= f(n1+key[5]);

n1 ^= f(n2+key[4]);

n2 ^= f(n1+key[3]);

n1 ^= f(n2+key[2]);

n2 ^= f(n1+key[1]);

n1 ^= f(n2+key[0]);

n2 ^= f(n1+key[7]);

n1 ^= f(n2+key[6]);

n2 ^= f(n1+key[5]);

n1 ^= f(n2+key[4]);

n2 ^= f(n1+key[3]);

n1 ^= f(n2+key[2]);

n2 ^= f(n1+key[1]);

n1 ^= f(n2+key[0]);

out[0] = n2;

out[1] = n1;

}

/*

* The GOST "Output feedback" standard. It seems closer morally

* to the counter feedback mode some people have proposed for DES.

* The avoidance of the short cycles that are possible in OFB seems

* like a Good Thing.

*

* Calling it the stream mode makes more sense.

*

* The IV is encrypted with the key to produce the initial counter value.

* Then, for each output block, a constant is added, modulo 2^32-1

* (0 is represented as all-ones, not all-zeros), to each half of

* the counter, and the counter is encrypted to produce the value

* to XOR with the output.

*

* Len is the number of blocks. Sub-block encryption is

* left as an exercise for the user. Remember that the

* standard defines everything in a little-endian manner,

* so you want to use the low bit of gamma[0] first.

*

* OFB is, of course, self-inverse, so there is only one function.

*/

/* The constants for addition */

#define C1 0x01010104

#define C2 0x01010101

void

gostofb(word32 const *in, word32 *out, int len,

word32 const iv[2], word32 const key[8])

{

word32 temp[2]; /* Counter */

word32 gamma[2]; /* Output XOR value */

/* Compute starting value for counter */

gostcrypt(iv, temp, key);

while (len--) {

temp[0] += C2;

if (temp[0] < C2) /* Wrap modulo 2^32? */

temp[0]++; /* Make it modulo 2^32-1 */

temp[1] += C1;

if (temp[1] < C1) /* Wrap modulo 2^32? */

temp[1]++; /* Make it modulo 2^32-1 */

gostcrypt(temp, gamma, key);

*out++ = *in++ ^ gamma[0];

*out++ = *in++ ^ gamma[1];

}

}

/*

* The CFB mode is just what you'd expect. Each block of ciphertext y[] is

* derived from the input x[] by the following pseudocode:

* y[i] = x[i] ^ gostcrypt(y[i-1])

* x[i] = y[i] ^ gostcrypt(y[i-1])

* Where y[-1] is the IV.

*

* The IV is modified in place. Again, len is in *blocks*.

*/

void

gostcfbencrypt(word32 const *in, word32 *out, int len,

word32 iv[2], word32 const key[8])

{

while (len--) {

gostcrypt(iv, iv, key);

iv[0] = *out++ ^= iv[0];

iv[1] = *out++ ^= iv[1];

}

}

void

gostcfbdecrypt(word32 const *in, word32 *out, int len,

word32 iv[2], word32 const key[8])

{

word32 t;

while (len--) {

gostcrypt(iv, iv, key);

t = *out;

*out++ ^= iv[0];

iv[0] = t;

t = *out;

*out++ ^= iv[1];

iv[1] = t;

}

}

/*

* The message suthetication code uses only 16 of the 32 rounds.

* There *is* a swap after the 16th round.

* The last block should be padded to 64 bits with zeros.

* len is the number of *blocks* in the input.

*/

void

gostmac(word32 const *in, int len, word32 out[2], word32 const key[8])

{

register word32 n1, n2; /* As named in the GOST */

n1 = 0;

n2 = 0;

while (len--) {

n1 ^= *in++;

n2 = *in++;

/* Instead of swapping halves, swap names each round */

n2 ^= f(n1+key[0]);

n1 ^= f(n2+key[1]);

n2 ^= f(n1+key[2]);

n1 ^= f(n2+key[3]);

n2 ^= f(n1+key[4]);

n1 ^= f(n2+key[5]);

n2 ^= f(n1+key[6]);

n1 ^= f(n2+key[7]);

n2 ^= f(n1+key[0]);

n1 ^= f(n2+key[1]);

n2 ^= f(n1+key[2]);

n1 ^= f(n2+key[3]);

n2 ^= f(n1+key[4]);

n1 ^= f(n2+key[5]);

n2 ^= f(n1+key[6]);

n1 ^= f(n2+key[7]);

}

out[0] = n1;

out[1] = n2;

}

#ifdef TEST

#include <stdio.h>

#include <stdlib.h>

/* Designed to cope with 15-bit rand() implementations */

#define RAND32 ((word32)rand() << 17 ^ (word32)rand() << 9 ^ rand())

int

main(void)

{

word32 key[8];

word32 plain[2];

word32 cipher[2];

int i, j;

kboxinit();

printf("GOST 21847-89 test driver.\n");

for (i = 0; i < 1000; i++) {

for (j = 0; j < 8; j++)

key[j] = RAND32;

plain[0] = RAND32;

plain[1] = RAND32;

printf("%3d\r", i);

fflush(stdout);

gostcrypt(plain, cipher, key);

for (j = 0; j < 99; j++)

gostcrypt(cipher, cipher, key);

for (j = 0; j < 100; j++)

gostdecrypt(cipher, cipher, key);

if (plain[0] != cipher[0] || plain[1] != cipher[1]) {

fprintf(stderr, "\nError! i = %d\n", i);

return 1;

}

}

printf("All tests passed.\n");

return 0;

}

#endif /* TEST */

Простое XOR

//**************************************

//INCLUDE files for :crypt.c

//**************************************

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

//**************************************

// Name: crypt.c

// Description:Encrypts file and outputs it to a file or stdout

// By:

//

//

// Inputs:crypt1.exe <infile> <outfile> <key>

//

//**************************************

#define cypherbits 256 /* encryption strength in bits */

#define cypher cypherbits/(sizeof(int)*8)

int seed[cypher];

void modseed() {

int x;

for(x=1;x<cypher;x++)seed[x]=seed[x]*0x81772012+seed[x]+0x49122035+seed[x+1];

for(x=1;x<cypher;x++)seed[0]=seed[0]^seed[x];

}

int seedsum() {

int n,x;

n=0x80379251;

for(x=0;x<cypher;x++)n=n^seed[x];

return((n>>24)^((n>>16)&255)^((n>>8)&255)^(n&255));

}

char strequ(char *s1,char *s2) {

int p;

p=0;

while((s1[p]==s2[p])&&(s1[p]!=0)&&(s2[p]!=0))p++;

if(s1[p]==s2[p])return(1); else return(0);

}

int main(int argc,char *argv[]) {

char banner[]="\x43\x6f\x64\x65\x64\x20\x62\x79\x20\x70\x61\x69"

"\x6e\x74\x20\x6f\x66\x20\x44\x61\x6c\x4e"

"\x75\x74\x20\x28\x70\x61\x69\x6e\x74\x40\x6c\x65\x65\x74\x2e\x63\x6f\x6d\x29";

char buf[2048];

int p,r,l,i,t,s,x;

char b,c,pct,lpct;

FILE *infile=NULL,*outfile=NULL;

fprintf(stderr, "%s\n", banner);

if(argc!=4){

fprintf(stderr,"use: %s <infile> <outfile> <key>\n",argv[0]);

exit(-1);

}

if(strequ(argv[1],"stdin"))infile=stdin; else

if((infile=fopen(argv[1],"r"))==NULL){

fprintf(stderr,"failed to open %s\n",argv[1]);

exit(-1);

}

if(strequ(argv[2],"stdout"))outfile=stdout; else

if((outfile=fopen(argv[2],"w"))==NULL){

fprintf(stderr,"failed to create %s\n",argv[2]);

exit(-1);

}

if(infile!=stdin) {

fseek(infile,0,SEEK_END);

l=ftell(infile);

rewind(infile);

} else l=0;

s=l;

t=0;

pct=0;

if(l<1)fprintf(stderr,"Encrypting data.. (%d bit cypher)\n",cypher*sizeof(int)*8);

else fprintf(stderr,"Encrypting %d bytes.. (%d bit cypher)\n",l,cypher*sizeof(int)*8);

bzero(seed,sizeof(seed));

modseed;

p=0;

while(argv[3][p]!=0){

modseed;

seed[0]=seed[0]+argv[3][p];

modseed;

p++;

}

i=0;

if(l>0){

fputc('[',stderr);

x=(l/sizeof(buf));

if(l-x*sizeof(buf)!=0)x+=1;

if(x>38)x=38;

for(p=0;p<x;p++) fputc(32,stderr);

fputc(']',stderr);

fputc(13,stderr);

fputc('[',stderr);

fflush(stderr);

}

c=1;

while(c){

r=fread(&buf,1,sizeof(buf),infile);

if(r>0) {

t+=r;

if(l>0){

lpct=pct;

pct=t/(l/x);

if(pct>lpct) {

fputc(88+32*i,stderr);

fflush(stderr);

i=1-i;

}

} else {

fputc(88+32*i,stderr);

fflush(stderr);

i=1-i;

}

p=0;

while(p<r) {

modseed();

buf[p]=buf[p]^seedsum();

p++;

}

if(fwrite(&buf,1,r,outfile)!=r) {

fprintf(stderr,"\nerror writing data\n");

exit(-1);

}

} else c=0;

}

if(l>0)fputc(']',stderr);

fprintf(stderr,"\nDone. Wrote %d bytes.\n",t);

}

FileCoding

Данная программа осуществляет простое (без сжатия) кодирование любого файла по алгоритму ГОСТ. ГОСТ был выбрано по нескольким причинам- одна из которых, возможное принятие данного алгоритма шифрования в качестве основного, Соединенными Штатами Америки, а следовательно (так как он уже признан стандартом шифрования России)-данный алгоритм является на данный момент самым надежным и легко реальзуемым

Для работы с программой для начала необходимо дважды ввести пароль (не менее 3-х символов, рекомендуется более) и задём нажатием на кнопку «rjlbht,f» вызвать диалоговое окно выбора файла. Далее фаил будет закодирован и сохранен под тем же именем что и исходный, но с расширением *.enc. Рекомендуется удалять исходный фаил.

Процесс раскодирование похож на процесс кодирование с точностью до наоборот- тоесть надо ввести (дважды) пароль, нажать «ltrjlbht,f», и затем выбрать зашифрованный фаил. После выдачи системного сообщения «Процесс завершён», раскодированный фаил становится доступным.

Размещено на Allbest