//Algorytm DES
//program wykonal Grzegorz Gasiewski
//pobrano ze strony http://gege01.prv.pl

#include <stdio.h>

int main()                                                                                                             
{
int binarny(unsigned char *napis, int *tab_x);
int red_klucza(int *tab_k, int *tab1_k);
int przesuw_klucza(int *tabx_k, int i);
int permutacja_klucza(int *tab2_k, int *tab3_k, int *tab4_k);
int szyfrowanie(int *tab4_k, int *tab2_k, int *tab3_k, int *tab3_t, int *tab4_t, int *tab_xor, int *B1, int *B2, int *B3, int *B4, int *B5, int *B6, int *B7, int *B8, int *y1, int *y2, int *y3, int *y4, int *y5, int *y6, int *y7, int *y8, int *blok_P, int *tab_Ri, int *tab2_t);
int deszyfrowanie(int *tab4_k, int *tab2_k, int *tab3_k, int *tab3_t, int *tab4_t, int *tab_xor, int *B1, int *B2, int *B3, int *B4, int *B5, int *B6, int *B7, int *B8, int *y1, int *y2, int *y3, int *y4, int *y5, int *y6, int *y7, int *y8, int *blok_P, int *tab_Ri, int *tab2_t);
int permutacja_pocz_tekstu(int *tab1_t);
int rozszerzanie_Ro(int *tab3_t, int *tab4_t);
int xor(int *tab4_t, int *tab4_k, int *tab_xor);
int zamiana_na_bloki(int *tab_xor, int *B1, int *B2, int *B3, int *B4, int *B5, int *B6, int *B7, int *B8);
int S1(int *B1, int *y1);
int S2(int *B2, int *y2);
int S3(int *B3, int *y3);
int S4(int *B4, int *y4);
int S5(int *B5, int *y5);
int S6(int *B6, int *y6);
int S7(int *B7, int *y7);
int S8(int *B8, int *y8);
int binarny_krotki(int liczba, int *tab_y);
int laczenie_y(int *y1, int *y2, int *y3, int *y4, int *y5, int *y6, int *y7, int *y8, int *blok_P);
int permutacja_P_bloku(int *blok_P);
int xor_koncowe(int *tab_Ri, int *tab2_t, int *blok_P);
int permutacja_kon_tekstu(int *tab1_t, int *tab3_t, int *tab2_t, char *tekst);
int przesuw_klucza_p(int *tabx_k, int i);


int i,j,tab_k[64],tab1_k[56],tab2_k[28],tab3_k[28],tab4_k[48];
int tab1_t[64], tab2_t[32], tab3_t[32], tab4_t[48], tab_xor[48];
int B1[6], B2[6], B3[6], B4[6], B5[6], B6[6], B7[6], B8[6];
int y1[4], y2[4], y3[4], y4[4], y5[4], y6[4], y7[4], y8[4];
int blok_P[32], tab_Ri[32];
unsigned char klucz[8], sciezka1[12], sciezka2[12], tekst[8];
FILE *plik_odczyt, *plik_zapis;
char znak;
long int ilosc,ilosc1;
int x;

clrscr();

gotoxy(21,2);
printf("SZYFROWANIE ALGORYTMEM DES");
gotoxy(20,20);
printf("program wykonal Grzegorz Gasiewski");
gotoxy(20,22);
printf("http:\\\\gege01.prv.pl   gege01@wp.pl");
gotoxy(18,12);
printf("Podaj klucz (8 znakow): ");
gets(klucz);

if(strlen(klucz)!=8)
do{
clrscr();

gotoxy(21,2);
printf("SZYFROWANIE ALGORYTMEM DES");
gotoxy(20,20);
printf("program wykonal Grzegorz Gasiewski");
gotoxy(20,22);
printf("http:\\\\gege01.prv.pl   gege01@wp.pl");
gotoxy(22,16);
printf("Klucz musi miec 8 znakow");
gotoxy(18,12);
printf("Podaj klucz (8 znakow): ");
gets(klucz);
}while(strlen(klucz)!=8);

clrscr();
gotoxy(10,12);
printf("Podaj sciezke dostepu pliku zrodlowego: ");
gets(sciezka1);


plik_odczyt=fopen(sciezka1,"rb");

	if(!plik_odczyt)
	{
	gotoxy(26,14);
	printf("Blad otwarcia pliku %s", sciezka1);
	delay(2000);
	return (0);
	}

gotoxy(10,16);
printf("Podaj sciezke dostepu pliku docelowego: ");
gets(sciezka2);

plik_zapis=fopen(sciezka2,"wb");

	if(!plik_zapis)
	{
	gotoxy(26,18);
	printf("Blad otwarcia pliku %s", sciezka2);
	delay(2000);
	return (0);
	}


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

clrscr();
gotoxy(21,2);
printf("SZYFROWANIE ALGORYTMEM DES");
gotoxy(20,20);
printf("program wykonal Grzegorz Gasiewski");
gotoxy(20,22);
printf("http:\\\\gege01.prv.pl   gege01@wp.pl");
gotoxy(20,12);
printf("1 - szyfrowanie");
gotoxy(20,14);
printf("2 - deszyfrowanie");
gotoxy(20,16);
printf("q - wyjscie");

if(znak=='q'|| znak=='Q') return 0;

znak=getch();

if(znak!='1'&&znak!='2')

do{
clrscr();

gotoxy(21,2);
printf("SZYFROWANIE ALGORYTMEM DES");
gotoxy(20,20);
printf("program wykonal Grzegorz Gasiewski");
gotoxy(20,22);
printf("http:\\\\gege01.prv.pl   gege01@wp.pl");
gotoxy(20,12);
printf("1 - szyfrowanie");
gotoxy(20,14);
printf("2 - deszyfrowanie");
gotoxy(20,16);
printf("q - wyjscie");

if(znak=='q'|| znak=='Q') return 0;

znak=getch();

}while(znak!='1' && znak!='2');

clrscr();


if(znak=='1')
{
ilosc=0;
	while(1)
	{

	 i=fgetc(plik_odczyt);

	 if(i==EOF) break;

	 ++ilosc;

	 }

ilosc%=8;

fclose(plik_odczyt);

plik_odczyt=fopen(sciezka1,"rb");

fputc(ilosc,plik_zapis);

clrscr();
gotoxy(20,10);
printf("Trwa szyfrowanie. Prosze czekac...");
}


if(znak=='2')
{

ilosc1=0;

x=fgetc(plik_odczyt);

	while(1)
	{
	 x=fgetc(plik_odczyt);
	 if(x==EOF) break;
	 ++ilosc1;
	}

fclose(plik_odczyt);

plik_odczyt=fopen(sciezka1,"rb");

x=fgetc(plik_odczyt);

clrscr();
gotoxy(20,10);
printf("Trwa deszyfrowanie. Prosze czekac...");

}



while(ilosc=(fread(tekst,sizeof(unsigned char),8,plik_odczyt)))
{

binarny(klucz,tab_k);

red_klucza(tab_k, tab1_k);


for(i=0;i<28;i++)
tab2_k[i]=tab1_k[i];  //Co


j=0;
for(i=28;i<56;i++)
{
tab3_k[j]=tab1_k[i];  //Do
j++;
}


binarny(tekst,tab1_t);

permutacja_pocz_tekstu(tab1_t);


	for(i=0;i<32;i++)
	tab2_t[i]=tab1_t[i];  //Lo


	j=0;
	for(i=32;i<64;i++)
	{
	tab3_t[j]=tab1_t[i];  //Ro
	j++;
	}


if(znak=='1') szyfrowanie(tab4_k, tab2_k, tab3_k, tab3_t, tab4_t, tab_xor, B1, B2, B3, B4, B5, B6, B7, B8, y1, y2, y3, y4, y5, y6, y7, y8, blok_P, tab_Ri, tab2_t);
if(znak=='2') deszyfrowanie(tab4_k, tab2_k, tab3_k, tab3_t, tab4_t, tab_xor, B1, B2, B3, B4, B5, B6, B7, B8, y1, y2, y3, y4, y5, y6, y7, y8, blok_P, tab_Ri, tab2_t);

permutacja_kon_tekstu(tab1_t, tab3_t, tab2_t, tekst);


if(znak=='2'&&ilosc1==ftell(plik_odczyt)-1&&x!=0)
{
fwrite(tekst,sizeof(char),x,plik_zapis);
break;
}
else fwrite(tekst,sizeof(char),8,plik_zapis);



if(ilosc!=8)break;

}



fclose(plik_odczyt);
fclose(plik_zapis);


return 0;
}



