// returns a random number between 0 and 1:
double TRanrotBGenerator::Random() {
uint32 x;
// generate next random number
x = randbuffer[p1] = _lrotl(randbuffer[p2], R1) + _lrotl(randbuffer[p1], R2);
// rotate list pointers
if (--p1 < 0) p1 = KK - 1;
if (--p2 < 0) p2 = KK - 1;
// perform self-test
if (randbuffer[p1] == randbufcopy[0] &&
memcmp(randbuffer, randbufcopy+KK-p1, KK*sizeof(uint32)) == 0) {
// self-test failed
if ((p2 + KK - p1) % KK != JJ) {
// note: the way of printing error messages depends on system
// In Windows you may use FatalAppExit
printf("Random number generator not initialized");}
else {
printf("Random number generator returned to initial state");}
exit(1);}
// conversion to float:
union {double f; uint32 i[2];} convert;
switch (Architecture) {
case LITTLEENDIAN:
convert.i[0] = x << 20;
convert.i[1] = (x >> 12) | 0x3FF00000;
return convert.f - 1.0;
case BIGENDIAN:
convert.i[1] = x << 20;
convert.i[0] = (x >> 12) | 0x3FF00000;
return convert.f - 1.0;
case NONIEEE: default:
;}
// This somewhat slower method works for all architectures, including
// non-IEEE floating point representation:
return (double)x * (1./((double)(uint32)(-1L)+1.));}
ushort
DWordXorShift(
LPSSTR lpsstr,
WORD wModulo,
LPUL lpul
)
{
LPB lpbName = lpsstr->lpName;
UNALIGNED ULONG* lpulName = (UNALIGNED ULONG*) lpbName;
int cb = lpsstr->cb;
int cul;
int iul;
ULONG ulSum = 0;
ULONG ulEnd = 0;
while (cb & 3) {
ulEnd |= byt_toupper (lpbName [ cb - 1 ]);
ulEnd <<= 8;
cb -= 1;
}
cul = cb / 4;
for (iul = 0; iul < cul; iul++) {
ulSum ^= dwrd_toupper(lpulName[iul]);
ulSum = _lrotl (ulSum, 4);
}
ulSum ^= ulEnd;
*lpul = ulSum;
return (ushort) (ulSum % wModulo);
}
unsigned long thirtytwobits(unsigned long seed)
{
/* In use, we call sixteenbits(seed) once
with some nonzero seed, and from then on call it
with seed value zero to get the next random value. It also works fine
if you don't seed it it all, but for short runs you may want to start
from different seeds. Using the same seed twice produces the same
sequence of numbers.*/
register unsigned long l,c,r;
if (seed)
{
shiftregister = seed;
count = 0;
return seed;
}
l = r = c = shiftregister;
#ifndef MYMACROS //Borland compiler
l = _lrotr(l, 1);/* bit i of l equals bit just left of bit i in c */
r = _lrotl(r, 1);/* bit i of r euqals bit just right of bit i in c */
#else //other compiler
l = MYLROTR(l);/* bit i of l equals bit just left of bit i in c */
r = MYLROTL(r);/* bit i of r euqals bit just right of bit i in c */
#endif //MYMACROS
c |= r;
c ^= l; /* c = l xor (c or r), aka rule 30, named by wolfram */
c ^= count; /* rucker's trick to make reaction self-sustaining */
count++;
shiftregister = c;
return c;
}
//GOST basic Simple Step
void GOST_Crypt_Step(GOST_Data_Part *DATA, uint8_t *GOST_Table, uint32_t GOST_Key, bool Last )
{
typedef union
{
uint32_t full;
uint8_t parts[_GOST_TABLE_NODES/2];
} GOST_Data_Part_sum;
GOST_Data_Part_sum S;
uint8_t m;
uint8_t tmp;
//N1=Lo(DATA); N2=Hi(DATA)
S.full = (uint32_t)((*DATA).half[_GOST_Data_Part_N1_Half]+GOST_Key) ;//S=(N1+X)mod2^32
for(m=0; m<(_GOST_TABLE_NODES/2); m++)
{
//S(m)=H(m,S)
tmp=S.parts[m];
S.parts[m] = *(GOST_Table+(tmp&0x0F));//Low value
GOST_Table+= _GOST_TABLE_MAX_NODE_VALUE;//next line in table
S.parts[m] |= (*(GOST_Table+((tmp&0xF0)>>4)))<<4;//Hi value
GOST_Table+= _GOST_TABLE_MAX_NODE_VALUE;//next line in table
}
S.full = (*DATA).half[_GOST_Data_Part_N2_Half]^_lrotl(S.full,11);//S=Rl(11,S); rol S,11 //S XOR N2
if (Last)
{
(*DATA).half[_GOST_Data_Part_N2_Half] = S.full; //N2=S
}else
{
(*DATA).half[_GOST_Data_Part_N2_Half] = (*DATA).half[_GOST_Data_Part_N1_Half];//N2=N1
(*DATA).half[_GOST_Data_Part_N1_Half] = S.full;//N1=S
}
}
void main() {
char a[15],*p,*q;
long n;
unsigned long x,R;
printf ("De un numero unsigned long ..\n");
gets (a);
x = strtoul (a, &p,0);
while (*p != '\0') {
printf ("Cifra errada. Rectifique... %c\n",7);
gets (a);
x = strtoul (a,&p,0);
}
printf ("\n");
printf ("De el numero de veces que desea rotar la cifra\n");
gets (a);
n = strtol (a, &p,0);
while (*p != '\0' || n < -32768L || n > 32767L) {
printf ("Cifra errada. Rectifique... %c\n",7);
gets (a);
n = strtol (a,&p,0);
}
printf ("\n");
R = _lrotl (x, (int)n); /* Rota x n veces hacia la izquierda */
printf ("%#lX, rotado %d vez(ces) hacia",x, (int)n);
printf (" la izquierda es : %#lX\n",R);
getch();
}
//GOST basic Simple Step
void Crypt_Step(Data *DATA, uint8_t *Table, uint32_t Key, bool Last){
typedef union
{
uint32_t full;
uint8_t parts[NODES / 2];
} Data_Part_sum;
Data_Part_sum S;
//N1=Lo(DATA); N2=Hi(DATA)
_ADD32((*DATA).half[N1], Key, S.full);//S=(N1+X)mod2^32
for (uint8_t m = 0; m<(NODES / 2); m++){
S.parts[m] = *(Table + (S.parts[m] & 0x0F));
Table += MAX_NODE_VALUE;//next line in table
}
S.full = (*DATA).half[N2] ^ _lrotl(S.full, 11);//S=Rl(11,S); rol S,11 //S XOR N2
if (Last){
(*DATA).half[N2] = S.full; //N2=S
}else{
(*DATA).half[N2] = (*DATA).half[N1];//N2=N1
(*DATA).half[N1] = S.full;//N1=S
}
}
// set data to network byte order
void CCapsLoader::Swap(PUDWORD buf, int cnt)
{
#ifdef INTEL
for (cnt>>=2; cnt > 0; cnt--, buf++) {
UDWORD src=*buf;
UDWORD dst=_lrotl(src, 8)&0x00ff00ff | _lrotr(src, 8)&0xff00ff00;
*buf=dst;
}
#endif
}
/**
\details GOST_BASIC_STEP_CRYPT
Осуществляет основой шаг криптопреобразования.
Основной шаг криптообразования по своей сути является оператором, определяющим преобразование 64-битового блока данных.
Дополнительным параметром этого оператора является 32-битовый блок, в качестве которого используется какой-либо элемент ключа.
Предусматривает 7 шагов.
ШАГ 0. Определяет исходные данные для основного шага криптопреобразования.
ШАГ 1. Сложение с ключом.
ШАГ 2. Поблочная замена.
ШАГ 3. Циклический сдвиг на 11 бит влево.
ШАГ 4. Побитовое сложение.
ШАГ 5. Сдвиг по цепочке.
ШАГ 6. Полученное значение возвращается как результат выполнения алгоритма основго шага криптопреобразования.
параметры:
\param[in] *DATA Указатель на данные для зашифрования в формате GOST_PART_DATA.
\param[in] *GOST_Table Указатель на таблицу замены ГОСТ в 64 байтном формате
\param[in] GOST_Key - 32х битная часть ключа
\param[in] LastStep - Является ли шаг криптопреобразования последним?
TRUE - заносим результат в 32х битный накопитель N2
FALSE - предыдущее значение N1 сохраняется в N2, а результат пишем в N1.
DWORD - unsigned int 32 bit type
BYTE - unsigned int 8 bit type
*/
void GOST_BASIC_STEP_CRYPT(GOST_PART_DATA *DATA, BYTE *GOST_Table, DWORD GOST_Key, bool LastStep){
typedef union{
DWORD full; //Полное представление данных
BYTE parts[_GOST_NODE_REPLACE_TABLE / 2]; //Часть представления данных - 8/2 = 4
} GOST_PART_DATA_SUM;
BYTE m; //Для поблочной замены
BYTE tmp; //m=0..7, tmp - временная переменная
/**
\details
Шаг 0. N - преобразуемый 64-битовый блока данных, в ходе выполнения шага, его младшая и старшая части (N1 и N2 соответственно)
обрабатываются как отдельные 32-битовые целые числа без знака: N = (N1,N2); X - 32-битовый элемент ключа.
N1 = LOW(DATA), N2 = HI(DATA)
*/
GOST_PART_DATA_SUM S; //Для оператора S = (N1+X)mod32^2
/**
Шаг 1. Сложение с ключом. Младшая половина преобразуемого блока складывается по модулю 2^32 с используемым на шаге
элементом ключа, результат передается на слудющий шаг.
*/
S.full = (DWORD)((*DATA).half[_GOST_PART_DATA_N1_HALF] + GOST_Key); //S = (N1 + X)mod32 ^ 2
/**
Шаг 2. Поблочная замена. 32-битовое значение, полученное на предыдущем шаге интерпретируется как массив из восьми 4-битовых блоков кода:
S=(S0,S1,...S7,S8). Далее значение каждого из восьми блоков заменяется новым, которое выбирается по таблице замен следующим образом:
значение блока Si меняется на Si-тый по порядку элемент (нумерация с 0) i-го узла замен (т.е. i-той строки таблицы замен, нумерация так же с 0).
Другими словами, в качестве замены для значения блока выбирается элемент из таблицы замен с номером строки, равным номеру заменяемого блока как 4-битового
целого неотрицательного числа. Тепер ьстановится понятным размер таблицы замен: число строк в ней равно числу 4-битовых элементов в 32-битовом блоке данных,
т.е. 8, а число столбцов равно числу различных значений 4-битового блока данных, равному как известно 2^4 - 16.
*/
for (m = 0; m < (_GOST_NODE_REPLACE_TABLE / 2); m++) //m=0..7
{
//S(m) = H(m,S(m)) H - Таблица замен
//Битовые сдвиги - умножение или деление на 2 в какой-то степени.
tmp = S.parts[m];
S.parts[m] = *(GOST_Table + (tmp & 0x0F)); //LOW VALUE (tmp "побитовое И" 0x0F - 15)
GOST_Table += _GOST_MAX_NUMBER_OF_ELEMENTS_NODE_TABLE; //Следующая строка таблицы замен
S.parts[m] |= (*(GOST_Table + ((tmp & 0x0F) >> 4))) << 4; //HI VALUE (|= - побитовое ИЛИ с присваиванием; <<,>> - побитовые сдвиги)
GOST_Table += _GOST_MAX_NUMBER_OF_ELEMENTS_NODE_TABLE; //Следующая строка таблицы замен
}
/**
Шаг 3. Циклический сдвиг на 11 бит влево. Результат предыдущего шага сдвигается циклически на 11 бит в сторону старших разряодв и передается
на следующий шаг.
Шаг 4. Побитовое сложение. Значение полученное на шаге 3, побитно складывается по модулю 2 со старшей половиной преобразуемого блока.
Шаг 5. Свдиг по цепочке: младшая часть преобразуемого блока сдвигается на место старшей, а на её место помещается результат выполнения предыдущего шага.
Шаг 6. Полученное значение преобразуемого блока возвращается как результат выполнения алгоритма основого шага криптопреобразования.
*/
S.full = (*DATA).half[_GOST_PART_DATA_N2_HALF] ^ _lrotl(S.full, 11); //S=<-R(11,S) S= XOR N2
if (LastStep){ //Если шаг преобразования последний,
(*DATA).half[_GOST_PART_DATA_N2_HALF] = S.full; //то в DATA пишем S.full (Шаг 6)
}
else{ //Иначе Шаг 5
(*DATA).half[_GOST_PART_DATA_N2_HALF] = (*DATA).half[_GOST_PART_DATA_N1_HALF]; //N2 = N1,
(*DATA).half[_GOST_PART_DATA_N1_HALF] = S.full; //N1 = S
}
}
uint32 TRanrotWGenerator::BRandom() {
// generate next random number
uint32 y, z;
// generate next number
z = _lrotl(randbuffer[p1][0], R1) + randbuffer[p2][0];
y = _lrotl(randbuffer[p1][1], R2) + randbuffer[p2][1];
randbuffer[p1][0] = y; randbuffer[p1][1] = z;
// rotate list pointers
if (--p1 < 0) p1 = KK - 1;
if (--p2 < 0) p2 = KK - 1;
// perform self-test
if (randbuffer[p1][0] == randbufcopy[0][0] &&
memcmp(randbuffer, randbufcopy[KK-p1], 2*KK*sizeof(uint32)) == 0) {
// self-test failed
if ((p2 + KK - p1) % KK != JJ) {
// note: the way of printing error messages depends on system
// In Windows you may use FatalAppExit
printf("Random number generator not initialized");}
else {
printf("Random number generator returned to initial state");}
exit(1);}
randbits[0] = y;
randbits[1] = z;
return y;}
DWORD
DWordXorLrl( char *szSym )
/*++
Routine Description:
This function will take an ascii character string and generate
a hash for that string. The hash algorithm is the CV NB08 hash
algorithm.
Arguments:
szSym - a character pointer, the first char is the string length
Return Value:
The generated hash value.
--*/
{
char *pName = szSym+1;
int cb = *szSym;
char *pch;
char c;
DWORD hash = 0;
DWORD UNALIGNED *pul = (DWORD *) pName;
static rgMask[] = {0, 0xff, 0xffff, 0xffffff};
//
// We replace all "::" to "__"
//
c = *(pName+cb);
*(pName+cb) = '\0';
pch = strstr( pName, "::" );
if ( pch ) {
*pch++ = '_';
*pch = '_';
}
*(pName+cb) = c;
pch = pName + cb - 1;
while (isdigit(*pch)) {
pch--;
}
if (*pch == '@') {
cb = pch - pName;
}
for (; cb > 3; cb-=4, pul++) {
hash = _lrotl(hash, 4);
hash ^= (*pul & 0xdfdfdfdf);
}
if (cb > 0) {
hash = _lrotl(hash,4);
hash ^= ((*pul & rgMask[cb]) & 0xdfdfdfdf);
}
return hash;
} /* DWordXorLrl() */
void main()
{
mask = _lrotl( mask, 4 );
printf( "%08lX\n", mask );
}
} mgf_header_t;
typedef struct {
s8 magic[13]; // "MalieScenario"
} mls_header_t;
#pragma pack ()
static int is_libu, is_encryption;
static unsigned int keyTable[CAMELLIA_TABLE_WORD_LEN];
static void rotate16bytes(u32 offset, DWORD *cipher)
{
BYTE shifts = ((offset >> 4) & 0x0f) + 16;
cipher[0] = _lrotl(cipher[0], shifts);
cipher[1] = _lrotr(cipher[1], shifts);
cipher[2] = _lrotl(cipher[2], shifts);
cipher[3] = _lrotr(cipher[3], shifts);
}
static void *memstr(void *_dst, int len, char *src)
{
BYTE *dst = (BYTE *)_dst;
for (int i = 0; i < len; ++i) {
for (int k = 0; src[k]; ++k) {
if (dst[i + k] != src[k])
break;
}
if (!src[k])
break;
