Blog. Just Blog

Расчет хеша MD4 на Ассемблере

Версия для печати Добавить в Избранное Отправить на E-Mail | Категория: Образ мышления: Assembler | Автор: ManHunter
MD4 (Message Digest 4) - хеш-функция, разработанная профессором Рональдом Ривестом в 1990 году. Для произвольных входных данных функция MD4 генерирует 128-разрядный хеш. Функция MD4 является предшественником MD5 и до настоящего времени применяется в некоторых сетевых технологиях Windows. В реализации обоих алгоритмов очень много общего, поэтому точно так же в сегменте данных надо подготовить следующие массивы и переменные:
  1. ; Сегмент данных
  2. section '.data' data readable writeable  
  3. ...
  4. ; Шаблоны функции wsprintf для перевода хеша в строковый вид,
  5. ; при необходимости можно оставить только какой-нибудь один
  6. szMD4Format1 db '%.8X%.8X%.8X%.8X',0  ; Для получения заглавных букв
  7. szMD4Format2 db '%.8x%.8x%.8x%.8x',0  ; Для маленьких букв в строке хеша
  8.  
  9. stMD4Result:
  10.   stdtA      dd ?   ; Переменные для получения и хранения
  11.   stdtB      dd ?   ; результата хеширования
  12.   stdtC      dd ?
  13.   stdtD      dd ?
  14.  
  15. stMD4Hash    rb 33  ; Буфер для строки хеша в формате ASCIIZ 
