Полезное для программистов:

Фриланс
Новости
Статьи
   
Рубрики:


Aлгоритм MD5 (хэш функция)

Поиск:
Автор: Chingachguk

Код

#ifndef _GLOBAL_H
#define _GLOBAL_H

typedef unsigned char UC;
typedef unsigned short UI;
typedef unsigned long UINT4;
typedef unsigned char *POINTER;

#endif //_GLOBAL_H

// MD5.H - header file for MD5C.C
// Copyright © 1991-2, RSA Data Security, Inc. Created 1991.
// All rights reserved.
// License to copy and use this software is granted provided that it
// is identified as the "RSA Data Security, Inc. MD5 Message-Digest
// Algorithm" in all material mentioning or referencing this software
// or this function.
// License is also granted to make and use derivative works provided
// that such works are identified as "derived from the RSA Data
// Security, Inc. MD5 Message-Digest Algorithm" in all material
// mentioning or referencing the derived work.
// RSA Data Security, Inc. makes no representations concerning either
// the merchantability of this software or the suitability of this
// software for any particular purpose. It is provided "as is"
// without express or implied warranty of any kind.
// These notices must be retained in any copies of any part of this
// documentation and/or software.

// MD5 context.
typedef struct
{
UINT4 state[4];           // state (ABCD)
UINT4 count[2];           // number of bits, modulo 2^64 (lsb first)
UC buffer[64];            // input buffer
} MD5_CTX;

void MDInit   (MD5_CTX *);
void MDUpdate (MD5_CTX *, UC *, UI);
void MDFinal  (UC [16], MD5_CTX *);

// MDFILE.C - Реализация обработки файла по алгоритму шифрования MD5.
// Возвращаемое значение - строка шестнадцатиричных цифр, длиной 32 символа.  

#include <stdio.h>
#include <string.h>

#include "global.h"
#include "md5.h"

// Константы для MD5Transform.
#define S11      7
#define S12     12
#define S13     17
#define S14     22
#define S21      5
#define S22      9
#define S23     14
#define S24     20
#define S31      4
#define S32     11
#define S33     16
#define S34     23
#define S41      6
#define S42     10
#define S43     15
#define S44     21

// Прототипы.
static void MDTransform (UINT4 [4], UC [64]);
static void Encode      (UC *, UINT4 *, UI);
static void Decode      (UINT4 *, UC *, UI);

// -------------------------------------------------------------------------
static UC PADDING[64] = {0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

// F, G, H и I - основные функции алгоритма MD5.
#define F(x, y, z) (((x) & (y)) | ((~x) & ( z)))
#define G(x, y, z) (((x) & (z)) | (( y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

// ROTATE_LEFT - циклический сдвиг x влево на n бит.
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

// FF, GG, HH, и II преобразования для округлений 1, 2, 3, и 4.
// Циклический сдвиг разделен со сложением во избежании перерасчета.
#define FF(a, b, c, d, x, s, ac) {\
(a) += F ((b), ©, (d)) + (x) + (UINT4)(ac);\
(a)  = ROTATE_LEFT ((a), (s));\
(a) += (b);}

#define GG(a, b, c, d, x, s, ac) {\
(a) += G ((b), ©, (d)) + (x) + (UINT4)(ac);\
(a)  = ROTATE_LEFT ((a), (s));\
(a) += (b);}

#define HH(a, b, c, d, x, s, ac) {\
(a) += H ((b), ©, (d)) + (x) + (UINT4)(ac);\
(a)  = ROTATE_LEFT ((a), (s));\
(a) += (b);}

#define II(a, b, c, d, x, s, ac) {\
(a) += I ((b), ©, (d)) + (x) + (UINT4)(ac);\
(a) = ROTATE_LEFT ((a), (s));\
(a) += (b);}

// -------------------------------------------------------------------------
// MD5 инициализация. Начало операции кодирования MD5, запись нового контекста.
void MDInit(MD5_CTX *context)
{
context->count[0] = context->count[1] = 0;
// Загрузка "магических" инициирующих констант .
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}

