//ATmega8

////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////// GOST: 
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////// Key:
//unsigned char xK = 0;        //счёт Key 
//unsigned char Key_N_ = 0; //Key_N_ = 0,1,2 -Номер Key   
////////////////////////////////////////K_int[128] 
unsigned int K_int[128] = {
//////////////////////////////////////// 0...7
////////////////vektor_0:  
0,0,0,0,0,0,0,0,
//////////////////////////////////////// 8...39
////////////////Key_0: 32 байт (256-бит)
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,
//////////////////////////////////////// 40...47
////////////////vektor_1: 
0,0,0,0,0,0,0,0,
//////////////////////////////////////// 48...79
////////////////Key_1: 32 байт (256-бит)
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,
//////////////////////////////////////// 80...87
////////////////vektor_2: 
0,0,0,0,0,0,0,0,
//////////////////////////////////////// 88...119
////////////////Key_2: 32 байт (256-бит)
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,
//////////////////////////////////////// 120...127
////////////////Флаги:
0,0,0,0,0,0,
////////////////crc:
0,0
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// vektor_RX:
unsigned int vektor_RX[8] = {0,0,0,0,0,0,0,0};  
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////// vektor_0:
//////////////////////////////////счёт вектор инициализации: 
void vektor_0(void) {
    ////////////////////////////////////////0...7
    K_int[0] = GS_TX();      //GS = 1...255  
    ////////////////////////////////////////проверка счёт вектор инициализации:          
    if (K_int[1] == 0) { // MAX K_int[x] больше  
        K_int[7]++;
    }
    ////////////////////////////////////////////////
    if (K_int[7] > 0xFF) {K_int[7]=0; K_int[6]++;}//счёт вектор инициализации
    if (K_int[6] > 0xFF) {K_int[6]=0; K_int[5]++;}//счёт вектор инициализации
    if (K_int[5] > 0xFF) {K_int[5]=0; K_int[4]++;}//счёт вектор инициализации
    if (K_int[4] > 0xFF) {K_int[4]=0; K_int[3]++;}//счёт вектор инициализации
    if (K_int[3] > 0xFF) {K_int[3]=0; K_int[2]++;}//счёт вектор инициализации
    if (K_int[2] > 0xFF) {K_int[2]=0; K_int[1]++;}//счёт вектор инициализации
}	
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////// vektor_1:
//////////////////////////////////счёт вектор инициализации: 
void vektor_1(void) {
    ////////////////////////////////////////40...47
    K_int[40] = GS_TX();  //GS = 1...255 
    //////////////////////////////////////////////// проверка счёт вектор инициализации:          
    if (K_int[41] == 0) { // MAX K_int[x] больше   
        K_int[47]++;
    }
    ////////////////////////////////////////////////
    if (K_int[47] > 0xFF) {K_int[47]=0; K_int[46]++;}//счёт вектор инициализации  
    if (K_int[46] > 0xFF) {K_int[46]=0; K_int[45]++;}//счёт вектор инициализации
    if (K_int[45] > 0xFF) {K_int[45]=0; K_int[44]++;}//счёт вектор инициализации
    if (K_int[44] > 0xFF) {K_int[44]=0; K_int[43]++;}//счёт вектор инициализации
    if (K_int[43] > 0xFF) {K_int[43]=0; K_int[42]++;}//счёт вектор инициализации
    if (K_int[42] > 0xFF) {K_int[42]=0; K_int[41]++;}//счёт вектор инициализации
}	
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////// vektor_2:
//////////////////////////////////счёт вектор инициализации: 
void vektor_2(void) {
    ////////////////////////////////////////40...47
    K_int[80] = GS_TX();  //GS = 1...255 
    //////////////////////////////////////////////// проверка счёт вектор инициализации:          
    if (K_int[81] == 0) { // MAX K_int[x] больше   
        K_int[87]++;
    }
    ////////////////////////////////////////////////
    if (K_int[87] > 0xFF) {K_int[87]=0; K_int[86]++;}//счёт вектор инициализации
    if (K_int[86] > 0xFF) {K_int[86]=0; K_int[85]++;}//счёт вектор инициализации
    if (K_int[85] > 0xFF) {K_int[85]=0; K_int[84]++;}//счёт вектор инициализации
    if (K_int[84] > 0xFF) {K_int[84]=0; K_int[83]++;}//счёт вектор инициализации
    if (K_int[83] > 0xFF) {K_int[83]=0; K_int[82]++;}//счёт вектор инициализации
    if (K_int[82] > 0xFF) {K_int[82]=0; K_int[81]++;}//счёт вектор инициализации
}	
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// Буфер Key:
//Буфер Key 32 байт (256-бит) разбивается на 4 байт (32-бит): K1…K8 
unsigned char K1[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K2[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K3[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K4[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K5[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K6[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K7[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
unsigned char K8[5] = {0x00,0x00,0x00,0x00,0x00};//1...4
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////// Key_0 > Буфер Key:
//Key_0 > Буфер Key: 
void Key_0_Key(void) {
  K1[1]=0x45; K1[2]=0xA2; K1[3]=0x81; K1[4]=0x3C;
  K2[1]=0x7F; K2[2]=0xC8; K2[3]=0x74; K2[4]=0xCE;
  K3[1]=0x83; K3[2]=0x50; K3[3]=0xE6; K3[4]=0x38;
  K4[1]=0xF9; K4[2]=0xD5; K4[3]=0x04; K4[4]=0x14;
  K5[1]=0x49; K5[2]=0x56; K5[3]=0x63; K5[4]=0x05;
  K6[1]=0x20; K6[2]=0x65; K6[3]=0x89; K6[4]=0x53;
  K7[1]=0x64; K7[2]=0x40; K7[3]=0x17; K7[4]=0x30;
  K8[1]=0x50; K8[2]=0x92; K8[3]=0x86; K8[4]=0x78;
}
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////// Key_1 > Буфер Key:
//Key_1 > Буфер Key:  
void Key_1_Key(void) {
  K1[1]=K_int[48]; K1[2]=K_int[49]; K1[3]=K_int[50]; K1[4]=K_int[51];
  K2[1]=K_int[52]; K2[2]=K_int[53]; K2[3]=K_int[54]; K2[4]=K_int[55];
  K3[1]=K_int[56]; K3[2]=K_int[57]; K3[3]=K_int[58]; K3[4]=K_int[59];
  K4[1]=K_int[60]; K4[2]=K_int[61]; K4[3]=K_int[62]; K4[4]=K_int[63];
  K5[1]=K_int[64]; K5[2]=K_int[65]; K5[3]=K_int[66]; K5[4]=K_int[67];
  K6[1]=K_int[68]; K6[2]=K_int[69]; K6[3]=K_int[70]; K6[4]=K_int[71];
  K7[1]=K_int[72]; K7[2]=K_int[73]; K7[3]=K_int[74]; K7[4]=K_int[75];
  K8[1]=K_int[76]; K8[2]=K_int[77]; K8[3]=K_int[78]; K8[4]=K_int[79];
}
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////// Key_2 > Буфер Key:
//Key_2 > Буфер Key:  
void Key_2_Key(void) {
  K1[1]=K_int[88]; K1[2]=K_int[89]; K1[3]=K_int[90]; K1[4]=K_int[91];
  K2[1]=K_int[92]; K2[2]=K_int[93]; K2[3]=K_int[94]; K2[4]=K_int[95];
  K3[1]=K_int[96]; K3[2]=K_int[97]; K3[3]=K_int[98]; K3[4]=K_int[99];
  K4[1]=K_int[100]; K4[2]=K_int[101]; K4[3]=K_int[102]; K4[4]=K_int[103];
  K5[1]=K_int[104]; K5[2]=K_int[105]; K5[3]=K_int[106]; K5[4]=K_int[107];
  K6[1]=K_int[108]; K6[2]=K_int[109]; K6[3]=K_int[110]; K6[4]=K_int[111];
  K7[1]=K_int[112]; K7[2]=K_int[113]; K7[3]=K_int[114]; K7[4]=K_int[115];
  K8[1]=K_int[116]; K8[2]=K_int[117]; K8[3]=K_int[118]; K8[4]=K_int[119];
}
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////// raund_Key:
unsigned char raund = 0;   //номер раунд (Всего 32 раунда) 
unsigned char xraund = 0; //счёт raund 
//Буфер Ключ: K1...K8 > K
unsigned int K[5]={0x00,0x00,0x00,0x00,0x00};//1...4
//расписание ключей шифрования 32–З:
//k1,k2,k3,k4,k5,k6,k7,k8,k1,k2,k3,k4,k5,k6,k7,k8,k1,k2,k3,k4,k5,k6,k7,k8,k8,k7,k6,k5,k4,k3,k2,k1
void KZ(void){
if (raund==0)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==1)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==2)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==3)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==4)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==5)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==6)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==7)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	

if (raund==8)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==9)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==10) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==11) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==12) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==13) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==14) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==15) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	
	