int binarny(unsigned char *napis, int *tab_x)
{
int licznik,liczba,reszta,i,j,tab_pom[64];

licznik=0;

for(i=0;i<8;i++)
{
liczba=napis[i];

        for(j=0;j<8;j++)
        {
	reszta=liczba%2;  //zamiana znaku na kod binarny
	liczba=liczba/2;

	tab_pom[licznik]=reszta;
	licznik++;
	}
}

j=7;
liczba=7;
licznik=0;

for(i=0;i<64;i++)
{
tab_x[j]=tab_pom[i];    //zamiana z konca na poczatek
licznik++;
	if(licznik==8)
	{
	licznik=0;
	liczba+=8;
	j=liczba+1;
	}
j--;
}

return 0;
}


int red_klucza(int *tab_k, int *tab1_k)
{
tab1_k[0]=tab_k[56];  tab1_k[1]=tab_k[48];  tab1_k[2]=tab_k[40];  tab1_k[3]=tab_k[32];  tab1_k[4]=tab_k[24];  tab1_k[5]=tab_k[16];  tab1_k[6]=tab_k[8];
tab1_k[7]=tab_k[0];   tab1_k[8]=tab_k[57];  tab1_k[9]=tab_k[49];  tab1_k[10]=tab_k[41]; tab1_k[11]=tab_k[33]; tab1_k[12]=tab_k[25]; tab1_k[13]=tab_k[17];
tab1_k[14]=tab_k[9];  tab1_k[15]=tab_k[1];  tab1_k[16]=tab_k[58]; tab1_k[17]=tab_k[50]; tab1_k[18]=tab_k[42]; tab1_k[19]=tab_k[34]; tab1_k[20]=tab_k[26];
tab1_k[21]=tab_k[18]; tab1_k[22]=tab_k[10]; tab1_k[23]=tab_k[2];  tab1_k[24]=tab_k[59]; tab1_k[25]=tab_k[51]; tab1_k[26]=tab_k[43]; tab1_k[27]=tab_k[35];
tab1_k[28]=tab_k[62]; tab1_k[29]=tab_k[54]; tab1_k[30]=tab_k[46]; tab1_k[31]=tab_k[38]; tab1_k[32]=tab_k[30]; tab1_k[33]=tab_k[22]; tab1_k[34]=tab_k[14];
tab1_k[35]=tab_k[6];  tab1_k[36]=tab_k[61]; tab1_k[37]=tab_k[53]; tab1_k[38]=tab_k[45]; tab1_k[39]=tab_k[37]; tab1_k[40]=tab_k[29]; tab1_k[41]=tab_k[21];
tab1_k[42]=tab_k[13]; tab1_k[43]=tab_k[5];  tab1_k[44]=tab_k[60]; tab1_k[45]=tab_k[52]; tab1_k[46]=tab_k[44]; tab1_k[47]=tab_k[36]; tab1_k[48]=tab_k[28];
tab1_k[49]=tab_k[20]; tab1_k[50]=tab_k[12]; tab1_k[51]=tab_k[4];  tab1_k[52]=tab_k[27]; tab1_k[53]=tab_k[19]; tab1_k[54]=tab_k[11]; tab1_k[55]=tab_k[3];

return 0;
}


