/**
\details GOST_ENCRYPTED_GAMMA_WITH_FEEDBACK
Функция шифрования в режиме гаммирования с обратной связью.
\param[in] *Data указатель на даныне для шифрования/дешифрования
\param[in] Size  размер данных
\param[in] *Sync указатель на синхропосылку, заносится текущее значение синхропосылки
\param[in] Mode Если _GOST_MODE_ENCRYPT будет выполнено шифрование данных, если _GOST_MODE_DECRYPT - расшифрование
\param[in] *GOST_Table указатель на таблицу замен ГОСТ в 64-байтном формате
\param[in] *GOST_Key указательн на 256 битный ключ
\attetion Если используется режим совместимости с входами эталонного шифратора, то сихнропосылка
Sync для первого вызова должна быть подготовлена функцицией GOST_PREPARE_SYNCPACK_GAMMA_FEEDBACK
*/
void GOST_ENCRYPTED_GAMMA_WITH_FEEDBACK(BYTE *Data, DWORD Size, BYTE *Sync, bool Mode, BYTE *GOST_Table, BYTE *GOST_Key){
	GOST_PART_DATA *SyncP = (GOST_PART_DATA *)Sync;
	BYTE i, tmp;
	while (Size != 0){
		GOST_ENCRYPTED_32_CICLE(SyncP, GOST_Table, (DWORD *)GOST_Key);
#if _GOST_COMPATIBILITY_STANDART == 1
		(*SyncP).half[_GOST_PART_DATA_N2_HALF] = _SWAPW32((*SyncP).half[_GOST_PART_DATA_N2_HALF]);
		(*SyncP).half[_GOST_PART_DATA_N1_HALF] = _SWAPW32((*SyncP).half[_GOST_PART_DATA_N1_HALF]);
#endif
		for (i = 0; i < _MINIMUM(_GOST_PART_SIZE, Size); i++){
			if (Mode == _GOST_MODE_ENCRYPT){
				*Data ^= (*SyncP).parts[i];
				(*SyncP).parts[i] = *Data;
			}
			else{
				tmp = *Data;
				*Data ^= (*SyncP).parts[i];
				(*SyncP).parts[i] = tmp;
			}
			Data++;
		}
#if _GOST_COMPATIBILITY_STANDART == 1
		(*SyncP).half[_GOST_PART_DATA_N2_HALF] = _SWAPW32((*SyncP).half[_GOST_PART_DATA_N2_HALF]);
		(*SyncP).half[_GOST_PART_DATA_N1_HALF] = _SWAPW32((*SyncP).half[_GOST_PART_DATA_N1_HALF]);
#endif
		Size -= i;
	}
}
/**
\details GOST_SIMPLE_REPLACEMENT
Функция шифрования/расшифрования в режиме простой замены
Параметры:
\param[in] *Data Указатель на данные для шифрования и параметр для занесения данных результата
\param[in] Size Размер данных
\param[in] Mode Если _GOST_MODE_ENCRYPT шифрование, то _GOST_MODE_DECRYPT - расшифрование
\param[in] *GOST_Table Указатель на таблицу замен ГОСТ в 64 байтном формате
\param[in] *GOST_Key Указатель на 256 битный массив ключа
*/
void GOST_SIMPLE_REPLACEMENT(BYTE *Data, DWORD Size, bool Mode, BYTE *GOST_Table, BYTE *GOST_Key){
	BYTE Current_Part_Size;												//Размер текущей части
	GOST_PART_DATA Prepare_Data;											//Подготовленные данные
	DWORD *Gost_Key_Pt = (DWORD*)GOST_Key;							//Ключ

	while (Size != 0){														//Пока не кончатся данные продолжаем работу
		Current_Part_Size = _MINIMUM(_GOST_PART_SIZE, Size);				//Определим минимум из размера порции данных для криптообработки и размера данных
		memset(&Prepare_Data, _GOST_DEFAULT_BYTE, sizeof(Prepare_Data));	//Заполним буфер (&Prepare_Data) символом (_DEFAULT_BYTE), количетсвом символов (sizeof(Prepare_Data))
#if _GOST_COMPATIBILITY_STANDART == 1
		Prepare_Data.half[_GOST_PART_DATA_N2_HALF] = _SWAPW32(Prepare_Data.half[_GOST_PART_DATA_N2_HALF]);
		Prepare_Data.half[_GOST_PART_DATA_N1_HALF] = _SWAPW32(Prepare_Data.half[_GOST_PART_DATA_N1_HALF]);
#endif
		memcpy(&Prepare_Data, Data, Current_Part_Size);						//Скопируем Current_Part_Size байтов первого блока памяти, на который ссылается Data, 
		//во второй блок памяти, на который ссылается &Prepare_Data
		if (Mode == _GOST_MODE_ENCRYPT){
			GOST_ENCRYPTED_32_CICLE(&Prepare_Data, GOST_Table, Gost_Key_Pt);//Запускаем шифрование
		}
		else{
			GOST_DECRYPTED_32_CICLE(&Prepare_Data, GOST_Table, Gost_Key_Pt);//Запускаем дешифрование
		}
#if _GOST_COMPATIBILITY_STANDART == 1
		Prepare_Data.half[_GOST_PART_DATA_N2_HALF] = _SWAPW32(Prepare_Data.half[_GOST_PART_DATA_N2_HALF]);
		Prepare_Data.half[_GOST_PART_DATA_N1_HALF] = _SWAPW32(Prepare_Data.half[_GOST_PART_DATA_N1_HALF]);
#endif
		memcpy(Data, &Prepare_Data, Current_Part_Size);						//Скопируем Current_Part_Size байтов первого блока памяти, на который ссылается Prepare_Data,
		//Во второй блок памяти, на который ссылается Data
		Data += Current_Part_Size;											//Увеличим данные (перейдем к следующей порции) на текущую порцию
		Size -= Current_Part_Size;											//Уменьшим размер на обработанную порцию
	}
}
Beispiel #3
0
/**
@details GOST_Crypt_GF_Data
Функция шифрования в режиме гаммирования с обратной связью.
@param *Data - указатель на данные для шифрования/расшифрования.
@param Size - Размер данных
@param *Synchro - Указатель на синхопросылку,
также сюда заносится текущее значение синхропосылки.
@param Mode - Если _GOST_Mode_Encrypt будет выполнено шифрование данных,
если _GOST_Mode_Decrypt расшифрование
@param *GOST_Table - Указатель на таблицу замены ГОСТ(ДК) в 128 байтном формате
(вместо старшого полубайта 0).
@param *GOST_Key - Указатель на 256 битный массив ключа(СК).
@attention Если используется режим совместимости с входами еталонного шифратора, то синхропосылка
Synchro для первого вызова должна быть подготовлена функцией GOST_Crypt_GF_Prepare_S.
*/
void GOST_Crypt_GF_Data(uint8_t *Data, uint32_t Size, uint8_t *Synchro, bool Mode, uint8_t *GOST_Table, uint8_t *GOST_Key )
{
    GOST_Data_Part *S=(GOST_Data_Part *)Synchro;
    uint8_t i,Tmp;
    while(Size!=0)
    {

        GOST_Crypt_32_E_Cicle(S,GOST_Table,(uint32_t *)GOST_Key);//C32(S)
#if _GOST_ROT==1
        (*S).half[_GOST_Data_Part_N2_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N2_Half]);
        (*S).half[_GOST_Data_Part_N1_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N1_Half]);