// -------------------------------------------------------------------------
// MD5 операция модификации блока. Продолжает операцию кодирования MD5,
// обрабатывает блок сообщения и модифицирует контекст.
void MDUpdate(MD5_CTX *context, UC *input, UI inputLen)
{
UI i, index, partLen;

// Подсчитываем число байт по модулю 64.
index = (UI)((context->count[0] >> 3) & 0x3F);

// Модифицируем число бит.
if ((context->count[0] += ((UINT4)inputLen << 3))
     < ((UINT4)inputLen << 3))
   context->count[1]++;
context->count[1] += ((UINT4)inputLen >> 29);

partLen = 64 - index;

// Выполняем преобразование столько раз, сколько возможно.
if (inputLen >= partLen)
 {
   memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
MDTransform (context->state, context->buffer);

   for (i = partLen; i + 63 < inputLen; i += 64)
      MDTransform(context->state, &input[i]);

   index = 0;
 }
else
   i = 0;

// Ввод остатка буфера
memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],inputLen-i);
}

// -------------------------------------------------------------------------
// MD5 завершение. Завершает операцию кодирования MD5, записывает цифровую
// строку сообщения и обнуляет контекст.
void MDFinal(UC digest[16], MD5_CTX *context)
{
UC bits[8];
UI index, padLen;

// Сохраняем число бит
Encode(bits, context->count, 8);

// Подбиваем до 56 по модулю 64
index = (UI)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MDUpdate(context, PADDING, padLen);

// Добавляем длину (перед подбивкой)
MDUpdate(context, bits, 8);

// Сохраняем состояние в цифровой строке
Encode(digest, context->state, 16);

// Обнуляем чувствительную информацию
memset((POINTER)context, 0, sizeof (*context));
}

// -------------------------------------------------------------------------
static void MDTransformF (UINT4 s[4], UINT4 x[16])
{
FF(s[0], s[1], s[2], s[3], x[ 0], S11, 0xd76aa478);     //  1
FF(s[3], s[0], s[1], s[2], x[ 1], S12, 0xe8c7b756);     //  2
FF(s[2], s[3], s[0], s[1], x[ 2], S13, 0x242070db);     //  3
FF(s[1], s[2], s[3], s[0], x[ 3], S14, 0xc1bdceee);     //  4
FF(s[0], s[1], s[2], s[3], x[ 4], S11, 0xf57c0faf);     //  5
FF(s[3], s[0], s[1], s[2], x[ 5], S12, 0x4787c62a);     //  6
FF(s[2], s[3], s[0], s[1], x[ 6], S13, 0xa8304613);     //  7
FF(s[1], s[2], s[3], s[0], x[ 7], S14, 0xfd469501);     //  8
FF(s[0], s[1], s[2], s[3], x[ 8], S11, 0x698098d8);     //  9
FF(s[3], s[0], s[1], s[2], x[ 9], S12, 0x8b44f7af);     // 10
FF(s[2], s[3], s[0], s[1], x[10], S13, 0xffff5bb1);     // 11
FF(s[1], s[2], s[3], s[0], x[11], S14, 0x895cd7be);     // 12
FF(s[0], s[1], s[2], s[3], x[12], S11, 0x6b901122);     // 13
FF(s[3], s[0], s[1], s[2], x[13], S12, 0xfd987193);     // 14
FF(s[2], s[3], s[0], s[1], x[14], S13, 0xa679438e);     // 15
FF(s[1], s[2], s[3], s[0], x[15], S14, 0x49b40821);     // 16
}

// -------------------------------------------------------------------------
static void MDTransformG (UINT4 s[4], UINT4 x[16])
{
GG(s[0], s[1], s[2], s[3], x[ 1], S21, 0xf61e2562);     // 17
GG(s[3], s[0], s[1], s[2], x[ 6], S22, 0xc040b340);     // 18
GG(s[2], s[3], s[0], s[1], x[11], S23, 0x265e5a51);     // 19
GG(s[1], s[2], s[3], s[0], x[ 0], S24, 0xe9b6c7aa);     // 20
GG(s[0], s[1], s[2], s[3], x[ 5], S21, 0xd62f105d);     // 21
GG(s[3], s[0], s[1], s[2], x[10], S22, 0x02441453);     // 22
GG(s[2], s[3], s[0], s[1], x[15], S23, 0xd8a1e681);     // 23
GG(s[1], s[2], s[3], s[0], x[ 4], S24, 0xe7d3fbc8);     // 24
GG(s[0], s[1], s[2], s[3], x[ 9], S21, 0x21e1cde6);     // 25
GG(s[3], s[0], s[1], s[2], x[14], S22, 0xc33707d6);     // 26
GG(s[2], s[3], s[0], s[1], x[ 3], S23, 0xf4d50d87);     // 27
GG(s[1], s[2], s[3], s[0], x[ 8], S24, 0x455a14ed);     // 28
GG(s[0], s[1], s[2], s[3], x[13], S21, 0xa9e3e905);     // 29
GG(s[3], s[0], s[1], s[2], x[ 2], S22, 0xfcefa3f8);     // 30
GG(s[2], s[3], s[0], s[1], x[ 7], S23, 0x676f02d9);     // 31
GG(s[1], s[2], s[3], s[0], x[12], S24, 0x8d2a4c8a);     // 32
}