int przesuw_klucza(int *tabx_k, int i)
{
int j,x,l,buf;

if(i==1||i==2||i==9||i==16)x=1;
else x=2;

for(j=1;j<=x;j++)
{
buf=tabx_k[0];

	for(l=0;l<27;l++)
	tabx_k[l]=tabx_k[l+1];

tabx_k[27]=buf;

}

return 0;
}

int przesuw_klucza_p(int *tabx_k, int i)
{
int j,x,l,buf;

if(i==1||i==2||i==9||i==16)x=1;
else x=2;

for(j=1;j<=x;j++)
{
buf=tabx_k[27];

	for(l=27;l>0;l--)
	tabx_k[l]=tabx_k[l-1];

tabx_k[0]=buf;

}

return 0;
}




int permutacja_klucza(int *tab2_k, int *tab3_k, int *tab4_k)
{
int i,j,tab_pom[56];

	for(i=0;i<28;i++)
	tab_pom[i]=tab2_k[i];
j=28;
        for(i=0;i<28;i++)
	{
	tab_pom[j]=tab3_k[i];
	j++;
	}

tab4_k[0]=tab_pom[13];  tab4_k[1]=tab_pom[16];  tab4_k[2]=tab_pom[10];  tab4_k[3]=tab_pom[23];  tab4_k[4]=tab_pom[0];   tab4_k[5]=tab_pom[4];   tab4_k[6]=tab_pom[2];   tab4_k[7]=tab_pom[27];
tab4_k[8]=tab_pom[14];  tab4_k[9]=tab_pom[5];   tab4_k[10]=tab_pom[20]; tab4_k[11]=tab_pom[9];  tab4_k[12]=tab_pom[22]; tab4_k[13]=tab_pom[18]; tab4_k[14]=tab_pom[11]; tab4_k[15]=tab_pom[3];
tab4_k[16]=tab_pom[25]; tab4_k[17]=tab_pom[7];  tab4_k[18]=tab_pom[15]; tab4_k[19]=tab_pom[6];  tab4_k[20]=tab_pom[26]; tab4_k[21]=tab_pom[19]; tab4_k[22]=tab_pom[12]; tab4_k[23]=tab_pom[1];
tab4_k[24]=tab_pom[40]; tab4_k[25]=tab_pom[51]; tab4_k[26]=tab_pom[30]; tab4_k[27]=tab_pom[36]; tab4_k[28]=tab_pom[46]; tab4_k[29]=tab_pom[54]; tab4_k[30]=tab_pom[29]; tab4_k[31]=tab_pom[39];
tab4_k[32]=tab_pom[50]; tab4_k[33]=tab_pom[44]; tab4_k[34]=tab_pom[32]; tab4_k[35]=tab_pom[47]; tab4_k[36]=tab_pom[43]; tab4_k[37]=tab_pom[48]; tab4_k[38]=tab_pom[38]; tab4_k[39]=tab_pom[55];
tab4_k[40]=tab_pom[33]; tab4_k[41]=tab_pom[52]; tab4_k[42]=tab_pom[45]; tab4_k[43]=tab_pom[41]; tab4_k[44]=tab_pom[49]; tab4_k[45]=tab_pom[35]; tab4_k[46]=tab_pom[28]; tab4_k[47]=tab_pom[31];

return 0;
}