#endif
        for (i=0;i<_Min(_GOST_Part_Size,Size);i++)//Data XOR S; S=Data;
        {
            if (Mode==_GOST_Mode_Encrypt)
            {
                *Data^=(*S).parts[i];
                (*S).parts[i]=*Data;
            } else
            {
                Tmp=*Data;
                *Data^=(*S).parts[i];
                (*S).parts[i]=Tmp;
            }
            Data++;
        }
#if _GOST_ROT==1
        (*S).half[_GOST_Data_Part_N2_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N2_Half]);
        (*S).half[_GOST_Data_Part_N1_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N1_Half]);
#endif
        Size-=i;
    }

}
Beispiel #4
0
/**
@details GOST_Crypt_G_Data
Шифрование\Расшифрования блока данных в режиме гаммирования.
@param *Data - Указатель на данные для шифрования\расшифрования, также сюда заносится результат работы.
@param Size - Размер данных
@param *Synchro - Указатель на синхопросылку, также сюда заносится текущее значение синхропосылки.
@param *GOST_Table - Указатель на таблицу замены ГОСТ(ДК) в 128 байтном формате(вместо старшого полубайта 0).
@param *GOST_Key - Указатель на 256 битный массив ключа(СК).
@attention Синхропосылка Synchro для первого вызова должна быть подготовлена функцией/макросом GOST_Crypt_G_PS.
*/
void GOST_Crypt_G_Data(uint8_t *Data, uint32_t Size, uint8_t *Synchro, uint8_t *GOST_Table, uint8_t *GOST_Key )
{

    GOST_Data_Part *S=(GOST_Data_Part *)Synchro;
    GOST_Data_Part Tmp;
    uint8_t i;
    while(Size!=0)
    {
        (*S).half[_GOST_Data_Part_N1_Half]+=_GOST_C0;
        _GOST_ADC32((*S).half[_GOST_Data_Part_N2_Half],_GOST_C1,(*S).half[_GOST_Data_Part_N2_Half]);//_GOST_Data_Part_HiHalf

        Tmp=*S;
        GOST_Crypt_32_E_Cicle(&Tmp,GOST_Table,(uint32_t *)GOST_Key);
#if _GOST_ROT==1
        Tmp.half[_GOST_Data_Part_N2_Half]=_SWAPW32(Tmp.half[_GOST_Data_Part_N2_Half]);
        Tmp.half[_GOST_Data_Part_N1_Half]=_SWAPW32(Tmp.half[_GOST_Data_Part_N1_Half]);
#endif
        for (i=0;i<_Min(_GOST_Part_Size,Size);i++)
        {
            *Data^=Tmp.parts[i];
            Data++;
        }
        Size-=i;
    }
}
Beispiel #5
0
/**
@details GOST_Encrypt_SR
Функция шифрования/расшифрования в режиме простой замены.
@param *Data - Указатель на данные для шифрования, также сюда заносится результат.
@param Size - Размер данных
@param Mode - Если _GOST_Mode_Encrypt шифрования, _GOST_Mode_Decrypt - расшифрование
@param *GOST_Table - Указатель на таблицу замены ГОСТ(ДК) в 128 байтном формате
(вместо старшого полубайта 0)
@param *GOST_Key - Указатель на 256 битный массив ключа(СК).
*/
void GOST_Encrypt_SR(uint8_t *Data, uint32_t Size, bool Mode, uint8_t *GOST_Table, uint8_t *GOST_Key )
{
    uint8_t Cur_Part_Size;
    GOST_Data_Part Data_prep;
    uint32_t *GOST_Key_pt=(uint32_t *) GOST_Key;

    while (Size!=0)
    {
        Cur_Part_Size=_Min(_GOST_Part_Size,Size);
        memset(&Data_prep,_GOST_Def_Byte,sizeof(Data_prep));
        memcpy(&Data_prep,Data,Cur_Part_Size);
#if _GOST_ROT==1
        Data_prep.half[_GOST_Data_Part_N2_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N2_Half]);
        Data_prep.half[_GOST_Data_Part_N1_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N1_Half]);
