Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. macro chn x, y, z
  2. {
  3.         mov     eax, [y]
  4.         xor     eax, [z]
  5.         and     eax, [x]
  6.         xor     eax, [z]
  7. }
  8.  
  9. macro maj x, y, z
  10. {
  11.         mov     eax, [x]
  12.         xor     eax, [y]
  13.         and     eax, [z]
  14.         mov     ecx, [x]
  15.         and     ecx, [y]
  16.         xor     eax, ecx
  17. }
  18.  
  19. macro Sigma0 x
  20. {
  21.         mov     eax, x
  22.         mov     ecx, eax
  23.         ror     ecx, 2
  24.         ror     eax, 13
  25.         xor     eax, ecx
  26.         mov     ecx, x
  27.         ror     ecx, 22
  28.         xor     eax, ecx
  29. }
  30.  
  31. macro Sigma1 x
  32. {
  33.         mov     eax, x
  34.         mov     ecx, eax
  35.         ror     ecx, 6
  36.         ror     eax, 11
  37.         xor     eax, ecx
  38.         mov     ecx, x
  39.         ror     ecx, 25
  40.         xor     eax, ecx
  41. }
  42.  
  43. macro sigma0 x
  44. {
  45.         mov     eax, x
  46.         mov     ecx, eax
  47.         ror     ecx, 7
  48.         ror     eax, 18
  49.         xor     eax, ecx
  50.         mov     ecx, x
  51.         shr     ecx, 3
  52.         xor     eax, ecx
  53. }
  54.  
  55. macro sigma1 x
  56. {
  57.         mov     eax, x
  58.         mov     ecx, eax
  59.         ror     ecx, 17
  60.         ror     eax, 19
  61.         xor     eax, ecx
  62.         mov     ecx, x
  63.         shr     ecx, 10
  64.         xor     eax, ecx
  65. }
  66.  
  67. macro recalculate_w n
  68. {
  69.         mov     edx, [w + ((n-2) and 15)*4]
  70.         sigma1  edx
  71.         add     eax, [w + ((n-7) and 15)*4]
  72.         push    eax
  73.         mov     edx, [w + ((n-15) and 15)*4]
  74.         sigma0  edx
  75.         pop     ecx
  76.         add     eax, ecx
  77.         add     [w + (n)*4], eax
  78. }
  79.  
  80. macro crash.sha256.round a, b, c, d, e, f, g, h, k
  81. {
  82.         mov     ebx, [h]
  83.         mov     edx, [e]
  84.         Sigma1  edx
  85.  
  86.         add     ebx, eax
  87.         chn     e, f, g
  88.  
  89.         add     ebx, eax
  90.         add     ebx, [k]
  91.         add     ebx, edi
  92.  
  93.         add     [d], ebx
  94.  
  95.         mov     edx, [a]
  96.         Sigma0  edx
  97.         add     ebx, eax
  98.         maj     a, b, c
  99.         add     eax, ebx
  100.         mov     [h], eax
  101. }
  102.  
  103.  
  104. macro crash.sha256.round_1_16 a, b, c, d, e, f, g, h, n
  105. {
  106.  
  107.         mov     eax, [esi + (n)*4]
  108.         bswap   eax
  109.  
  110.         mov     dword[w + (n)*4], eax
  111.         mov     edi, eax
  112.         crash.sha256.round a, b, c, d, e, f, g, h, (crash._.sha256_table + (n)*4)
  113. }
  114.  
  115. macro crash.sha256.round_17_64 a, b, c, d, e, f, g, h, n, rep_num
  116. {
  117.         recalculate_w n
  118.         mov     edi, [w + (n)*4]
  119.         crash.sha256.round a, b, c, d, e, f, g, h, (crash._.sha256_table + (n+16*rep_num)*4)
  120. }
  121.  
  122.  
  123. proc crash.sha256 _sha256, _data, _len, _callback, _msglen
  124. locals
  125.         final   rd 1
  126.         w       rd 64
  127.         A       rd 1
  128.         B       rd 1
  129.         C       rd 1
  130.         D       rd 1
  131.         E       rd 1
  132.         F       rd 1
  133.         G       rd 1
  134.         H       rd 1
  135. endl
  136.         mov     [final], 0
  137.   .first:
  138.         mov     eax, [_msglen]
  139.         mov     ecx, [_len]
  140.         add     [eax], ecx
  141.         mov     esi, [_data]
  142.         test    ecx, ecx
  143.         jz      .callback
  144.   .begin:
  145.         sub     [_len], 64
  146.         jnc     @f
  147.         add     [_len], 64
  148.         jmp     .endofblock
  149.     @@:
  150.         mov     edi, [_sha256]
  151.         mov     eax, [edi + 0x00]
  152.         mov     [A], eax
  153.         mov     eax, [edi + 0x04]
  154.         mov     [B], eax
  155.         mov     eax, [edi + 0x08]
  156.         mov     [C], eax
  157.         mov     eax, [edi + 0x0c]
  158.         mov     [D], eax
  159.         mov     eax, [edi + 0x10]
  160.         mov     [E], eax
  161.         mov     eax, [edi + 0x14]
  162.         mov     [F], eax
  163.         mov     eax, [edi + 0x18]
  164.         mov     [G], eax
  165.         mov     eax, [edi + 0x1c]
  166.         mov     [H], eax
  167.  
  168.         crash.sha256.round_1_16         A, B, C, D, E, F, G, H,  0
  169.         crash.sha256.round_1_16         H, A, B, C, D, E, F, G,  1
  170.         crash.sha256.round_1_16         G, H, A, B, C, D, E, F,  2
  171.         crash.sha256.round_1_16         F, G, H, A, B, C, D, E,  3
  172.         crash.sha256.round_1_16         E, F, G, H, A, B, C, D,  4
  173.         crash.sha256.round_1_16         D, E, F, G, H, A, B, C,  5
  174.         crash.sha256.round_1_16         C, D, E, F, G, H, A, B,  6
  175.         crash.sha256.round_1_16         B, C, D, E, F, G, H, A,  7
  176.         crash.sha256.round_1_16         A, B, C, D, E, F, G, H,  8
  177.         crash.sha256.round_1_16         H, A, B, C, D, E, F, G,  9
  178.         crash.sha256.round_1_16         G, H, A, B, C, D, E, F, 10
  179.         crash.sha256.round_1_16         F, G, H, A, B, C, D, E, 11
  180.         crash.sha256.round_1_16         E, F, G, H, A, B, C, D, 12
  181.         crash.sha256.round_1_16         D, E, F, G, H, A, B, C, 13
  182.         crash.sha256.round_1_16         C, D, E, F, G, H, A, B, 14
  183.         crash.sha256.round_1_16         B, C, D, E, F, G, H, A, 15
  184.  
  185. repeat 3
  186.         crash.sha256.round_17_64        A, B, C, D, E, F, G, H,  0, %
  187.         crash.sha256.round_17_64        H, A, B, C, D, E, F, G,  1, %
  188.         crash.sha256.round_17_64        G, H, A, B, C, D, E, F,  2, %
  189.         crash.sha256.round_17_64        F, G, H, A, B, C, D, E,  3, %
  190.         crash.sha256.round_17_64        E, F, G, H, A, B, C, D,  4, %
  191.         crash.sha256.round_17_64        D, E, F, G, H, A, B, C,  5, %
  192.         crash.sha256.round_17_64        C, D, E, F, G, H, A, B,  6, %
  193.         crash.sha256.round_17_64        B, C, D, E, F, G, H, A,  7, %
  194.         crash.sha256.round_17_64        A, B, C, D, E, F, G, H,  8, %
  195.         crash.sha256.round_17_64        H, A, B, C, D, E, F, G,  9, %
  196.         crash.sha256.round_17_64        G, H, A, B, C, D, E, F, 10, %
  197.         crash.sha256.round_17_64        F, G, H, A, B, C, D, E, 11, %
  198.         crash.sha256.round_17_64        E, F, G, H, A, B, C, D, 12, %
  199.         crash.sha256.round_17_64        D, E, F, G, H, A, B, C, 13, %
  200.         crash.sha256.round_17_64        C, D, E, F, G, H, A, B, 14, %
  201.         crash.sha256.round_17_64        B, C, D, E, F, G, H, A, 15, %
  202. end repeat
  203.  
  204.         mov     edi, [_sha256]
  205.         mov     eax, [A]
  206.         add     [edi + 0x00], eax
  207.         mov     eax, [B]
  208.         add     [edi + 0x04], eax
  209.         mov     eax, [C]
  210.         add     [edi + 0x08], eax
  211.         mov     eax, [D]
  212.         add     [edi + 0x0c], eax
  213.         mov     eax, [E]
  214.         add     [edi + 0x10], eax
  215.         mov     eax, [F]
  216.         add     [edi + 0x14], eax
  217.         mov     eax, [G]
  218.         add     [edi + 0x18], eax
  219.         mov     eax, [H]
  220.         add     [edi + 0x1c], eax
  221.         add     esi, 64
  222.         jmp     .begin
  223.   .endofblock:
  224.         cmp     [final], 1
  225.         je      .quit
  226.  
  227.   .callback:
  228.         mov     eax, [_callback]
  229.         test    eax, eax
  230.         jz      @f
  231.         call    eax
  232.         test    eax, eax
  233.         jz      @f
  234.         mov     [_len], eax
  235.         jmp     .first
  236.     @@:
  237.  
  238.         mov     edi, [_data]
  239.         mov     ecx, [_len]
  240.         rep     movsb
  241.         mov     eax, [_msglen]
  242.         mov     eax, [eax]
  243.         and     eax, 63
  244.         mov     ecx, 56
  245.         sub     ecx, eax
  246.         ja      @f
  247.         add     ecx, 64
  248.     @@:
  249.         add     [_len], ecx
  250.         mov     byte[edi], 0x80
  251.         add     edi, 1
  252.         sub     ecx, 1
  253.         mov     al, 0
  254.         rep     stosb
  255.         mov     eax, [_msglen]
  256.         mov     eax, [eax]
  257.         mov     edx, 8
  258.         mul     edx
  259.         bswap   eax
  260.         bswap   edx
  261.         mov     dword[edi], edx
  262.         mov     dword[edi + 4], eax
  263.         add     [_len], 8
  264.         mov     [final], 1
  265.         jmp     .first
  266.   .quit:
  267.         mov     esi, [_sha256]
  268.         mov     edi, esi
  269.         mov     ecx, 8
  270.     @@:
  271.         lodsd
  272.         bswap   eax
  273.         stosd
  274.         sub     ecx, 1
  275.         jnz     @b
  276.         ret
  277. endp
  278.  
  279.