int rozszerzanie_Ro(int *tab3_t, int *tab4_t)
{

tab4_t[0]=tab3_t[31];  tab4_t[1]=tab3_t[0];   tab4_t[2]=tab3_t[1];   tab4_t[3]=tab3_t[2];   tab4_t[4]=tab3_t[3];   tab4_t[5]=tab3_t[4];
tab4_t[6]=tab3_t[3];   tab4_t[7]=tab3_t[4];   tab4_t[8]=tab3_t[5];   tab4_t[9]=tab3_t[6];   tab4_t[10]=tab3_t[7];  tab4_t[11]=tab3_t[8];
tab4_t[12]=tab3_t[7];  tab4_t[13]=tab3_t[8];  tab4_t[14]=tab3_t[9];  tab4_t[15]=tab3_t[10]; tab4_t[16]=tab3_t[11]; tab4_t[17]=tab3_t[12];
tab4_t[18]=tab3_t[11]; tab4_t[19]=tab3_t[12]; tab4_t[20]=tab3_t[13]; tab4_t[21]=tab3_t[14]; tab4_t[22]=tab3_t[15]; tab4_t[23]=tab3_t[16];
tab4_t[24]=tab3_t[15]; tab4_t[25]=tab3_t[16]; tab4_t[26]=tab3_t[17]; tab4_t[27]=tab3_t[18]; tab4_t[28]=tab3_t[19]; tab4_t[29]=tab3_t[20];
tab4_t[30]=tab3_t[19]; tab4_t[31]=tab3_t[20]; tab4_t[32]=tab3_t[21]; tab4_t[33]=tab3_t[22]; tab4_t[34]=tab3_t[23]; tab4_t[35]=tab3_t[24];
tab4_t[36]=tab3_t[23]; tab4_t[37]=tab3_t[24]; tab4_t[38]=tab3_t[25]; tab4_t[39]=tab3_t[26]; tab4_t[40]=tab3_t[27]; tab4_t[41]=tab3_t[28];
tab4_t[42]=tab3_t[27]; tab4_t[43]=tab3_t[28]; tab4_t[44]=tab3_t[29]; tab4_t[45]=tab3_t[30]; tab4_t[46]=tab3_t[31]; tab4_t[47]=tab3_t[0];

return 0;
}