Основная и вспомогательные функции более простые и компактные, к тому же вспомогательных функций всего три, по количеству используемых раундов хеширования.
  1. ;-------------------------------------------------------
  2. ; Процедура расчета хеша MD4
  3. ; На входе:
  4. ; dta, dtb, dtc, dtd - начальные значения MD4, по умолчанию = 0
  5. ; ptBuffer - указатель на буфер от которого считается хеш
  6. ; dtBufferLength - длина буфера в байтах
  7. ; На выходе:
  8. ; Заполненные переменные stdtA, stdtB, stdtC, stdtD
  9. ;-------------------------------------------------------
  10. proc    procMD4hash dta, dtb, dtc, dtd, ptBuffer, dtBufferLength
  11.         push eax ebx ecx edx edi esi
  12.  
  13.         ; phase 1 - padding
  14.         mov     edi,[ptBuffer]
  15.         mov     eax,[dtBufferLength]
  16.  
  17.         inc     eax
  18.         add     edi,eax
  19.         mov     byte [edi-1],080h
  20.  
  21.         xor     edx,edx
  22.  
  23.         mov     ebx,64
  24.         div     ebx
  25.  
  26.         neg     edx
  27.         add     edx,64
  28.  
  29.         cmp     edx,8
  30.         jae     @f
  31.  
  32.         add     edx,64
  33.  
  34. @@:
  35.         mov     ecx,edx
  36.         xor     al,al
  37.         rep     stosb
  38.  
  39.         mov     eax,[dtBufferLength]
  40.  
  41.         inc     edx
  42.         add     [dtBufferLength],edx
  43.  
  44.         xor     edx,edx
  45.  
  46.         mov     ebx,8
  47.         mul     ebx
  48.  
  49.         mov     dword [edi-8],eax
  50.         mov     dword [edi-4],edx
  51.  
  52.         mov     edx,[dtBufferLength]
  53.  
  54.         mov     edi,[ptBuffer]
  55.  
  56.         ; phase II - chaining variables initialization
  57.  
  58.         mov     [stdtA],067452301h
  59.         mov     [stdtB],0efcdab89h
  60.         mov     [stdtC],098badcfeh
  61.         mov     [stdtD],010325476h
  62.  
  63.         ; phase III - hashing
  64. hashloop:
  65.         mov     eax,[stdtA]
  66.         mov     [dta],eax
  67.         mov     eax,[stdtB]
  68.         mov     [dtb],eax
  69.         mov     eax,[stdtC]
  70.         mov     [dtc],eax
  71.         mov     eax,[stdtD]
  72.         mov     [dtd],eax
  73.  
  74.         ; round 1
  75.         stdcall FF,[dta],[dtb],[dtc],[dtd],dword [edi+00*4],03
  76.         mov     [dta],eax
  77.         stdcall FF,[dtd],[dta],[dtb],[dtc],dword [edi+01*4],07
  78.         mov     [dtd],eax
  79.         stdcall FF,[dtc],[dtd],[dta],[dtb],dword [edi+02*4],11
  80.         mov     [dtc],eax
  81.         stdcall FF,[dtb],[dtc],[dtd],[dta],dword [edi+03*4],19
  82.         mov     [dtb],eax
  83.         stdcall FF,[dta],[dtb],[dtc],[dtd],dword [edi+04*4],03
  84.         mov     [dta],eax
  85.         stdcall FF,[dtd],[dta],[dtb],[dtc],dword [edi+05*4],07
  86.         mov     [dtd],eax
  87.         stdcall FF,[dtc],[dtd],[dta],[dtb],dword [edi+06*4],11
  88.         mov     [dtc],eax
  89.         stdcall FF,[dtb],[dtc],[dtd],[dta],dword [edi+07*4],19
  90.         mov     [dtb],eax
  91.         stdcall FF,[dta],[dtb],[dtc],[dtd],dword [edi+08*4],03
  92.         mov     [dta],eax
  93.         stdcall FF,[dtd],[dta],[dtb],[dtc],dword [edi+09*4],07
  94.         mov     [dtd],eax
  95.         stdcall FF,[dtc],[dtd],[dta],[dtb],dword [edi+10*4],11
  96.         mov     [dtc],eax
  97.         stdcall FF,[dtb],[dtc],[dtd],[dta],dword [edi+11*4],19
  98.         mov     [dtb],eax
  99.         stdcall FF,[dta],[dtb],[dtc],[dtd],dword [edi+12*4],03
  100.         mov     [dta],eax
  101.         stdcall FF,[dtd],[dta],[dtb],[dtc],dword [edi+13*4],07
  102.         mov     [dtd],eax
  103.         stdcall FF,[dtc],[dtd],[dta],[dtb],dword [edi+14*4],11
  104.         mov     [dtc],eax
  105.         stdcall FF,[dtb],[dtc],[dtd],[dta],dword [edi+15*4],19
  106.         mov     [dtb],eax
  107.  
  108.         ; round 2
  109.         stdcall GG,[dta],[dtb],[dtc],[dtd],dword [edi+00*4],03
  110.         mov     [dta],eax
  111.         stdcall GG,[dtd],[dta],[dtb],[dtc],dword [edi+04*4],05
  112.         mov     [dtd],eax
  113.         stdcall GG,[dtc],[dtd],[dta],[dtb],dword [edi+08*4],09
  114.         mov     [dtc],eax
  115.         stdcall GG,[dtb],[dtc],[dtd],[dta],dword [edi+12*4],13
  116.         mov     [dtb],eax
  117.         stdcall GG,[dta],[dtb],[dtc],[dtd],dword [edi+01*4],03
  118.         mov     [dta],eax
  119.         stdcall GG,[dtd],[dta],[dtb],[dtc],dword [edi+05*4],05
  120.         mov     [dtd],eax
  121.         stdcall GG,[dtc],[dtd],[dta],[dtb],dword [edi+09*4],09
  122.         mov     [dtc],eax
  123.         stdcall GG,[dtb],[dtc],[dtd],[dta],dword [edi+13*4],13
  124.         mov     [dtb],eax
  125.         stdcall GG,[dta],[dtb],[dtc],[dtd],dword [edi+02*4],03
  126.         mov     [dta],eax
  127.         stdcall GG,[dtd],[dta],[dtb],[dtc],dword [edi+06*4],05
  128.         mov     [dtd],eax
  129.         stdcall GG,[dtc],[dtd],[dta],[dtb],dword [edi+10*4],09
  130.         mov     [dtc],eax
  131.         stdcall GG,[dtb],[dtc],[dtd],[dta],dword [edi+14*4],13
  132.         mov     [dtb],eax
  133.         stdcall GG,[dta],[dtb],[dtc],[dtd],dword [edi+03*4],03
  134.         mov     [dta],eax
  135.         stdcall GG,[dtd],[dta],[dtb],[dtc],dword [edi+07*4],05
  136.         mov     [dtd],eax
  137.         stdcall GG,[dtc],[dtd],[dta],[dtb],dword [edi+11*4],09
  138.         mov     [dtc],eax
  139.         stdcall GG,[dtb],[dtc],[dtd],[dta],dword [edi+15*4],13
  140.         mov     [dtb],eax
  141.  
  142.         ; round 3
  143.         stdcall HH,[dta],[dtb],[dtc],[dtd],dword [edi+00*4],03
  144.         mov     [dta],eax
  145.         stdcall HH,[dtd],[dta],[dtb],[dtc],dword [edi+08*4],09
  146.         mov     [dtd],eax
  147.         stdcall HH,[dtc],[dtd],[dta],[dtb],dword [edi+04*4],11
  148.         mov     [dtc],eax
  149.         stdcall HH,[dtb],[dtc],[dtd],[dta],dword [edi+12*4],15
  150.         mov     [dtb],eax
  151.         stdcall HH,[dta],[dtb],[dtc],[dtd],dword [edi+02*4],03
  152.         mov     [dta],eax
  153.         stdcall HH,[dtd],[dta],[dtb],[dtc],dword [edi+10*4],09
  154.         mov     [dtd],eax
  155.         stdcall HH,[dtc],[dtd],[dta],[dtb],dword [edi+06*4],11
  156.         mov     [dtc],eax
  157.         stdcall HH,[dtb],[dtc],[dtd],[dta],dword [edi+14*4],15
  158.         mov     [dtb],eax
  159.         stdcall HH,[dta],[dtb],[dtc],[dtd],dword [edi+01*4],03
  160.         mov     [dta],eax
  161.         stdcall HH,[dtd],[dta],[dtb],[dtc],dword [edi+09*4],09
  162.         mov     [dtd],eax
  163.         stdcall HH,[dtc],[dtd],[dta],[dtb],dword [edi+05*4],11
  164.         mov     [dtc],eax
  165.         stdcall HH,[dtb],[dtc],[dtd],[dta],dword [edi+13*4],15
  166.         mov     [dtb],eax
  167.         stdcall HH,[dta],[dtb],[dtc],[dtd],dword [edi+03*4],03
  168.         mov     [dta],eax
  169.         stdcall HH,[dtd],[dta],[dtb],[dtc],dword [edi+11*4],09
  170.         mov     [dtd],eax
  171.         stdcall HH,[dtc],[dtd],[dta],[dtb],dword [edi+07*4],11
  172.         mov     [dtc],eax
  173.         stdcall HH,[dtb],[dtc],[dtd],[dta],dword [edi+15*4],15
  174.         mov     [dtb],eax
  175.  
  176.         mov     eax,[dta]
  177.         add     [stdtA],eax
  178.         mov     eax,[dtb]
  179.         add     [stdtB],eax
  180.         mov     eax,[dtc]
  181.         add     [stdtC],eax
  182.         mov     eax,[dtd]
  183.         add     [stdtD],eax
  184.  
  185.         add     edi,64
  186.  
  187.         sub     edx,64
  188.         jnz     hashloop
  189.  
  190.         ; phase IV - results
  191.  
  192.         mov     ecx,4
  193.         mov     esi,stMD4Result
  194. @@:
  195.         mov     eax,dword [esi]
  196.         xchg    al,ah
  197.         rol     eax,16
  198.         xchg    al,ah
  199.         mov     dword [esi],eax
  200.  
  201.         add     esi,4
  202.  
  203.         loop    @b
  204.  
  205.         pop  esi edi edx ecx ebx eax
  206.  
  207.         ret
  208. endp
  209.  
  210. ; a = (a + F(b,c,d) + X[k]) <<< s
  211. proc    FF var1,var2,var3,var4,k,s
  212.         push    ebx ecx
  213.  
  214.         mov     eax,[var2]
  215.         and     eax,[var3]
  216.         mov     ebx,[var2]
  217.         not     ebx
  218.         and     ebx,[var4]
  219.         or      eax,ebx
  220.  
  221.         add     eax,[k]
  222.         add     eax,[var1]
  223.  
  224.         mov     ecx,[s]
  225.         rol     eax,cl
  226.  
  227.         pop     ecx ebx
  228.         ret
  229. endp
  230.  
  231. ;a = (a + G(b,c,d) + X[k] + 5A827999) <<< s
  232. proc    GG var1,var2,var3,var4,k,s
  233.         push    ebx ecx
  234.  
  235.         mov     eax,[var2]
  236.         mov     ebx,[var3]
  237.         or      ebx,[var4]
  238.         and     eax,ebx
  239.         mov     ebx,[var3]
  240.         and     ebx,[var4]
  241.         or      eax,ebx
  242.  
  243.         add     eax,5A827999h
  244.         add     eax,[k]
  245.         add     eax,[var1]
  246.  
  247.         mov     ecx,[s]
  248.         rol     eax,cl
  249.  
  250.         pop     ecx ebx
  251.         ret
  252. endp
  253.  
  254. ; a = (a + H(b,c,d) + X[k] + 6ED9EBA1) <<< s
  255. proc    HH var1,var2,var3,var4,k,s
  256.         push    ecx
  257.  
  258.         mov     eax,[var2]
  259.         xor     eax,[var3]
  260.         xor     eax,[var4]
  261.  
  262.         add     eax,6ED9EBA1h
  263.         add     eax,[k]
  264.         add     eax,[var1]
  265.  
  266.         mov     ecx,[s]
  267.         rol     eax,cl
  268.  
  269.         pop     ecx
  270.         ret
  271. endp