#endif
        if (Mode==_GOST_Mode_Encrypt)
        {
            GOST_Crypt_32_E_Cicle(&Data_prep,GOST_Table,GOST_Key_pt);
        } else
        {
            GOST_Crypt_32_D_Cicle(&Data_prep,GOST_Table,GOST_Key_pt);
        }
#if _GOST_ROT==1
        Data_prep.half[_GOST_Data_Part_N2_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N2_Half]);
        Data_prep.half[_GOST_Data_Part_N1_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N1_Half]);
#endif
        memcpy(Data,&Data_prep, Cur_Part_Size);
        Data+=Cur_Part_Size;
        Size-=Cur_Part_Size;
   }

}
void GOST_ENCRYPTED_GAMMA(BYTE *Data, DWORD Size, BYTE *SyncPack, BYTE *GOST_Table, DWORD *GOST_Key){
	GOST_PART_DATA *SYNCP = (GOST_PART_DATA *)SyncPack;															//Приведем к 64битному формату синхропосылку
	GOST_PART_DATA tmp;																							//Временная переменная для синхропосылки
	BYTE i;																									//Переменная цикла
	while (Size != 0){																							//Цикл по данным
		(*SYNCP).half[_GOST_PART_DATA_N1_HALF] += _GOST_C0;														//Прибавление константы С0
		_GOST_ADC32((*SYNCP).half[_GOST_PART_DATA_N2_HALF], _GOST_C1, (*SYNCP).half[_GOST_PART_DATA_N2_HALF]);	//Суммирование 
		tmp = *SYNCP;																							//
		GOST_ENCRYPTED_32_CICLE(&tmp, GOST_Table, (DWORD*)GOST_Key);											//Гаммирование.
#if _GOST_COMPATIBILITY_STANDART == 1
		tmp.half[_GOST_PART_DATA_N2_HALF] = _SWAPW32(tmp.half[_GOST_PART_DATA_N2_HALF]);
		tmp.half[_GOST_PART_DATA_N1_HALF] = _SWAPW32(tmp.half[_GOST_PART_DATA_N1_HALF]);
#endif	
		for (i = 0; i < _MINIMUM(_GOST_PART_SIZE, Size); i++){													//Цикл прохода по данным
			*Data ^= tmp.parts[i];																				//Побитовый XOR с частями в 8ми битном представлении
			Data++;																								//Уведичиваем данные
		}																										//Конец FOR
		Size -= i;																								//Уменьшаем размер на порцию
	}																											//Конец While
}
/**
\details GOST_IMITTAPASTE
Расчет имитовставки
\param[in] *Open_data указатель на данные для которых требуется расчитать имитовставку.
\param[in] *Im указатель на массив размером _GOST_IMIT_SIZE (64bit) куда будет занесен результат расчета имитовставки
\param[in] Size Размер данных
\param[in] *GOST_Table Указатель на таблицу замен ГОСТ в 64 байтном формате
\param[in] *GOST_Key Указатель на 256 битный массив ключа
\warning Для первого раунда массив 	Im должен быть заполнен	_GOST_DEFAULT_BYTE
*/
void GOST_IMITTAPASTE(BYTE *Open_data, BYTE *Im, DWORD Size, BYTE *GOST_Table, BYTE *GOST_Key){
	BYTE Current_Part_Size;
	GOST_PART_DATA *Im_Prepare = (GOST_PART_DATA *)Im;
	GOST_PART_DATA Open_data_Prepare;
	while (Size != 0){
		Current_Part_Size = _MINIMUM(_GOST_PART_SIZE, Size);
		Open_data_Prepare.half[_GOST_PART_DATA_N1_HALF] = 0;
		Open_data_Prepare.half[_GOST_PART_DATA_N2_HALF] = 0;
		memcpy(&Open_data_Prepare, Open_data, Current_Part_Size);
		(*Im_Prepare).half[_GOST_PART_DATA_N1_HALF] ^= Open_data_Prepare.half[_GOST_PART_DATA_N1_HALF];
		(*Im_Prepare).half[_GOST_PART_DATA_N2_HALF] ^= Open_data_Prepare.half[_GOST_PART_DATA_N2_HALF];
		Size -= Current_Part_Size;
		Open_data += Current_Part_Size;
		GOST_IMITTAPASTE_ENCRYPTED_CICLE(Im_Prepare, GOST_Table, (DWORD *)GOST_Key);
	}
#if _GOST_COMPATIBILITY_STANDART == 1
	(*Im_Prepare).half[_GOST_PART_DATA_N1_HALF] = _SWAPW32((*Im_Prepare).half[_GOST_PART_DATA_N1_HALF]);
	(*Im_Prepare).half[_GOST_PART_DATA_N2_HALF] = _SWAPW32((*Im_Prepare).half[_GOST_PART_DATA_N2_HALF]);
#endif
}
Beispiel #8
0
//for first round Imitta must set to _GOST_Def_Byte
void GOST_Imitta(uint8_t *Open_Data,  uint8_t *Imitta, uint32_t Size, uint8_t *GOST_Table, uint8_t *GOST_Key )
{

    uint8_t Cur_Part_Size;
    GOST_Data_Part *Imitta_Prep=(GOST_Data_Part *) Imitta;
    GOST_Data_Part Open_Data_Prep;
    while(Size!=0)
    {
        Cur_Part_Size=_Min(_GOST_Part_Size,Size);
        Open_Data_Prep.half[_GOST_Data_Part_N2_Half]=0;
        Open_Data_Prep.half[_GOST_Data_Part_N1_Half]=0;
        memcpy(&Open_Data_Prep,Open_Data,Cur_Part_Size);
        (*Imitta_Prep).half[_GOST_Data_Part_N1_Half]^=Open_Data_Prep.half[_GOST_Data_Part_N1_Half];
        (*Imitta_Prep).half[_GOST_Data_Part_N2_Half]^=Open_Data_Prep.half[_GOST_Data_Part_N2_Half];
        Size-=Cur_Part_Size;
        Open_Data+=Cur_Part_Size;
        GOST_Imitta_16_E_Cicle(Imitta_Prep,GOST_Table,(uint32_t *)GOST_Key);
    }
#if _GOST_ROT==1
    (*Imitta_Prep).half[_GOST_Data_Part_N1_Half]=_SWAPW32((*Imitta_Prep).half[_GOST_Data_Part_N1_Half]);
    (*Imitta_Prep).half[_GOST_Data_Part_N2_Half]=_SWAPW32((*Imitta_Prep).half[_GOST_Data_Part_N2_Half]);
#endif
}