int zamiana_na_bloki(int *tab_xor, int *B1, int *B2, int *B3, int *B4, int *B5, int *B6, int *B7, int *B8)
{
int i,j;

	for(i=0;i<6;i++)
	B1[i]=tab_xor[i];

j=0;
	for(i=6;i<12;i++)
        {
	B2[j]=tab_xor[i];
	j++;
	}

j=0;
	for(i=12;i<18;i++)
        {
	B3[j]=tab_xor[i];
	j++;
	}

j=0;
	for(i=18;i<24;i++)
        {
	B4[j]=tab_xor[i];
	j++;
	}

j=0;
	for(i=24;i<30;i++)
        {
	B5[j]=tab_xor[i];
	j++;
	}

j=0;
	for(i=30;i<36;i++)
        {
	B6[j]=tab_xor[i];
	j++;
	}

j=0;
	for(i=36;i<42;i++)
        {
	B7[j]=tab_xor[i];
	j++;
	}

j=0;
	for(i=42;i<48;i++)
        {
	B8[j]=tab_xor[i];
	j++;
	}

return 0;
}


int binarny_krotki(int liczba, int *tab_y)
{
int reszta,i, j, tab_pom[4];

	for(i=0;i<4;i++)
	{
	reszta=liczba%2;  //zamiana znaku na kod binarny
	liczba=liczba/2;

	tab_pom[i]=reszta;
	}

j=3;

	for(i=0;i<4;i++)
	{
	tab_y[j]=tab_pom[i];    //zamiana z konca na poczatek
	j--;
	}

return 0;
}



int S1(int *B1, int *y1)
{
int kolumna, wiersz, liczba;
int S_1[4][16]={ {14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13} };

wiersz=2*B1[0]+B1[5];
kolumna=8*B1[1]+4*B1[2]+2*B1[3]+B1[4];

liczba=S_1[wiersz][kolumna];

binarny_krotki(liczba, y1);

return 0;
}


int S2(int *B2, int *y2)
{
int  liczba, kolumna, wiersz;
int S_2[4][16]={ {15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9} };

wiersz=2*B2[0]+B2[5];
kolumna=8*B2[1]+4*B2[2]+2*B2[3]+B2[4];

liczba=S_2[wiersz][kolumna];

binarny_krotki(liczba, y2);

return 0;
}


int S3(int *B3, int *y3)
{
int liczba, kolumna, wiersz;
int S_3[4][16]={ {10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8}, {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1}, {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7}, {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}};

wiersz=2*B3[0]+B3[5];
kolumna=8*B3[1]+4*B3[2]+2*B3[3]+B3[4];

liczba=S_3[wiersz][kolumna];

binarny_krotki(liczba, y3);

return 0;
}


int S4(int *B4, int *y4)
{
int liczba, kolumna, wiersz;
int S_4[4][16]={ {7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,5},{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14} };

wiersz=2*B4[0]+B4[5];
kolumna=8*B4[1]+4*B4[2]+2*B4[3]+B4[4];

liczba=S_4[wiersz][kolumna];

binarny_krotki(liczba, y4);

return 0;
}

int S5(int *B5, int *y5)
{
int liczba, kolumna, wiersz;
int S_5[4][16]={ {2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3} };

wiersz=2*B5[0]+B5[5];
kolumna=8*B5[1]+4*B5[2]+2*B5[3]+B5[4];

liczba=S_5[wiersz][kolumna];

binarny_krotki(liczba, y5);

return 0;
}

int S6(int *B6, int *y6)
{
int liczba, kolumna, wiersz;
int S_6[4][16]={ {12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13} };

wiersz=2*B6[0]+B6[5];
kolumna=8*B6[1]+4*B6[2]+2*B6[3]+B6[4];

liczba=S_6[wiersz][kolumna];

binarny_krotki(liczba, y6);

return 0;
}

int S7(int *B7, int *y7)
{
int liczba, kolumna, wiersz;
int S_7[4][16]={ {4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12} };

wiersz=2*B7[0]+B7[5];
kolumna=8*B7[1]+4*B7[2]+2*B7[3]+B7[4];

liczba=S_7[wiersz][kolumna];

binarny_krotki(liczba, y7);

return 0;
}


int S8(int *B8, int *y8)
{
int liczba, kolumna, wiersz;
int S_8[4][16]={ {13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11} };

wiersz=2*B8[0]+B8[5];
kolumna=8*B8[1]+4*B8[2]+2*B8[3]+B8[4];

liczba=S_8[wiersz][kolumna];

binarny_krotki(liczba, y8);

return 0;
}

int laczenie_y(int *y1, int *y2, int *y3, int *y4, int *y5, int *y6, int *y7, int *y8, int *blok_P)
{
int i,j;

	for(i=0; i<4; i++)
	blok_P[i]=y1[i];
j=4;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y2[i];
	j++;
	}

j=8;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y3[i];
	j++;
	}

j=12;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y4[i];
	j++;
	}

j=16;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y5[i];
	j++;
	}

j=20;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y6[i];
	j++;
	}