Для накопительного расчета при каждом следующем вызове начальные значения MD4 должны быть проинициализированы результатами предыдущего расчета. Пример использования для одиночной стоки (блока данных):
  1. ; Сегмент данных
  2. section '.data' data readable writeable  
  3. ...
  4. somedata db 'Yeah! I like Flat Assembler!',0 ; Исходные данные для хеширования
  5.  
  6. ; Сегмент кода
  7. section '.code' code readable executable
  8.         ...
  9.         ; Расчет длины строки. Для бинарных данных lstrlen лучше не использовать
  10.         invoke  lstrlen,somedata
  11.         ; Расчет MD4
  12.         stdcall procMD4hash,0,0,0,0,somedata,eax
  13.         ; Перевод в строку, буквы заглавные
  14.         invoke  wsprintf,stMD4Hash,szMD4Format1,[stdtA],[stdtB],[stdtC],[stdtD]
  15.         ...
После выполнения приведенного пример в текстовом буфере stMD4Hash будет строка хеша MD4 "87BBCCB2145ACDE7272EA8EDF7184920" в формате ASCIIZ.

Первые уязвимости алгоритма и коллизии были найдены уже через год после его опубликования, но MD4 создавался прежде всего как очень быстрый алгоритм хеширования, поэтому он не является достаточно хорошим в плане криптостойкости. В приложении пример программы с исходным текстом, считающей хеш MD4 от введенной строки.