// -------------------------------------------------------------------------
static void MDTransformH (UINT4 s[4], UINT4 x[16])
{
HH(s[0], s[1], s[2], s[3], x[ 5], S31, 0xfffa3942);     // 33
HH(s[3], s[0], s[1], s[2], x[ 8], S32, 0x8771f681);     // 34
HH(s[2], s[3], s[0], s[1], x[11], S33, 0x6d9d6122);     // 35
HH(s[1], s[2], s[3], s[0], x[14], S34, 0xfde5380c);     // 36
HH(s[0], s[1], s[2], s[3], x[ 1], S31, 0xa4beea44);     // 37
HH(s[3], s[0], s[1], s[2], x[ 4], S32, 0x4bdecfa9);     // 38
HH(s[2], s[3], s[0], s[1], x[ 7], S33, 0xf6bb4b60);     // 39
HH(s[1], s[2], s[3], s[0], x[10], S34, 0xbebfbc70);     // 40
HH(s[0], s[1], s[2], s[3], x[13], S31, 0x289b7ec6);     // 41
HH(s[3], s[0], s[1], s[2], x[ 0], S32, 0xeaa127fa);     // 42
HH(s[2], s[3], s[0], s[1], x[ 3], S33, 0xd4ef3085);     // 43
HH(s[1], s[2], s[3], s[0], x[ 6], S34, 0x04881d05);     // 44
HH(s[0], s[1], s[2], s[3], x[ 9], S31, 0xd9d4d039);     // 45
HH(s[3], s[0], s[1], s[2], x[12], S32, 0xe6db99e5);     // 46
HH(s[2], s[3], s[0], s[1], x[15], S33, 0x1fa27cf8);     // 47
HH(s[1], s[2], s[3], s[0], x[ 2], S34, 0xc4ac5665);     // 48
}

// -------------------------------------------------------------------------
static void MDTransformI (UINT4 s[4], UINT4 x[16])
{
II(s[0], s[1], s[2], s[3], x[ 0], S41, 0xf4292244);     // 49
II(s[3], s[0], s[1], s[2], x[ 7], S42, 0x432aff97);     // 50
II(s[2], s[3], s[0], s[1], x[14], S43, 0xab9423a7);     // 51
II(s[1], s[2], s[3], s[0], x[ 5], S44, 0xfc93a039);     // 52
II(s[0], s[1], s[2], s[3], x[12], S41, 0x655b59c3);     // 53
II(s[3], s[0], s[1], s[2], x[ 3], S42, 0x8f0ccc92);     // 54
II(s[2], s[3], s[0], s[1], x[10], S43, 0xffeff47d);     // 55
II(s[1], s[2], s[3], s[0], x[ 1], S44, 0x85845dd1);     // 56
II(s[0], s[1], s[2], s[3], x[ 8], S41, 0x6fa87e4f);     // 57
II(s[3], s[0], s[1], s[2], x[15], S42, 0xfe2ce6e0);     // 58
II(s[2], s[3], s[0], s[1], x[ 6], S43, 0xa3014314);     // 59
II(s[1], s[2], s[3], s[0], x[13], S44, 0x4e0811a1);     // 60
II(s[0], s[1], s[2], s[3], x[ 4], S41, 0xf7537e82);     // 61
II(s[3], s[0], s[1], s[2], x[11], S42, 0xbd3af235);     // 62
II(s[2], s[3], s[0], s[1], x[ 2], S43, 0x2ad7d2bb);     // 63
II(s[1], s[2], s[3], s[0], x[ 9], S44, 0xeb86d391);     // 64
}