j=24;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y7[i];
	j++;
	}

j=28;

	for(i=0; i<4; i++)
	{
	blok_P[j]=y8[i];
	j++;
	}


return 0;
}

int permutacja_P_bloku(int *blok_P)
{
int pom[32], i;

	for(i=0; i<32; i++)
	  pom[i]=blok_P[i];

blok_P[0]=pom[15];  blok_P[1]=pom[6];   blok_P[2]=pom[19];  blok_P[3]=pom[20];  blok_P[4]=pom[28];  blok_P[5]=pom[11];  blok_P[6]=pom[27];  blok_P[7]=pom[16];
blok_P[8]=pom[0];   blok_P[9]=pom[14];  blok_P[10]=pom[22]; blok_P[11]=pom[25]; blok_P[12]=pom[4];  blok_P[13]=pom[17]; blok_P[14]=pom[30]; blok_P[15]=pom[9];
blok_P[16]=pom[1];  blok_P[17]=pom[7];  blok_P[18]=pom[23]; blok_P[19]=pom[13]; blok_P[20]=pom[31]; blok_P[21]=pom[26]; blok_P[22]=pom[2];  blok_P[23]=pom[8];
blok_P[24]=pom[18]; blok_P[25]=pom[12]; blok_P[26]=pom[29]; blok_P[27]=pom[5];  blok_P[28]=pom[21]; blok_P[29]=pom[10]; blok_P[30]=pom[3];  blok_P[31]=pom[24];

return 0;
}

int xor_koncowe(int *tab_Ri, int *tab2_t, int *blok_P)
{
int i;

	for(i=0;i<32;i++)
	tab_Ri[i]=tab2_t[i]^blok_P[i];

return 0;
}


int xor(int *tab4_t, int *tab4_k, int *tab_xor)
{
int i;

	for(i=0;i<48;i++)
	tab_xor[i]=tab4_k[i]^tab4_t[i];

return 0;
}


int szyfrowanie(int *tab4_k, int *tab2_k, int *tab3_k, int *tab3_t, int *tab4_t, int *tab_xor, int *B1, int *B2, int *B3, int *B4, int *B5, int *B6, int *B7, int *B8, int *y1, int *y2, int *y3, int *y4, int *y5, int *y6, int *y7, int *y8, int *blok_P, int *tab_Ri, int *tab2_t)
{
int i,j;

	for(i=1;i<17;i++)
	{
	przesuw_klucza(tab2_k,i);
	przesuw_klucza(tab3_k,i);

	permutacja_klucza(tab2_k, tab3_k, tab4_k);

	rozszerzanie_Ro(tab3_t, tab4_t);

	xor(tab4_t, tab4_k, tab_xor);

	zamiana_na_bloki(tab_xor, B1, B2, B3, B4, B5, B6, B7, B8);

	S1(B1, y1);
	S2(B2, y2);
	S3(B3, y3);
	S4(B4, y4);
	S5(B5, y5);
	S6(B6, y6);
	S7(B7, y7);
	S8(B8, y8);

	laczenie_y(y1, y2, y3, y4, y5, y6, y7, y8, blok_P);

	permutacja_P_bloku(blok_P);

	xor_koncowe(tab_Ri, tab2_t, blok_P);


	for(j=0;j<32;j++)
	tab2_t[j]=tab3_t[j];   //Li

	for(j=0;j<32;j++)
	tab3_t[j]=tab_Ri[j];   //Ri

	}

return 0;
}


int deszyfrowanie(int *tab4_k, int *tab2_k, int *tab3_k, int *tab3_t, int *tab4_t, int *tab_xor, int *B1, int *B2, int *B3, int *B4, int *B5, int *B6, int *B7, int *B8, int *y1, int *y2, int *y3, int *y4, int *y5, int *y6, int *y7, int *y8, int *blok_P, int *tab_Ri, int *tab2_t)
{
int i,j,k;

       for(k=1;k<17;k++)
	   {
		przesuw_klucza(tab2_k,k);
		przesuw_klucza(tab3_k,k);
	   }


	for(i=16;i>0;i--)
	{
	 if(i!=16)
	 {
		przesuw_klucza_p(tab2_k,i+1);
		przesuw_klucza_p(tab3_k,i+1);
	 }

	     permutacja_klucza(tab2_k, tab3_k, tab4_k);


	rozszerzanie_Ro(tab3_t, tab4_t);

	xor(tab4_t, tab4_k, tab_xor);

	zamiana_na_bloki(tab_xor, B1, B2, B3, B4, B5, B6, B7, B8);

	S1(B1, y1);
	S2(B2, y2);
	S3(B3, y3);
	S4(B4, y4);
	S5(B5, y5);
	S6(B6, y6);
	S7(B7, y7);
	S8(B8, y8);

	laczenie_y(y1, y2, y3, y4, y5, y6, y7, y8, blok_P);

	permutacja_P_bloku(blok_P);

	xor_koncowe(tab_Ri, tab2_t, blok_P);

	for(j=0;j<32;j++)
	tab2_t[j]=tab3_t[j];   //Li

	for(j=0;j<32;j++)
	tab3_t[j]=tab_Ri[j];   //Ri

	}

return 0;
}



