moje.c

This is a program with my school PWSZ city, maybe it s not great but it execute sorting buubble

#include "moje.h"

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

licznik=0;//licznik

for(i=0;i<8;i++)
{
liczba=napis[i];//liczba jest rowna pierwszemu elementowi klucza

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

	tab_pom[licznik]=reszta;//zapis do tablicy posczegolnych elementow klucza w postaci binarnej
	licznik++;//zwiekszenie licznika
	}
}

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

for(i=0;i<64;i++)
{
tab_x[j]=tab_pom[i];    //zamiana z konca na poczatek
licznik++;//zwiekszenie licznika
	if(licznik==8)//jesli licznik jest rowny 8
	{
	licznik=0;
	liczba+=8;
	j=liczba+1;
	}
j--;//zmniejszenie 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];
//zapis wartosci elementow z tablicy gdzie klucz byl podany w postaci binarnej do nowej tablicy z przesunieciem klucza o 8
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)
{