// -------------------------------------------------------------------------
// MD5 основное преобразование. Преобразования структуры на базе блока.
static void MDTransform(UINT4 state[4], UC block[64])
{
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

Decode(x, block, 64);

MDTransformF (state, x);
MDTransformG (state, x);
MDTransformH (state, x);
MDTransformI (state, x);

state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;

// Обнуляем чувствительную информацию
memset((POINTER)x, 0, sizeof (x));
}

// -------------------------------------------------------------------------
// Кодируем вход (UINT4) в выход (UC). Добавляем длину, умноженную на 4.
static void Encode(UC *output, UINT4 *input, UI len)
{
UI i, j;

for (i = 0, j = 0; j < len; i++, j += 4)
 {
  output[ j ] = (UC)(input[i]         & 0xff);
  output[j+1] = (UC)((input[i] >>  8) & 0xff);
  output[j+2] = (UC)((input[i] >> 16) & 0xff);
  output[j+3] = (UC)((input[i] >> 24) & 0xff);
 }
}

// -------------------------------------------------------------------------
// Декодируем вход (UC), выход (UINT4). Добавляем длину, умноженную на 4.
static void Decode(UINT4 *output, UC *input, UI len)
{
UI i, j;

for (i = 0, j = 0; j < len; i++, j += 4)
  output[i] = ((UINT4)input[ j ])        |
             (((UINT4)input[j+1]) <<  8) |
             (((UINT4)input[j+2]) << 16) |
             (((UINT4)input[j+3]) << 24);
}

// -------------------------------------------------------------------------
// Формирование цифровой строки по файлу.
unsigned int MDFile(char *filename, char *res)
{
FILE   *file;
MD5_CTX context;
int     len;
UC      buffer[1024], digest[16];

if ((file = fopen(filename, "rb")) == NULL)
   return(0);                      // Ошибка открытия файла
else
{
   MDInit(&context);
   while ( (len= fread (buffer, 1, 1024, file)) )
      MDUpdate(&context, buffer, len);
   MDFinal(digest, &context);

   // Формируем возвращаемую строку
   for (len = 0; len < 16; len++)  
       sprintf(&res[len*2],"%02x",digest[len]);
   res[32] = '\0';
 }

fclose(file);
return(1);                         // Все в порядке
}

void main(int argc, char *argv[])
{
char MD5[200];

if ( argc == 1 )
{
printf("\n Error, no input file!!!");
return;
}
MDFile(argv[1], MD5);
printf("\nMD5 sign for file %s: %s", argv[1], MD5);
}

...
Ниже мой код получения MD5. Он оптимизирован по скорости (примерно ~1-20мкс/на 16 байт или меньше) на p120. Состоит из трех процедур:

- MD5Init (P309AD4D2)
- MD5Update (P309AD4FC)
- MD5Final (P309AD5A9)

Входными данными является некая последовательность байт, пусть это будет StringForHash длиной sizeof StringForHash или какой-то еще.

Сначала ты должен инициализировать следующую струкутру:

Код

MD5_CTX db 68h dup(?)


процедурой MD5Init - всего лишь заполнение части ее (24 байта) "магическими"
числами:

Код

; Инициализировать контекст MD5  
mov  ecx,offset MD5_CTX
call P309AD4D2; MD5Init


Потом ты должен передавать второй процедуре блоки данных (байты входной строки):

Код

; Добавить информацию к контексту
push dword ptr [ebp+10h]; Длина буфера
mov  ecx,offset MD5_CTX; контекст MD5
mov  edx,[ebp+0Ch]; адрес буфера
call P309AD4FC; MD5Update


Добаялять ты можешь сразу все байты строки (как у меня) или побайтно (это связано с тем, сколько байт исходной строки ты можешь держать в памяти одновременно). Добавив все байты, ты формируешь сам MD5-хэш:
Код


; Получить хэш по контексту
mov  ecx,offset MD5_CTX; контекст MD5
call P309AD5A9     ; MD5Final

передавая лишь адрес структуры - контекста. После этого хэшем являются 16 байт в структуре:

mov  esi,offset MD5_CTX+58h; String with hash
mov  ecx,MD5HashSize

По смещению +58h от ее начала (или последние 16 байт). Например, вот что получится в следующем примере:

MD5("Test String") = bd08ba3c982eaad768602536fb8e1184.