if (raund==16) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==17) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==18) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==19) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==20) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==21) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==22) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==23) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	
	
if (raund==24) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==25) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==26) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==27) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==28) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==29) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==30) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==31) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
};
//расписание ключей расшифровывания 32–Р:
//k1,k2,k3,k4,k5,k6,k7,k8,k8,k7,k6,k5,k4,k3,k2,k1,k8,k7,k6,k5,k4,k3,k2,k1,k8,k7,k6,k5,k4,k3,k2,k1
//public static void KR() {   
void KR(void){
if (raund==0)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==1)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==2)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==3)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==4)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==5)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==6)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==7)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	

if (raund==8)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==9)  {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==10) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==11) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==12) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==13) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==14) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==15) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
		
if (raund==16) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==17) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==18) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==19) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==20) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==21) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==22) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==23) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
		
if (raund==24) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K8[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==25) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K7[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==26) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K6[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==27) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K5[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==28) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K4[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==29) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K3[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==30) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K2[xraund];};}//расписание ключей: K1...K8 > K 	
if (raund==31) {for (xraund=4; xraund>0; xraund--) {K[xraund] = K1[xraund];};}//расписание ключей: K1...K8 > K 	
};
//bufer S_блок 
unsigned char bufer_S_blok_1 = 0;
unsigned char bufer_S_blok_2 = 0;
//строки нумеруются от 0 до 7, столбцы от 0 до F
//S_блок
unsigned char S_blok_1[16]={
0x0F,0x0C,0x02,0x0A,0x06,0x04,0x05,0x00,0x07,0x09,0x0E,0x0D,0x01,0x0B,0x08,0x03 
}; 
unsigned char S_blok_2[16]={
0x0B,0x06,0x03,0x04,0x0C,0x0F,0x0E,0x02,0x07,0x0D,0x08,0x00,0x05,0x0A,0x09,0x01 
}; 
unsigned char S_blok_3[16]={
0x01,0x0C,0x0B,0x00,0x0F,0x0E,0x06,0x05,0x0A,0x0D,0x04,0x08,0x09,0x03,0x07,0x02 
}; 
unsigned char S_blok_4[16]={
0x01,0x05,0x0E,0x0C,0x0A,0x07,0x00,0x0D,0x06,0x02,0x0B,0x04,0x09,0x03,0x0F,0x08 
}; 
unsigned char S_blok_5[16]={
0x00,0x0C,0x08,0x09,0x0D,0x02,0x0A,0x0B,0x07,0x03,0x06,0x05,0x04,0x0E,0x0F,0x01 
}; 
unsigned char S_blok_6[16]={
0x08,0x00,0x0F,0x03,0x02,0x05,0x0E,0x0B,0x01,0x0A,0x04,0x07,0x0C,0x09,0x0D,0x06 
}; 
unsigned char S_blok_7[16]={
0x03,0x00,0x06,0x0F,0x01,0x0E,0x09,0x02,0x0D,0x08,0x0C,0x04,0x0B,0x0A,0x05,0x07 
}; 
unsigned char S_blok_8[16]={
0x01,0x0A,0x06,0x08,0x0F,0x0B,0x00,0x04,0x0C,0x03,0x05,0x09,0x07,0x0D,0x02,0x0E 
}; 
//S_блок подстановка:
unsigned int bufer_L[5]={0x00,0x00,0x00,0x00,0x00}; //1...4
unsigned int bufer_R[5]={0x00,0x00,0x00,0x00,0x00}; //1...4
void blok(void){
	 //bufer_R = {0x00,0x01,0x02,0x03,0x04}; //1...4
	 bufer_S_blok_1 = bufer_R[4] & 0x0F;      // = 0x04; 
	 bufer_S_blok_2 = bufer_R[4] & 0xF0;      // = 0x04; 
	 bufer_S_blok_2 = (bufer_S_blok_2 >> 4);  //0xF0 > 0x0F; 
	 
	 bufer_R[4] = S_blok_2[bufer_S_blok_2];   //0xF0;
	 bufer_R[4] = bufer_R[4]<<4;
	 bufer_R[4] |= S_blok_1[bufer_S_blok_1];  //0x0F;
	 
	 bufer_S_blok_1 = bufer_R[3] & 0x0F;      // = 0x04; 
	 bufer_S_blok_2 = bufer_R[3] & 0xF0;      // = 0x04; 
	 bufer_S_blok_2 = (bufer_S_blok_2 >> 4);  //0xF0 > 0x0F; 
	
	 bufer_R[3] = S_blok_4[bufer_S_blok_2];   //0xF0;
	 bufer_R[3] = bufer_R[3]<<4;
	 bufer_R[3] |= S_blok_3[bufer_S_blok_1];  //0x0F;
	 
	 bufer_S_blok_1 = bufer_R[2] & 0x0F;      // = 0x04; 
	 bufer_S_blok_2 = bufer_R[2] & 0xF0;      // = 0x04; 
	 bufer_S_blok_2 = (bufer_S_blok_2 >> 4);  //0xF0 > 0x0F; 
	
	 bufer_R[2] = S_blok_6[bufer_S_blok_2];   //0xF0;
	 bufer_R[2] = bufer_R[2]<<4;
	 bufer_R[2] |= S_blok_5[bufer_S_blok_1];  //0x0F;

	 bufer_S_blok_1 = bufer_R[1] & 0x0F;      // = 0x04; 
	 bufer_S_blok_2 = bufer_R[1] & 0xF0;      // = 0x04; 
	 bufer_S_blok_2 = (bufer_S_blok_2 >> 4);  //0xF0 > 0x0F; 
	
	 bufer_R[1] = S_blok_8[bufer_S_blok_2];   //0xF0;
	 bufer_R[1] = bufer_R[1]<<4;
	 bufer_R[1] |= S_blok_7[bufer_S_blok_1];  //0x0F;

};
//Цикличный сдвиг на 11-бит влево // буфер 32 байт (256-бит)
unsigned char bufer_rol_1 =0; 
unsigned char bufer_rol_2 =0; 
unsigned char bufer_rol_3 =0; 
unsigned char bufer_rol_4 =0; 
//Цикличный сдвиг на 11-бит влево // буфер 32 байт (256-бит)
void rol(void){
     	 bufer_rol_1 = bufer_R[1];   
           bufer_rol_2 = bufer_R[2];  
           bufer_rol_3 = bufer_R[3];   
           bufer_rol_4 = bufer_R[4];   
    	
   	 bufer_R[1] =  (bufer_rol_2<<3);     
           bufer_R[1] |= (bufer_rol_3>>5);  
    
           bufer_R[2] =  (bufer_rol_3<<3);  
           bufer_R[2] |= (bufer_rol_4>>5);  

           bufer_R[3] =  (bufer_rol_4<<3);    
           bufer_R[3] |= (bufer_rol_1>>5);  

       	 bufer_R[4] =  (bufer_rol_1<<3);  
           bufer_R[4] |= (bufer_rol_2>>5);   
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 unsigned char xGOST = 0; //счёт GOST 
//Входной блок 8 байт (64-бит) 
//N = 0x0102030405060708;  
//Входной блок разбиваем на два блока по 4 байт (32-бит) L и R	
//L = 0x01020304; //L = {0x01,0x02,0x03,0x04};
//R = 0x05060708; //R = {0x05,0x06,0x07,0x08};	
unsigned char L[5]={0x00,0x00,0x00,0x00,0x00}; //1...4
unsigned char R[5]={0x00,0x00,0x00,0x00,0x00}; //1...4
unsigned int LR = 0;
///////////////////////////////// один блок шифрования 32–З  =0,040c
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////// цикл шифрования 32–З: 
void GOST_Z(void){
///////////////////////////////////////////////////////////// raund 0...30:	 
for (raund=0; raund<31; raund++) {		
/////////////////////////////////////////// 0:   -один цикл = 0.000.2с х 31= 0.006с  
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] = L[xGOST];  // 4 байт (32 бит)
bufer_R[xGOST] = R[xGOST]; // 4 байт (32 бит)
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:    -один цикл = 0.000.5с х 31= 0.015с 
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл шифрования 32–З   -> K = 0.000.2с х 31= 0.005.9с 
KZ();                                              
// bufer_R + K сложение по модулю 32^2:      -> K = 0.000.3с х 31= 0.009.3с 
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_R[xGOST] += K[xGOST];  // 4 байт (32 бит)
LR = (bufer_R[xGOST] >> 8);    // 0xFF00 
bufer_R[xGOST-1] += LR;
bufer_R[xGOST] &= 0x00FF;     // 0x00FF 
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:     -один цикл = 0.000.2с х 31= 0.006.2с 
//Пункт 2: производим замену (S-блок):
blok();
///////////////////////////////////////////
/////////////////////////////////////////// 3:     -один цикл = 0.000.1с х 31= 0.003.1с 
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol();
///////////////////////////////////////////
/////////////////////////////////////////// 4:    -один цикл = 0.000.12с х 31= 0.003.7с 
//Пункт 4: bufer_L = bufer_R xor bufer_L:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] ^= bufer_R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5:    -один цикл = 0.000.12с х 31= 0.003.7с 
//Пункт 5: меняем местами R = L, L = R:
for (xGOST=4; xGOST>0; xGOST--) {       
L[xGOST] = R[xGOST]; 
R[xGOST] = bufer_L[xGOST]; 
};
///////////////////////////////////////////
};	     
///////////////////////////////////////////////////////////// raund 31: 
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] = L[xGOST];
bufer_R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл шифрования 32–З
KZ();
//bufer_R + K сложение по модулю 32^2:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_R[xGOST] += K[xGOST]; 
LR = (bufer_R[xGOST] >> 8); // 0xFF00
bufer_R[xGOST-1] += LR;
bufer_R[xGOST] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] ^= bufer_R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5: последний раунд не инвертировать !
//Пункт 5: меняем местами R = L, L = R:
for (xGOST=4; xGOST>0; xGOST--) {       
//L[xGOST] = R[xGOST]; 
//R[xGOST] = bufer_L[xGOST]; 
L[xGOST] = bufer_L[xGOST]; 
//R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////// цикл расшифровывания 32–Р:
void GOST_R(void){
///////////////////////////////////////////////////////////// raund 0...30:	
for (raund=0; raund<31; raund++) {		
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] = L[xGOST];
bufer_R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл расшифровывания 32–Р
KR();
//bufer_R + K сложение по модулю 32^2:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_R[xGOST] += K[xGOST]; 
LR = (bufer_R[xGOST] >> 8); // 0xFF00
bufer_R[xGOST-1] += LR;
bufer_R[xGOST] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOSTor bufer_L:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] ^= bufer_R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5:
//Пункт 5: меняем местами R = L, L = R:
for (xGOST=4; xGOST>0; xGOST--) {       
L[xGOST] = R[xGOST]; 
R[xGOST] = bufer_L[xGOST]; 
};
///////////////////////////////////////////
};
///////////////////////////////////////////////////////////// raund 31: 
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] = L[xGOST];
bufer_R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл расшифровывания 32–Р
KR();
//bufer_R + K сложение по модулю 32^2:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_R[xGOST] += K[xGOST]; 
LR = (bufer_R[xGOST] >> 8); // 0xFF00
bufer_R[xGOST-1] += LR;
bufer_R[xGOST] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST=4; xGOST>0; xGOST--) {       
bufer_L[xGOST] ^= bufer_R[xGOST]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5: последний раунд не инвертировать !
//Пункт 5: меняем местами R = L, L = R:
for (xGOST=4; xGOST>0; xGOST--) {       
//L[xGOST] = R[xGOST]; 
//R[xGOST] = bufer_L[xGOST]; 
L[xGOST] = bufer_L[xGOST]; 
//R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// gamma TX:
unsigned int TX_gamma_st = 0; //счёт gamma TX
////////////////////////////////////////////////////////////// шифрования 32–З: TX:
void GOST_TX(void){
//Входной блок 8 байт разбиваем на два блока по 4 байт (32-бит) L и R	
//static int [] L = {0x00,0x01,0x02,0x03,0x04}; //1...4
//static int [] R = {0x00,0x05,0x06,0x07,0x08}; //1...4
//////////////////////////////////vektor: 
//TX_int[0] = GS;         //GS = 1...255 
//TX_int[1] = vektor[1];  
//TX_int[2] = vektor[2];  
//TX_int[3] = vektor[3];  
//TX_int[4] = vektor[4];  
//TX_int[5] = vektor[5];  
//TX_int[6] = vektor[6];  
//TX_int[7] = vektor[7];  
/////////////////////////////////////////////////////// 
/////////////// Режим простой замены: 
/////////////////////////////////////////////////////// 
//заносится в регистры L и R
L[1] = TX_int[0];  
L[2] = TX_int[1];   
L[3] = TX_int[2];  
L[4] = TX_int[3];  
R[1] = TX_int[4];  
R[2] = TX_int[5];  
R[3] = TX_int[6];  
R[4] = TX_int[7];  
///////////////////////////////////////////////////////  	
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
GOST_Z(); // цикл шифрования 32–З:
//GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//Блок простой замены. 
TX_int[0] = L[1];
TX_int[1] = L[2];
TX_int[2] = L[3];
TX_int[3] = L[4];
TX_int[4] = R[1];
TX_int[5] = R[2];
TX_int[6] = R[3];
TX_int[7] = R[4];
/////////////////////////////////////////////////////// 
/////////////// Режим обратной связи по выходу:  
/////////////////////////////////////////////////////// 
/////////////////////////////////////////////////////// vektor: 	
//заносится в регистры L и R
//////////////////////////Key_N == 0
if (Key_N_ == 0){
	L[1] = K_int[0];  
	L[2] = K_int[1];   
	L[3] = K_int[2];  
	L[4] = K_int[3];  
	R[1] = K_int[4];  
	R[2] = K_int[5];  
	R[3] = K_int[6];  
	R[4] = K_int[7];  
};
//////////////////////////Key_N == 1
if (Key_N_ == 1){
	L[1] = K_int[40];  
	L[2] = K_int[41];   
	L[3] = K_int[42];  
	L[4] = K_int[43];  
	R[1] = K_int[44];  
	R[2] = K_int[45];  
	R[3] = K_int[46];  
	R[4] = K_int[47];  
};
//////////////////////////Key_N == 2
if (Key_N_ == 2){
	L[1] = K_int[80];  
	L[2] = K_int[81];   
	L[3] = K_int[82];  
	L[4] = K_int[83];  
	R[1] = K_int[84];  
	R[2] = K_int[85];  
	R[3] = K_int[86];  
	R[4] = K_int[87];  
};
///////////////////////////////////////////////////////  	
for (TX_gamma_st = 8; TX_gamma_st < TX_len; TX_gamma_st = TX_gamma_st + 8) {
/////////////////////////////////////////////////////// 
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
GOST_Z(); // цикл шифрования 32–З:
//GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//Блок гаммы
TX_int[TX_gamma_st]   ^= L[1];
TX_int[TX_gamma_st+1] ^= L[2];
TX_int[TX_gamma_st+2] ^= L[3];
TX_int[TX_gamma_st+3] ^= L[4];
TX_int[TX_gamma_st+4] ^= R[1];
TX_int[TX_gamma_st+5] ^= R[2];
TX_int[TX_gamma_st+6] ^= R[3];
TX_int[TX_gamma_st+7] ^= R[4];
};         
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// gamma RX:
unsigned int RX_gamma_st = 0; //счёт gamma RX
/////////////////////////////////////////////////////////// расшифрования 32–Р: RX:
void GOST_RX(void){
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//Входной блок 8 байт разбиваем на два блока по 4 байт (32-бит) L и R	
//static int [] L = {0x00,0x01,0x02,0x03,0x04}; //1...4
//static int [] R = {0x00,0x05,0x06,0x07,0x08}; //1...4
//////////////////////////////////vektor: 
//TX_int[0] = GS;         //GS = 1...255  
//TX_int[1] = vektor[1];  
//TX_int[2] = vektor[2];  
//TX_int[3] = vektor[3];  
//TX_int[4] = vektor[4];  
//TX_int[5] = vektor[5];  
//TX_int[6] = vektor[6];  
//TX_int[7] = vektor[7];  
/////////////////////////////////////////////////////// 
/////////////// Режим простой замены: 
/////////////////////////////////////////////////////// 
///////////////////////////////////////////////////////  	
//заносится в регистры L и R
L[1] = RX_int[0];  
L[2] = RX_int[1];  
L[3] = RX_int[2];
L[4] = RX_int[3];
R[1] = RX_int[4];
R[2] = RX_int[5];
R[3] = RX_int[6];
R[4] = RX_int[7];
///////////////////////////////////////////////////////  	
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
//GOST_Z(); // цикл шифрования 32–З:
GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//расшифровывания 32–Р:
vektor_RX[0] = L[1];  
vektor_RX[1] = L[2];  
vektor_RX[2] = L[3];
vektor_RX[3] = L[4];
vektor_RX[4] = R[1];
vektor_RX[5] = R[2];
vektor_RX[6] = R[3];
vektor_RX[7] = R[4];
/////////////////////////////////////////////////////// 
/////////////// Режим обратной связи по выходу:  
/////////////////////////////////////////////////////// 
///////////////////////////////////////////////////////  	
//заносится в регистры L и R
L[1] = vektor_RX[0]; 
L[2] = vektor_RX[1];  
L[3] = vektor_RX[2];
L[4] = vektor_RX[3];
R[1] = vektor_RX[4];
R[2] = vektor_RX[5];
R[3] = vektor_RX[6];
R[4] = vektor_RX[7];
///////////////////////////////////////////////////////  	
for (RX_gamma_st = 8; RX_gamma_st < RX_len; RX_gamma_st = RX_gamma_st + 8) {
/////////////////////////////////////////////////////// 	
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
GOST_Z(); // цикл шифрования 32–З:
//GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//Блок гаммы 
RX_int[RX_gamma_st]   ^= L[1];
RX_int[RX_gamma_st+1] ^= L[2];
RX_int[RX_gamma_st+2] ^= L[3];
RX_int[RX_gamma_st+3] ^= L[4];
RX_int[RX_gamma_st+4] ^= R[1];
RX_int[RX_gamma_st+5] ^= R[2];
RX_int[RX_gamma_st+6] ^= R[3];
RX_int[RX_gamma_st+7] ^= R[4];
};         
}
////////////////////////////////////////////////////////////////////////////////