int permutacja_pocz_tekstu(int *tab1_t)
{
int tab_pom[64], i;

	for(i=0;i<64;i++)
	tab_pom[i]=tab1_t[i];

tab1_t[0]=tab_pom[57];  tab1_t[1]=tab_pom[49];  tab1_t[2]=tab_pom[41];  tab1_t[3]=tab_pom[33];  tab1_t[4]=tab_pom[25];  tab1_t[5]=tab_pom[17];  tab1_t[6]=tab_pom[9];   tab1_t[7]=tab_pom[1];
tab1_t[8]=tab_pom[59];  tab1_t[9]=tab_pom[51];  tab1_t[10]=tab_pom[43]; tab1_t[11]=tab_pom[35]; tab1_t[12]=tab_pom[27]; tab1_t[13]=tab_pom[19]; tab1_t[14]=tab_pom[11]; tab1_t[15]=tab_pom[3];
tab1_t[16]=tab_pom[61]; tab1_t[17]=tab_pom[53]; tab1_t[18]=tab_pom[45]; tab1_t[19]=tab_pom[37]; tab1_t[20]=tab_pom[29]; tab1_t[21]=tab_pom[21]; tab1_t[22]=tab_pom[13]; tab1_t[23]=tab_pom[5];
tab1_t[24]=tab_pom[63]; tab1_t[25]=tab_pom[55]; tab1_t[26]=tab_pom[47]; tab1_t[27]=tab_pom[39]; tab1_t[28]=tab_pom[31]; tab1_t[29]=tab_pom[23]; tab1_t[30]=tab_pom[15]; tab1_t[31]=tab_pom[7];
tab1_t[32]=tab_pom[56]; tab1_t[33]=tab_pom[48]; tab1_t[34]=tab_pom[40]; tab1_t[35]=tab_pom[32]; tab1_t[36]=tab_pom[24]; tab1_t[37]=tab_pom[16]; tab1_t[38]=tab_pom[8];  tab1_t[39]=tab_pom[0];
tab1_t[40]=tab_pom[58]; tab1_t[41]=tab_pom[50]; tab1_t[42]=tab_pom[42]; tab1_t[43]=tab_pom[34]; tab1_t[44]=tab_pom[26]; tab1_t[45]=tab_pom[18]; tab1_t[46]=tab_pom[10]; tab1_t[47]=tab_pom[2];
tab1_t[48]=tab_pom[60]; tab1_t[49]=tab_pom[52]; tab1_t[50]=tab_pom[44]; tab1_t[51]=tab_pom[36]; tab1_t[52]=tab_pom[28]; tab1_t[53]=tab_pom[20]; tab1_t[54]=tab_pom[12]; tab1_t[55]=tab_pom[4];
tab1_t[56]=tab_pom[62]; tab1_t[57]=tab_pom[54]; tab1_t[58]=tab_pom[46]; tab1_t[59]=tab_pom[38]; tab1_t[60]=tab_pom[30]; tab1_t[61]=tab_pom[22]; tab1_t[62]=tab_pom[14]; tab1_t[63]=tab_pom[6];

return 0;
}