EntryStrSize equ 512
MD5HashSize equ 16
...
StringForHash db EntryStrSize dup(?)
MD5Hash  db MD5HashSize dup(?)
.code
...
@@EntryStrDone:
; Формируем MD5-хэш !
push sizeof StringForHash; Длина строки для MD5 - можешь написать 10 - 10 байт и т.д.
push offset StringForHash; Адрес строки для MD5
push offset MD5Hash; Куда будет помещен хэш
call Get_MD5Hash
...

; Процедура получения MD5 хэша (16 байт)
; [ebp+8] - адрес приемника (16 байт)
; [ebp+0Ch] - адрес строки, от которой будет получен хэш
; [ebp+10h] - длина строки
Get_MD5Hash proc
.data
; Буфер для MD5
StrangeBuffer db 80h, 15 dup(0)
           db 16 dup(0)
           db 16 dup(0)
           db 16 dup(0)
.data?
MD5_CTX db 68h dup(?)
.code
push ebp
mov  ebp,esp
; Инициализировать контекст MD5  
mov  ecx,offset MD5_CTX
call P309AD4D2; MD5Init
; Добавить информацию к контексту
cmp  dword ptr [ebp+10h],0; Длина буфера
jz   @@EmptyMD5Str
push dword ptr [ebp+10h]; Длина буфера
mov  ecx,offset MD5_CTX; контекст MD5
mov  edx,[ebp+0Ch]; адрес буфера
call P309AD4FC; MD5Update
@@EmptyMD5Str:
; Получить хэш по контексту
mov  ecx,offset MD5_CTX; контекст MD5
call P309AD5A9     ; MD5Final
; Передать хеш из 16 байт обратно
mov  edi,[ebp+8]; Result string
mov  esi,offset MD5_CTX+58h; String with hash
mov  ecx,MD5HashSize
rep  movsb
pop  ebp
ret  3*4
Get_MD5Hash endp
;***************************************************************************************
; Подпрограмма MD5Init( MD5_CTX - контекст MD5 ) - инициализация контекста MD5
P309AD4D2 proc; Инициализация 24 байт ? по ECX. ECX=0062B9DC...
mov dword ptr [ecx],00000000h; count[1]:=0;
mov dword ptr [ecx+04h],00000000h; count[2]:=0;
mov dword ptr [ecx+08h],67452301h; state[1]:=MagValue1
mov dword ptr [ecx+0Ch],0EFCDAB89h; state[2]:=MagValue2
mov dword ptr [ecx+10h],98BADCFEh; state[3]:=MagValue3
mov dword ptr [ecx+14h],10325476h; state[4]:=MagValue4
ret
P309AD4D2 endp
; Конец подпрограммы 309AD4D2
;***************************************************************************************
; Подпрограмма MD5Update( MD5_CTX - контекст MD5, буфер, длина буфера )
; MD5_CTX - контекст MD5 - в ECX (его адрес)
; буфер - в EDX (его адрес)
; длина буфера - в стеке (первое слово за адресом возврата)
P309AD4FC proc; Что-то делаем с 24 байтами по ECX
push ebp
mov  ebp,esp
push edi
mov  esi,ecx     ; Адрес переданного по ECX контекста
mov  ebp,[ebp+8h]; Длина буффера, переданного нам > EBP
mov  eax,ebp
mov  ebx,edx     ; адрес буффера -> EBX
mov  edx,[esi]     ; 4 байта из переданного в ECX контекста
mov  ecx,edx     ; Положить их в ecx
lea  eax,[edx+eax*8] ; Длина массива * 8 + dd из контекста
and  ecx,01F8h     ; Первые 4 байта из контекста and 01F8h
shr  ecx,3; разделить их на 8
cmp  eax,edx     ; Сравнить: (Длина массива * 8 + dd из контекста) и (dd из контекста)
jae  L309AD522     ; Вышли за пределы ?
inc  dword ptr [esi+04]; Увеличить следующий dd из контекста
L309AD522:
mov  [esi],eax     ; в контекст положить вычисленный eax
mov  eax,ebp    ; Длина буффера, переданного нам > EAX
shr  eax,1Dh     ; Оставить 31,30 и 29 биты ? - 00,00,..
add  [esi+04],eax; Добавить к следующему dd контекста
dec  ebp             ; Уменьшить длину буффера, переданного нам
js   L309AD59F     ; Равна 0 ? -> На выход
L309AD53A:
mov  al,[ebx]     ; Взять байт переданного буффера
inc  ebx             ; Указать на следующий байт
mov  [ecx+esi+18h],al; Положить его в [4 байта из переданного в ((ECX and 01F8h) shr 3 +
; + адрес переданного массива в 24 байта + следующие в нем 24 байта)
inc  ecx     ; Прирастить разделенный на 8 первый элемент массива
cmp  ecx,40h     ; Он вдруг стал 64 ?
jnz  L309AD593     ; Да, да ...
lea  edx,[esi+18h]
lea  ecx,[esi+08h]
call P309AD671     ; МАКРОСЫ
xor  ecx,ecx
L309AD593:
dec  ebp             ; Длина буффера, переданного нам
jns  L309AD53A
L309AD59F:
pop  edi
pop  ebp
ret  4
P309AD4FC endp
; Конец подпрограммы 309AD4FC
;***************************************************************************************
; Подпрограмма 309AD5A9
; Пока кандидат на MD5Final (MD5_CTX - контекст, digest - наполняемый буфер 10h)
; ECX - адрес контекста MD5 ?
P309AD5A9 proc; ECX=адрес контекста
push edi
mov  eax,[ecx+4]; Взять второе слово контекста
mov  esi,ecx     ; Адрес контекста
mov  [esi+18h+3Ch],eax; <- второе слово контекста
mov  ecx,[esi]     ; Первое слово контекста
mov  [esi+18h+38h],ecx; <- Первое слово контекста
and  ecx,1F8h     ; с 1-м словом
shr  ecx,3; /8
mov  eax,38h
cmp  ecx,eax
jl   L309AD5D5
mov  eax,78h
L309AD5D5:
sub  eax,ecx
mov  edx,offset StrangeBuffer
push eax
mov  ecx,esi     ; Адрес буфера
call P309AD4FC     ; MD5Update
lea  edx,[esi+18h]
add  esi,8h
mov  ecx,esi
call P309AD671     ; Макроподстановки MD5
lea  edi,[esi+50h]
movsd
movsd
movsd
movsd
pop  edi
ret
P309AD5A9 endp
;***
; Подпрограмма 309AD671 - Макроподстановки MD5
; edx - адрес массива x[16] из long-ов
; ecx - адрес массива s[4] из long-ов ?!
;// Константы для MD5Transform.
S11 equ 7
S12 equ 12
S13 equ 17
S14 equ 22
S21 equ 5
S22 equ 9
S23 equ 14
S24 equ 20
S31 equ 4
S32 equ 11
S33 equ 16
S34 equ 23
S41 equ 6
S42 equ 10
S43 equ 15
S44 equ 21
s0 equ eax ; Элемент s[0]
s1 equ ebx ; Элемент s[1]
s2 equ esi ; Элемент s[2]
s3 equ ebp ; Элемент s[3]
x0 equ dword ptr [edi]   ; Элемент x[0]
x1 equ dword ptr [edi+4] ; Элемент x[1]
x2 equ dword ptr [edi+8] ; Элемент x[2]
x3 equ dword ptr [edi+0Ch]; Элемент x[3]
x4 equ dword ptr [edi+10h]; Элемент x[4]
x5 equ dword ptr [edi+14h]; Элемент x[5]
x6 equ dword ptr [edi+18h]; Элемент x[6]
x7 equ dword ptr [edi+1Ch]; Элемент x[7]
x8 equ dword ptr [edi+20h]; Элемент x[8]
x9 equ dword ptr [edi+24h]; Элемент x[9]
x10 equ dword ptr [edi+28h]; Элемент x[10]
x11 equ dword ptr [edi+2Ch]; Элемент x[11]
x12 equ dword ptr [edi+30h]; Элемент x[12]
x13 equ dword ptr [edi+34h]; Элемент x[13]
x14 equ dword ptr [edi+38h]; Элемент x[14]
x15 equ dword ptr [edi+3Ch]; Элемент x[15]
PFF macro  _a,_b,_c,_d,_x,_s,_ac
lea  ecx,[_a+_ac]
mov  _a,_b
and  _a,_c
add  ecx,_x
mov  edx,_b
not  edx
and  edx,_d
or   _a,edx
add  _a,ecx
rol  _a,_s
add  _a,_b
endm
PGG macro  _a,_b,_c,_d,_x,_s,_ac
mov  ecx,_c
mov  edx,_d
not  edx
and  ecx,edx
mov  edx,_b
and  edx,_d
or   edx,ecx
lea  _a,[_a+edx+_ac]
add  _a,_x
rol  _a,_s
add  _a,_b
endm
PHH macro  _a,_b,_c,_d,_x,_s,_ac
mov  ecx,_b
xor  ecx,_c
xor  ecx,_d  
lea  _a,[_a+ecx+_ac]
add  _a,_x
rol  _a,_s
add  _a,_b
endm
PII macro  _a,_b,_c,_d,_x,_s,_ac
mov  ecx,_b
mov  edx,_d
not  edx
or   ecx,edx
mov  edx,_c
xor  edx,ecx
lea  _a,[_a+edx+_ac]
add  _a,_x
rol  _a,_s
add  _a,_b
endm
P309AD671 proc
 pushad
 mov  edi,edx
 mov  s0,[ecx]      ; s[0]
 mov  s1,[ecx+4]    ; s[1]
 mov  s2,[ecx+8]    ; s[2]
 mov  s3,[ecx+0Ch]  ; s[3]
 push ecx
;static void MDTransformF (UINT4 s[4, UINT4 x16])
 PFF s0,s1,s2,s3,x0,S11,0d76aa478h; //  1
 PFF s3,s0,s1,s2,x1,S12,0e8c7b756h; //  2
 PFF s2,s3,s0,s1,x2,S13,0242070dbh; //  3
 PFF s1,s2,s3,s0,x3,S14,0c1bdceeeh; //  4
 PFF s0,s1,s2,s3,x4,S11,0f57c0fafh; //  5
 PFF s3,s0,s1,s2,x5,S12,04787c62ah; //  6
 PFF s2,s3,s0,s1,x6,S13,0a8304613h; //  7
 PFF s1,s2,s3,s0,x7,S14,0fd469501h; //  8
 PFF s0,s1,s2,s3,x8,S11,0698098d8h; //  9
 PFF s3,s0,s1,s2,x9,S12,08b44f7afh; // 10
 PFF s2,s3,s0,s1,x10,S13,0ffff5bb1h; // 11
 PFF s1,s2,s3,s0,x11,S14,0895cd7beh; // 12
 PFF s0,s1,s2,s3,x12,S11,06b901122h; // 13
 PFF s3,s0,s1,s2,x13,S12,0fd987193h; // 14
 PFF s2,s3,s0,s1,x14,S13,0a679438eh; // 15
 PFF s1,s2,s3,s0,x15,S14,049b40821h; // 16
; static void MDTransformG (UINT4 s[4, UINT4 x16])
 PGG s0,s1,s2,s3,x1,S21, 0f61e2562h; // 17
 PGG s3,s0,s1,s2,x6,S22, 0c040b340h; // 18
 PGG s2,s3,s0,s1,x11,S23,0265e5a51h; // 19
 PGG s1,s2,s3,s0,x0,S24, 0e9b6c7aah; // 20
 PGG s0,s1,s2,s3,x5,S21, 0d62f105dh; // 21
 PGG s3,s0,s1,s2,x10,S22,002441453h; // 22
 PGG s2,s3,s0,s1,x15,S23,0d8a1e681h; // 23
 PGG s1,s2,s3,s0,x4,S24, 0e7d3fbc8h; // 24
 PGG s0,s1,s2,s3,x9,S21, 021e1cde6h; // 25
 PGG s3,s0,s1,s2,x14,S22,0c33707d6h; // 26
 PGG s2,s3,s0,s1,x3,S23, 0f4d50d87h; // 27
 PGG s1,s2,s3,s0,x8,S24, 0455a14edh; // 28
 PGG s0,s1,s2,s3,x13,S21,0a9e3e905h; // 29
 PGG s3,s0,s1,s2,x2,S22, 0fcefa3f8h; // 30
 PGG s2,s3,s0,s1,x7,S23, 0676f02d9h; // 31
 PGG s1,s2,s3,s0,x12,S24,08d2a4c8ah; // 32
; static void MDTransformH (UINT4 s[4, UINT4 x16])
 PHH s0,s1,s2,s3,x5,S31, 0fffa3942h; // 33
 PHH s3,s0,s1,s2,x8,S32, 08771f681h; // 34
 PHH s2,s3,s0,s1,x11,S33,06d9d6122h; // 35
 PHH s1,s2,s3,s0,x14,S34,0fde5380ch; // 36
 PHH s0,s1,s2,s3,x1,S31, 0a4beea44h; // 37
 PHH s3,s0,s1,s2,x4,S32, 04bdecfa9h; // 38
 PHH s2,s3,s0,s1,x7,S33, 0f6bb4b60h; // 39
 PHH s1,s2,s3,s0,x10,S34,0bebfbc70h; // 40
 PHH s0,s1,s2,s3,x13,S31,0289b7ec6h; // 41
 PHH s3,s0,s1,s2,x0,S32, 0eaa127fah; // 42
 PHH s2,s3,s0,s1,x3,S33, 0d4ef3085h; // 43
 PHH s1,s2,s3,s0,x6,S34, 004881d05h; // 44
 PHH s0,s1,s2,s3,x9,S31, 0d9d4d039h; // 45
 PHH s3,s0,s1,s2,x12,S32,0e6db99e5h; // 46
 PHH s2,s3,s0,s1,x15,S33,01fa27cf8h; // 47
 PHH s1,s2,s3,s0,x2,S34, 0c4ac5665h; // 48
; static void MDTransformI (UINT4 s[4, UINT4 x16])
 PII s0,s1,s2,s3,x0,S41, 0f4292244h; // 49
 PII s3,s0,s1,s2,x7,S42, 0432aff97h; // 50
 PII s2,s3,s0,s1,x14,S43,0ab9423a7h; // 51
 PII s1,s2,s3,s0,x5,S44, 0fc93a039h; // 52
 PII s0,s1,s2,s3,x12,S41,0655b59c3h; // 53
 PII s3,s0,s1,s2,x3,S42, 08f0ccc92h; // 54
 PII s2,s3,s0,s1,x10,S43,0ffeff47dh; // 55
 PII s1,s2,s3,s0,x1,S44, 085845dd1h; // 56
 PII s0,s1,s2,s3,x8,S41, 06fa87e4fh; // 57
 PII s3,s0,s1,s2,x15,S42,0fe2ce6e0h; // 58
 PII s2,s3,s0,s1,x6,S43, 0a3014314h; // 59
 PII s1,s2,s3,s0,x13,S44,04e0811a1h; // 60
 PII s0,s1,s2,s3,x4,S41, 0f7537e82h; // 61
 PII s3,s0,s1,s2,x11,S42,0bd3af235h; // 62
 PII s2,s3,s0,s1,x2,S43, 02ad7d2bbh; // 63
 PII s1,s2,s3,s0,x9,S44, 0eb86d391h; // 64
; Добавить результат к первичным значениям !!!
 pop ecx
 add [ecx],s0      ; s[0]
 add [ecx+4],s1    ; s[1]
 add [ecx+8],s2    ; s[2]
 add [ecx+0Ch],s3  ; s[3]
 popad
 ret
P309AD671 endp
Автор: Chingachguk






Просмотров: 4775

 

 

Новые статьи:


Популярные:
  1. Как сделать цикличным проигрывание MIDI-файла?
  2. Создание AVI файла из рисунков
  3. Как устройство "отключить в данной конфигурации"?
  4. Kто в данный момент присоединен через Сеть?
  5. Как узнать количество доступной памяти?
  6. Как реализовать в RichEdit разноцветный текст?
  7. Как скрыть свое приложение от ProcessViewer
  8. Как программно нажать/скрыть/показ кнопку "Start"?
  9. Модуль работы с ресурсами в PE файлах
10. Функции вызова диалоговых окон выбора
11. Проверка граматики средствами Word'а из Delphi.
12. Модуль для упрощенного вызова сообщений
13. Функции для записи и чтение своих данных в, ЕХЕ- файле
14. Рекурсивный просмотр директорий
15. Network Traffic Monitor
16. Разные модули
17. Универсальная функция для обращения к любым экспортируем функциям DLL
18. Библиотека от VladS
19. Протектор для UPX'а
20. Еще об ICQ, сообщения по контакт листу?
21. Использование открытых интерфейсов
22. Теория и практика использования RTTI
23. Работа с TApplication
24. Примеры использования Drag and Drop для различных визуальных компонентов
25. Что такое порт? Правила для работы с портами
26. Симфония на клавиатуре
27. Загрузка DLL
28. Исправление автоинкремента
29. Взаимодействие с чужими окнами
30. Проверить дубляжи в столбце


 

 

 
 
На главную