Пример программы с исходным текстом (FASM)Пример программы с исходным текстом (FASM)

MD4.Demo.zip (3,954 bytes)


Поделиться ссылкой ВКонтакте Поделиться ссылкой на Facebook Поделиться ссылкой на LiveJournal Поделиться ссылкой в Мой Круг Добавить в Мой мир Добавить на ЛиРу (Liveinternet) Добавить в закладки Memori Добавить в закладки Google
Просмотров: 3098 | Комментариев: 2

Внимание! Статья опубликована больше года назад, информация могла устареть!

Комментарии

Отзывы посетителей сайта о статье
rogue (11.05.2012 в 13:29):
Красавец.
Yoshida (16.04.2012 в 22:16):
Спасибо, как всегда интересно.

Добавить комментарий

Заполните форму для добавления комментария
Имя*:
Текст комментария (не более 2000 символов)*:

*Все поля обязательны для заполнения.
Комментарии, содержащие рекламу, ненормативную лексику, оскорбления и т.п., а также флуд и сообщения не по теме, будут удаляться. Нарушителям может быть заблокирован доступ к сайту.
Наверх
Powered by PCL's Speckled Band Engine 0.2 RC3
© ManHunter / PCL, 2008-2018
При использовании материалов ссылка на сайт обязательна
Время генерации: 0.09 сек. / MySQL: 2 (0.0054 сек.) / Память: 4.75 Mb
Наверх