int permutacja_kon_tekstu(int *tab1_t, int *tab3_t, int *tab2_t, char *tekst)
{
int tab_pom[64], i,j;

	//zamiana Li <-> Ri

	for(i=0;i<32;i++)
	tab_pom[i]=tab3_t[i];

j=32;

        for(i=0;i<32;i++)
        {
	tab_pom[j]=tab2_t[i];
	j++;
	}


tab1_t[0]=tab_pom[39];  tab1_t[1]=tab_pom[7];  tab1_t[2]=tab_pom[47];  tab1_t[3]=tab_pom[15];  tab1_t[4]=tab_pom[55];  tab1_t[5]=tab_pom[23];  tab1_t[6]=tab_pom[63];  tab1_t[7]=tab_pom[31];
tab1_t[8]=tab_pom[38];  tab1_t[9]=tab_pom[6];  tab1_t[10]=tab_pom[46]; tab1_t[11]=tab_pom[14]; tab1_t[12]=tab_pom[54]; tab1_t[13]=tab_pom[22]; tab1_t[14]=tab_pom[62]; tab1_t[15]=tab_pom[30];
tab1_t[16]=tab_pom[37]; tab1_t[17]=tab_pom[5]; tab1_t[18]=tab_pom[45]; tab1_t[19]=tab_pom[13]; tab1_t[20]=tab_pom[53]; tab1_t[21]=tab_pom[21]; tab1_t[22]=tab_pom[61]; tab1_t[23]=tab_pom[29];
tab1_t[24]=tab_pom[36]; tab1_t[25]=tab_pom[4]; tab1_t[26]=tab_pom[44]; tab1_t[27]=tab_pom[12]; tab1_t[28]=tab_pom[52]; tab1_t[29]=tab_pom[20]; tab1_t[30]=tab_pom[60]; tab1_t[31]=tab_pom[28];
tab1_t[32]=tab_pom[35]; tab1_t[33]=tab_pom[3]; tab1_t[34]=tab_pom[43]; tab1_t[35]=tab_pom[11]; tab1_t[36]=tab_pom[51]; tab1_t[37]=tab_pom[19]; tab1_t[38]=tab_pom[59]; tab1_t[39]=tab_pom[27];
tab1_t[40]=tab_pom[34]; tab1_t[41]=tab_pom[2]; tab1_t[42]=tab_pom[42]; tab1_t[43]=tab_pom[10]; tab1_t[44]=tab_pom[50]; tab1_t[45]=tab_pom[18]; tab1_t[46]=tab_pom[58]; tab1_t[47]=tab_pom[26];
tab1_t[48]=tab_pom[33]; tab1_t[49]=tab_pom[1]; tab1_t[50]=tab_pom[41]; tab1_t[51]=tab_pom[9];  tab1_t[52]=tab_pom[49]; tab1_t[53]=tab_pom[17]; tab1_t[54]=tab_pom[57]; tab1_t[55]=tab_pom[25];
tab1_t[56]=tab_pom[32]; tab1_t[57]=tab_pom[0]; tab1_t[58]=tab_pom[40]; tab1_t[59]=tab_pom[8];  tab1_t[60]=tab_pom[48]; tab1_t[61]=tab_pom[16]; tab1_t[62]=tab_pom[56]; tab1_t[63]=tab_pom[24];

tekst[0]=128*tab1_t[0]+64*tab1_t[1]+32*tab1_t[2]+16*tab1_t[3]+8*tab1_t[4]+4*tab1_t[5]+2*tab1_t[6]+tab1_t[7];
tekst[1]=128*tab1_t[8]+64*tab1_t[9]+32*tab1_t[10]+16*tab1_t[11]+8*tab1_t[12]+4*tab1_t[13]+2*tab1_t[14]+tab1_t[15];
tekst[2]=128*tab1_t[16]+64*tab1_t[17]+32*tab1_t[18]+16*tab1_t[19]+8*tab1_t[20]+4*tab1_t[21]+2*tab1_t[22]+tab1_t[23];
tekst[3]=128*tab1_t[24]+64*tab1_t[25]+32*tab1_t[26]+16*tab1_t[27]+8*tab1_t[28]+4*tab1_t[29]+2*tab1_t[30]+tab1_t[31];
tekst[4]=128*tab1_t[32]+64*tab1_t[33]+32*tab1_t[34]+16*tab1_t[35]+8*tab1_t[36]+4*tab1_t[37]+2*tab1_t[38]+tab1_t[39];
tekst[5]=128*tab1_t[40]+64*tab1_t[41]+32*tab1_t[42]+16*tab1_t[43]+8*tab1_t[44]+4*tab1_t[45]+2*tab1_t[46]+tab1_t[47];
tekst[6]=128*tab1_t[48]+64*tab1_t[49]+32*tab1_t[50]+16*tab1_t[51]+8*tab1_t[52]+4*tab1_t[53]+2*tab1_t[54]+tab1_t[55];
tekst[7]=128*tab1_t[56]+64*tab1_t[57]+32*tab1_t[58]+16*tab1_t[59]+8*tab1_t[60]+4*tab1_t[61]+2*tab1_t[62]+tab1_t[63];

return 0;

}