libcrash: Sync with upstream.

* Add oneshot wrappers.
* Move tables to data section.
* Add/rename macros and fix their use in ssh.

git-svn-id: svn://kolibrios.org@7698 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Ivan Baravy 2019-10-21 22:33:41 +00:00
parent 488a034278
commit b51d135d5c
15 changed files with 2631 additions and 2448 deletions

View File

@ -1,3 +1,5 @@
if tup.getconfig("NO_FASM") ~= "" then return end if tup.getconfig("NO_FASM") ~= "" then return end
tup.rule("libcrash.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libcrash.obj") HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR")
tup.rule("crashtest.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crashtest") tup.include(HELPERDIR .. "/use_fasm.lua")
tup.rule("libcrash.asm", FASM .. " %f %o " .. tup.getconfig("KPACK_CMD"), "libcrash.obj")
tup.rule("crashtest.asm", FASM .. " %f %o " .. tup.getconfig("KPACK_CMD"), "crashtest")

View File

@ -1,112 +1,133 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2012-2013,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2012-2013,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
proc crc32.init _ctx CRC32_HASH_SIZE = 4
mov ebx, [_ctx]
lea edi, [ebx + ctx_crc32.hash] CRC32_ALIGN = 4
mov esi, crc32._.hash_init CRC32_ALIGN_MASK = CRC32_ALIGN - 1
mov ecx, 1
rep movsd struct ctx_crc32
ret hash rd 1
endp ends
if defined sizeof.crash_ctx
proc crc32.update _ctx, _msg, _size assert sizeof.crash_ctx >= sizeof.ctx_crc32
mov ebx, [_ctx] end if
mov esi, [_msg]
lea edi, [ebx + ctx_crc32.hash] proc crc32.init _ctx
mov eax, [edi] mov ebx, [_ctx]
mov ecx, [_size] lea edi, [ebx + ctx_crc32.hash]
jecxz .quit mov esi, crc32._.hash_init
mov ecx, 1
@@: rep movsd
movzx edx, al ret
xor dl, byte[esi] endp
add esi, 1
shr eax, 8
xor eax, [crc32._.table + edx*4] proc crc32.update _ctx, _msg, _size
dec ecx mov ebx, [_ctx]
jnz @b mov esi, [_msg]
lea edi, [ebx + ctx_crc32.hash]
stosd mov eax, [edi]
.quit: mov ecx, [_size]
ret jecxz .quit
endp
@@:
movzx edx, al
proc crc32.final _ctx xor dl, byte[esi]
mov ebx, [_ctx] add esi, 1
lea esi, [ebx + ctx_crc32.hash] shr eax, 8
mov edi, esi xor eax, [crc32._.table + edx*4]
lodsd dec ecx
xor eax, 0xffffffff jnz @b
bswap eax
stosd stosd
ret .quit:
endp ret
endp
align CRC32_ALIGN
proc crc32.final _ctx
crc32._.hash_init dd 0xffffffff mov ebx, [_ctx]
lea esi, [ebx + ctx_crc32.hash]
crc32._.table dd \ mov edi, esi
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,\ lodsd
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,\ xor eax, 0xffffffff
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,\ bswap eax
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,\ stosd
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,\ ret
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,\ endp
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,\
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,\
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,\ proc crc32.oneshot _ctx, _data, _len
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,\ stdcall crc32.init, [_ctx]
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,\ stdcall crc32.update, [_ctx], [_data], [_len]
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,\ stdcall crc32.final, [_ctx]
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,\ ret
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,\ endp
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,\
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,\
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,\ iglobal
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,\ align CRC32_ALIGN
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,\ crc32._.hash_init dd 0xffffffff
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,\
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,\ crc32._.table dd \
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,\ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,\
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,\ 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,\
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,\ 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,\
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,\ 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,\
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,\ 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,\
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,\ 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,\
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,\ 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,\
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,\ 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,\
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,\ 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,\
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,\ 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,\
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,\ 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,\
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,\ 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,\
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,\ 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,\
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,\ 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,\
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,\ 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,\
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,\ 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,\
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,\ 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,\
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,\ 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,\
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,\ 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,\
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,\ 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,\
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,\ 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,\
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,\
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,\
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,\
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,\
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,\
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,\
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,\
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,\
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,\
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,\
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,\
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,\
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,\
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,\
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,\
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,\
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,\
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,\
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,\
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,\
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,\
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
endg

View File

@ -19,11 +19,11 @@ format MS COFF
public @EXPORT as 'EXPORTS' public @EXPORT as 'EXPORTS'
include '../../../../struct.inc' include 'struct.inc'
include '../../../../proc32.inc' include 'proc32.inc'
include '../../../../macros.inc' include 'macros.inc'
include '../../../../config.inc' include 'config.inc'
;include '../../../../debug.inc' include 'kglobals.inc'
purge section,mov,add,sub purge section,mov,add,sub
section '.flat' code readable align 16 section '.flat' code readable align 16
@ -103,21 +103,23 @@ endp
section '.data' data readable align 16 section '.data' data readable align 16
crash._.bin2hex_table db '0123456789abcdef' crash._.bin2hex_table db '0123456789abcdef'
crash._.table dd \ crash._.table dd \
crc32.init, crc32.update, crc32.final, CRC32_HASH_SIZE, \ crc32.init, crc32.update, crc32.final, crc32.oneshot, CRC32_HASH_SIZE, \
md4.init, md4.update, md4.final, MD4_HASH_SIZE, \ md4.init, md4.update, md4.final, md4.oneshot, MD4_HASH_SIZE, \
md5.init, md5.update, md5.final, MD5_HASH_SIZE, \ md5.init, md5.update, md5.final, md5.oneshot, MD5_HASH_SIZE, \
sha1.init, sha1.update, sha1.final, SHA1_HASH_SIZE, \ sha1.init, sha1.update, sha1.final, sha1.oneshot, SHA1_HASH_SIZE, \
sha224.init, sha224.update, sha224.final, SHA224_HASH_SIZE, \ sha224.init, sha224.update, sha224.final, sha224.oneshot, SHA224_HASH_SIZE, \
sha256.init, sha256.update, sha256.final, SHA256_HASH_SIZE, \ sha256.init, sha256.update, sha256.final, sha256.oneshot, SHA256_HASH_SIZE, \
sha384.init, sha384.update, sha384.final, SHA384_HASH_SIZE, \ sha384.init, sha384.update, sha384.final, sha384.oneshot, SHA384_HASH_SIZE, \
sha512.init, sha512.update, sha512.final, SHA512_HASH_SIZE, \ sha512.init, sha512.update, sha512.final, sha512.oneshot, SHA512_HASH_SIZE, \
sha3224.init, sha3224.update, sha3224.final, SHA3224_HASH_SIZE,\ sha3_224.init, sha3_224.update, sha3_224.final, sha3_224.oneshot, SHA3_224_HASH_SIZE,\
sha3256.init, sha3256.update, sha3256.final, SHA3256_HASH_SIZE,\ sha3_256.init, sha3_256.update, sha3_256.final, sha3_256.oneshot, SHA3_256_HASH_SIZE,\
sha3384.init, sha3384.update, sha3384.final, SHA3384_HASH_SIZE,\ sha3_384.init, sha3_384.update, sha3_384.final, sha3_384.oneshot, SHA3_384_HASH_SIZE,\
sha3512.init, sha3512.update, sha3512.final, SHA3512_HASH_SIZE sha3_512.init, sha3_512.update, sha3_512.final, sha3_512.oneshot, SHA3_512_HASH_SIZE
IncludeIGlobals
align 4 align 4
@EXPORT: @EXPORT:
@ -129,36 +131,48 @@ export \
crc32.init, 'crc32_init' , \ crc32.init, 'crc32_init' , \
crc32.update, 'crc32_update' , \ crc32.update, 'crc32_update' , \
crc32.final, 'crc32_final' , \ crc32.final, 'crc32_final' , \
crc32.oneshot, 'crc32_oneshot' , \
md4.init, 'md4_init' , \ md4.init, 'md4_init' , \
md4.update, 'md4_update' , \ md4.update, 'md4_update' , \
md4.final, 'md4_final' , \ md4.final, 'md4_final' , \
md4.oneshot, 'md4_oneshot' , \
md5.init, 'md5_init' , \ md5.init, 'md5_init' , \
md5.update, 'md5_update' , \ md5.update, 'md5_update' , \
md5.final, 'md5_final' , \ md5.final, 'md5_final' , \
md5.oneshot, 'md5_oneshot' , \
sha1.init, 'sha1_init' , \ sha1.init, 'sha1_init' , \
sha1.update, 'sha1_update' , \ sha1.update, 'sha1_update' , \
sha1.final, 'sha1_final' , \ sha1.final, 'sha1_final' , \
sha1.oneshot, 'sha1_oneshot' , \
sha224.init, 'sha224_init' , \ sha224.init, 'sha224_init' , \
sha224.update, 'sha224_update' , \ sha224.update, 'sha224_update' , \
sha224.final, 'sha224_final' , \ sha224.final, 'sha224_final' , \
sha224.oneshot, 'sha224_oneshot' , \
sha256.init, 'sha256_init' , \ sha256.init, 'sha256_init' , \
sha256.update, 'sha256_update' , \ sha256.update, 'sha256_update' , \
sha256.final, 'sha256_final' , \ sha256.final, 'sha256_final' , \
sha256.oneshot, 'sha256_oneshot' , \
sha384.init, 'sha384_init' , \ sha384.init, 'sha384_init' , \
sha384.update, 'sha384_update' , \ sha384.update, 'sha384_update' , \
sha384.final, 'sha384_final' , \ sha384.final, 'sha384_final' , \
sha384.oneshot, 'sha384_oneshot' , \
sha512.init, 'sha512_init' , \ sha512.init, 'sha512_init' , \
sha512.update, 'sha512_update' , \ sha512.update, 'sha512_update' , \
sha512.final, 'sha512_final' , \ sha512.final, 'sha512_final' , \
sha3224.init, 'sha3_224_init' , \ sha512.oneshot, 'sha512_oneshot' , \
sha3224.update, 'sha3_224_update' , \ sha3_224.init, 'sha3_224_init' , \
sha3224.final, 'sha3_224_final' , \ sha3_224.update, 'sha3_224_update' , \
sha3256.init, 'sha3_256_init' , \ sha3_224.final, 'sha3_224_final' , \
sha3256.update, 'sha3_256_update' , \ sha3_224.oneshot, 'sha3_224_oneshot' , \
sha3256.final, 'sha3_256_final' , \ sha3_256.init, 'sha3_256_init' , \
sha3384.init, 'sha3_384_init' , \ sha3_256.update, 'sha3_256_update' , \
sha3384.update, 'sha3_384_update' , \ sha3_256.final, 'sha3_256_final' , \
sha3384.final, 'sha3_384_final' , \ sha3_256.oneshot, 'sha3_256_oneshot' , \
sha3512.init, 'sha3_512_init' , \ sha3_384.init, 'sha3_384_init' , \
sha3512.update, 'sha3_512_update' , \ sha3_384.update, 'sha3_384_update' , \
sha3512.final, 'sha3_512_final' sha3_384.final, 'sha3_384_final' , \
sha3_384.oneshot, 'sha3_384_oneshot' , \
sha3_512.init, 'sha3_512_init' , \
sha3_512.update, 'sha3_512_update' , \
sha3_512.final, 'sha3_512_final' , \
sha3_512.oneshot, 'sha3_512_oneshot'

View File

@ -1,175 +1,81 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2012-2014,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2012-2014,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
LIBCRASH_CRC32 = 0 LIBCRASH_CRC32 = 0
LIBCRASH_MD4 = 1 LIBCRASH_MD4 = 1
LIBCRASH_MD5 = 2 LIBCRASH_MD5 = 2
LIBCRASH_SHA1 = 3 LIBCRASH_SHA1 = 3
LIBCRASH_SHA224 = 4 LIBCRASH_SHA224 = 4
LIBCRASH_SHA256 = 5 LIBCRASH_SHA256 = 5
LIBCRASH_SHA384 = 6 LIBCRASH_SHA384 = 6
LIBCRASH_SHA512 = 7 LIBCRASH_SHA512 = 7
LIBCRASH_SHA3_224 = 8 LIBCRASH_SHA3_224 = 8
LIBCRASH_SHA3_256 = 9 LIBCRASH_SHA3_256 = 9
LIBCRASH_SHA3_384 = 10 LIBCRASH_SHA3_384 = 10
LIBCRASH_SHA3_512 = 11 LIBCRASH_SHA3_512 = 11
LIBCRASH_LAST = 11 LIBCRASH_LAST = 11
struct crash_item struct crash_item
init dd ? init dd ?
update dd ? update dd ?
final dd ? final dd ?
len_out dd ? oneshot dd ?
ends len_out dd ?
ends
; CRC32
struct crash_ctx
CRC32_HASH_SIZE = 4 hash rb 1024 ; context starts with hash data
CRC32_ALIGN = 4 ends
CRC32_ALIGN_MASK = CRC32_ALIGN - 1
struct ctx_crc32 CRC32_HASH_SIZE = 4
hash rd 1 CRC32_BLOCK_SIZE = 1
ends
MD4_HASH_SIZE = 16
; MD4 MD4_BLOCK_SIZE = 64
MD4_BLOCK_SIZE = 64 MD5_HASH_SIZE = 16
MD4_HASH_SIZE = 16 MD5_BLOCK_SIZE = 64
MD4_ALIGN = 4
MD4_ALIGN_MASK = MD4_ALIGN - 1 SHA1_HASH_SIZE = 20
SHA1_BLOCK_SIZE = 64
struct ctx_md4
hash rb MD4_HASH_SIZE SHA224_HASH_SIZE = 28
block rb MD4_BLOCK_SIZE SHA224_BLOCK_SIZE = 64
index rd 1
msglen_0 rd 1 SHA256_HASH_SIZE = 32
msglen_1 rd 1 SHA256_BLOCK_SIZE = 64
ends
SHA384_HASH_SIZE = 48
; MD5 SHA384_BLOCK_SIZE = 128
MD5_BLOCK_SIZE = 64 SHA512_HASH_SIZE = 64
MD5_HASH_SIZE = 16 SHA512_BLOCK_SIZE = 128
MD5_ALIGN = 4
MD5_ALIGN_MASK = MD5_ALIGN - 1 SHA3_224_HASH_SIZE = 28
SHA3_224_BLOCK_SIZE = 144
struct ctx_md5
hash rb MD5_HASH_SIZE SHA3_256_HASH_SIZE = 32
block rb MD5_BLOCK_SIZE SHA3_256_BLOCK_SIZE = 136
index rd 1
msglen_0 rd 1 SHA3_384_HASH_SIZE = 48
msglen_1 rd 1 SHA3_384_BLOCK_SIZE = 104
ends
SHA3_512_HASH_SIZE = 64
; SHA1 SHA3_512_BLOCK_SIZE = 72
SHA1_BLOCK_SIZE = 64
SHA1_HASH_SIZE = 20
SHA1_ALIGN = 4
SHA1_ALIGN_MASK = SHA1_ALIGN - 1
struct ctx_sha1
hash rb SHA1_HASH_SIZE
block rb SHA1_BLOCK_SIZE
index rd 1
msglen_0 rd 1
msglen_1 rd 1
ends
; SHA2
SHA224256_BLOCK_SIZE = 64
SHA224256_INIT_SIZE = 32
SHA224_HASH_SIZE = 28
SHA256_HASH_SIZE = 32
SHA224256_ALIGN = 4
SHA224256_ALIGN_MASK = SHA224256_ALIGN - 1
struct ctx_sha224256
hash rb SHA224256_INIT_SIZE
block rb SHA224256_BLOCK_SIZE
index rd 1
msglen_0 rd 1
msglen_1 rd 1
ends
SHA384512_BLOCK_SIZE = 128
SHA384512_INIT_SIZE = 64
SHA384_HASH_SIZE = 48
SHA512_HASH_SIZE = 64
SHA384512_ALIGN = 16
SHA384512_ALIGN_MASK = SHA384512_ALIGN - 1
struct ctx_sha384512
hash rb SHA384512_INIT_SIZE
block rb SHA384512_BLOCK_SIZE
index rd 1
msglen_0 rd 1
msglen_1 rd 1
msglen_2 rd 1
msglen_3 rd 1
rd 3 ; align
; tmp vars
w rq 80
A rq 1
B rq 1
C rq 1
D rq 1
E rq 1
F rq 1
G rq 1
H rq 1
temp rq 1
ends
; SHA3
SHA3224_BLOCK_SIZE = 144
SHA3256_BLOCK_SIZE = 136
SHA3384_BLOCK_SIZE = 104
SHA3512_BLOCK_SIZE = 72
SHA3MAX_BLOCK_SIZE = SHA3224_BLOCK_SIZE
SHA3_INIT_SIZE = 200
SHA3224_HASH_SIZE = 28
SHA3256_HASH_SIZE = 32
SHA3384_HASH_SIZE = 48
SHA3512_HASH_SIZE = 64
SHA3_ALIGN = 16
SHA3_ALIGN_MASK = SHA3_ALIGN-1
struct ctx_sha3
hash rb SHA3_INIT_SIZE
rb SHA3_ALIGN - (SHA3_INIT_SIZE mod SHA3_ALIGN)
block rb SHA3MAX_BLOCK_SIZE
rb SHA3_ALIGN - (SHA3MAX_BLOCK_SIZE mod SHA3_ALIGN)
index rd 1
block_size rd 1
rounds_cnt rd 1
rd 1 ; align
; tmp vars
C rq 5
D rq 5
ends

View File

@ -1,237 +1,263 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2012-2013,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2012-2013,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
macro md4._.f b, c, d MD4_HASH_SIZE = 16
{ MD4_BLOCK_SIZE = 64
mov eax, c
xor eax, d MD4_ALIGN = 4
and eax, b MD4_ALIGN_MASK = MD4_ALIGN - 1
xor eax, d
} struct ctx_md4
hash rb MD4_HASH_SIZE
macro md4._.g b, c, d block rb MD4_BLOCK_SIZE
{ index rd 1
push c d msglen_0 rd 1
mov eax, b msglen_1 rd 1
and eax, c ends
and c, d
and d, b if defined sizeof.crash_ctx
or eax, c assert sizeof.crash_ctx >= sizeof.ctx_md4
or eax, d end if
pop d c
} macro md4._.f b, c, d
{
macro md4._.h b, c, d mov eax, c
{ xor eax, d
mov eax, b and eax, b
xor eax, c xor eax, d
xor eax, d }
}
macro md4._.g b, c, d
macro md4._.round func, a, b, c, d, index, shift, ac {
{ push c d
func b, c, d mov eax, b
add eax, [esi + index*4] and eax, c
lea a, [a + eax + ac] and c, d
rol a, shift and d, b
} or eax, c
or eax, d
pop d c
proc md4.init _ctx }
mov ebx, [_ctx]
lea edi, [ebx + ctx_md4.hash] macro md4._.h b, c, d
mov esi, md4._.hash_init {
mov ecx, MD4_HASH_SIZE/4 mov eax, b
rep movsd xor eax, c
xor eax, eax xor eax, d
mov [ebx + ctx_md4.index], eax }
mov [ebx + ctx_md4.msglen_0], eax
mov [ebx + ctx_md4.msglen_1], eax macro md4._.round func, a, b, c, d, index, shift, ac
ret {
endp func b, c, d
add eax, [esi + index*4]
lea a, [a + eax + ac]
proc md4._.block _hash rol a, shift
}
mov eax, [_hash]
mov edi, [eax + 0x0]
mov ebx, [eax + 0x4] proc md4.init _ctx
mov ecx, [eax + 0x8] mov ebx, [_ctx]
mov edx, [eax + 0xc] lea edi, [ebx + ctx_md4.hash]
mov esi, md4._.hash_init
md4._.round md4._.f, edi, ebx, ecx, edx, 0, 3, 0x00000000 mov ecx, MD4_HASH_SIZE/4
md4._.round md4._.f, edx, edi, ebx, ecx, 1, 7, 0x00000000 rep movsd
md4._.round md4._.f, ecx, edx, edi, ebx, 2, 11, 0x00000000 xor eax, eax
md4._.round md4._.f, ebx, ecx, edx, edi, 3, 19, 0x00000000 mov [ebx + ctx_md4.index], eax
md4._.round md4._.f, edi, ebx, ecx, edx, 4, 3, 0x00000000 mov [ebx + ctx_md4.msglen_0], eax
md4._.round md4._.f, edx, edi, ebx, ecx, 5, 7, 0x00000000 mov [ebx + ctx_md4.msglen_1], eax
md4._.round md4._.f, ecx, edx, edi, ebx, 6, 11, 0x00000000 ret
md4._.round md4._.f, ebx, ecx, edx, edi, 7, 19, 0x00000000 endp
md4._.round md4._.f, edi, ebx, ecx, edx, 8, 3, 0x00000000
md4._.round md4._.f, edx, edi, ebx, ecx, 9, 7, 0x00000000
md4._.round md4._.f, ecx, edx, edi, ebx, 10, 11, 0x00000000 proc md4._.block _hash
md4._.round md4._.f, ebx, ecx, edx, edi, 11, 19, 0x00000000
md4._.round md4._.f, edi, ebx, ecx, edx, 12, 3, 0x00000000 mov eax, [_hash]
md4._.round md4._.f, edx, edi, ebx, ecx, 13, 7, 0x00000000 mov edi, [eax + 0x0]
md4._.round md4._.f, ecx, edx, edi, ebx, 14, 11, 0x00000000 mov ebx, [eax + 0x4]
md4._.round md4._.f, ebx, ecx, edx, edi, 15, 19, 0x00000000 mov ecx, [eax + 0x8]
mov edx, [eax + 0xc]
md4._.round md4._.g, edi, ebx, ecx, edx, 0, 3, 0x5a827999
md4._.round md4._.g, edx, edi, ebx, ecx, 4, 5, 0x5a827999 md4._.round md4._.f, edi, ebx, ecx, edx, 0, 3, 0x00000000
md4._.round md4._.g, ecx, edx, edi, ebx, 8, 9, 0x5a827999 md4._.round md4._.f, edx, edi, ebx, ecx, 1, 7, 0x00000000
md4._.round md4._.g, ebx, ecx, edx, edi, 12, 13, 0x5a827999 md4._.round md4._.f, ecx, edx, edi, ebx, 2, 11, 0x00000000
md4._.round md4._.g, edi, ebx, ecx, edx, 1, 3, 0x5a827999 md4._.round md4._.f, ebx, ecx, edx, edi, 3, 19, 0x00000000
md4._.round md4._.g, edx, edi, ebx, ecx, 5, 5, 0x5a827999 md4._.round md4._.f, edi, ebx, ecx, edx, 4, 3, 0x00000000
md4._.round md4._.g, ecx, edx, edi, ebx, 9, 9, 0x5a827999 md4._.round md4._.f, edx, edi, ebx, ecx, 5, 7, 0x00000000
md4._.round md4._.g, ebx, ecx, edx, edi, 13, 13, 0x5a827999 md4._.round md4._.f, ecx, edx, edi, ebx, 6, 11, 0x00000000
md4._.round md4._.g, edi, ebx, ecx, edx, 2, 3, 0x5a827999 md4._.round md4._.f, ebx, ecx, edx, edi, 7, 19, 0x00000000
md4._.round md4._.g, edx, edi, ebx, ecx, 6, 5, 0x5a827999 md4._.round md4._.f, edi, ebx, ecx, edx, 8, 3, 0x00000000
md4._.round md4._.g, ecx, edx, edi, ebx, 10, 9, 0x5a827999 md4._.round md4._.f, edx, edi, ebx, ecx, 9, 7, 0x00000000
md4._.round md4._.g, ebx, ecx, edx, edi, 14, 13, 0x5a827999 md4._.round md4._.f, ecx, edx, edi, ebx, 10, 11, 0x00000000
md4._.round md4._.g, edi, ebx, ecx, edx, 3, 3, 0x5a827999 md4._.round md4._.f, ebx, ecx, edx, edi, 11, 19, 0x00000000
md4._.round md4._.g, edx, edi, ebx, ecx, 7, 5, 0x5a827999 md4._.round md4._.f, edi, ebx, ecx, edx, 12, 3, 0x00000000
md4._.round md4._.g, ecx, edx, edi, ebx, 11, 9, 0x5a827999 md4._.round md4._.f, edx, edi, ebx, ecx, 13, 7, 0x00000000
md4._.round md4._.g, ebx, ecx, edx, edi, 15, 13, 0x5a827999 md4._.round md4._.f, ecx, edx, edi, ebx, 14, 11, 0x00000000
md4._.round md4._.f, ebx, ecx, edx, edi, 15, 19, 0x00000000
md4._.round md4._.h, edi, ebx, ecx, edx, 0, 3, 0x6ed9eba1
md4._.round md4._.h, edx, edi, ebx, ecx, 8, 9, 0x6ed9eba1 md4._.round md4._.g, edi, ebx, ecx, edx, 0, 3, 0x5a827999
md4._.round md4._.h, ecx, edx, edi, ebx, 4, 11, 0x6ed9eba1 md4._.round md4._.g, edx, edi, ebx, ecx, 4, 5, 0x5a827999
md4._.round md4._.h, ebx, ecx, edx, edi, 12, 15, 0x6ed9eba1 md4._.round md4._.g, ecx, edx, edi, ebx, 8, 9, 0x5a827999
md4._.round md4._.h, edi, ebx, ecx, edx, 2, 3, 0x6ed9eba1 md4._.round md4._.g, ebx, ecx, edx, edi, 12, 13, 0x5a827999
md4._.round md4._.h, edx, edi, ebx, ecx, 10, 9, 0x6ed9eba1 md4._.round md4._.g, edi, ebx, ecx, edx, 1, 3, 0x5a827999
md4._.round md4._.h, ecx, edx, edi, ebx, 6, 11, 0x6ed9eba1 md4._.round md4._.g, edx, edi, ebx, ecx, 5, 5, 0x5a827999
md4._.round md4._.h, ebx, ecx, edx, edi, 14, 15, 0x6ed9eba1 md4._.round md4._.g, ecx, edx, edi, ebx, 9, 9, 0x5a827999
md4._.round md4._.h, edi, ebx, ecx, edx, 1, 3, 0x6ed9eba1 md4._.round md4._.g, ebx, ecx, edx, edi, 13, 13, 0x5a827999
md4._.round md4._.h, edx, edi, ebx, ecx, 9, 9, 0x6ed9eba1 md4._.round md4._.g, edi, ebx, ecx, edx, 2, 3, 0x5a827999
md4._.round md4._.h, ecx, edx, edi, ebx, 5, 11, 0x6ed9eba1 md4._.round md4._.g, edx, edi, ebx, ecx, 6, 5, 0x5a827999
md4._.round md4._.h, ebx, ecx, edx, edi, 13, 15, 0x6ed9eba1 md4._.round md4._.g, ecx, edx, edi, ebx, 10, 9, 0x5a827999
md4._.round md4._.h, edi, ebx, ecx, edx, 3, 3, 0x6ed9eba1 md4._.round md4._.g, ebx, ecx, edx, edi, 14, 13, 0x5a827999
md4._.round md4._.h, edx, edi, ebx, ecx, 11, 9, 0x6ed9eba1 md4._.round md4._.g, edi, ebx, ecx, edx, 3, 3, 0x5a827999
md4._.round md4._.h, ecx, edx, edi, ebx, 7, 11, 0x6ed9eba1 md4._.round md4._.g, edx, edi, ebx, ecx, 7, 5, 0x5a827999
md4._.round md4._.h, ebx, ecx, edx, edi, 15, 15, 0x6ed9eba1 md4._.round md4._.g, ecx, edx, edi, ebx, 11, 9, 0x5a827999
md4._.round md4._.g, ebx, ecx, edx, edi, 15, 13, 0x5a827999
mov eax, [_hash]
add [eax + 0x0], edi md4._.round md4._.h, edi, ebx, ecx, edx, 0, 3, 0x6ed9eba1
add [eax + 0x4], ebx md4._.round md4._.h, edx, edi, ebx, ecx, 8, 9, 0x6ed9eba1
add [eax + 0x8], ecx md4._.round md4._.h, ecx, edx, edi, ebx, 4, 11, 0x6ed9eba1
add [eax + 0xc], edx md4._.round md4._.h, ebx, ecx, edx, edi, 12, 15, 0x6ed9eba1
md4._.round md4._.h, edi, ebx, ecx, edx, 2, 3, 0x6ed9eba1
ret md4._.round md4._.h, edx, edi, ebx, ecx, 10, 9, 0x6ed9eba1
endp md4._.round md4._.h, ecx, edx, edi, ebx, 6, 11, 0x6ed9eba1
md4._.round md4._.h, ebx, ecx, edx, edi, 14, 15, 0x6ed9eba1
md4._.round md4._.h, edi, ebx, ecx, edx, 1, 3, 0x6ed9eba1
proc md4.update _ctx, _msg, _size md4._.round md4._.h, edx, edi, ebx, ecx, 9, 9, 0x6ed9eba1
mov ebx, [_ctx] md4._.round md4._.h, ecx, edx, edi, ebx, 5, 11, 0x6ed9eba1
mov ecx, [_size] md4._.round md4._.h, ebx, ecx, edx, edi, 13, 15, 0x6ed9eba1
add [ebx + ctx_md4.msglen_0], ecx md4._.round md4._.h, edi, ebx, ecx, edx, 3, 3, 0x6ed9eba1
adc [ebx + ctx_md4.msglen_1], 0 md4._.round md4._.h, edx, edi, ebx, ecx, 11, 9, 0x6ed9eba1
md4._.round md4._.h, ecx, edx, edi, ebx, 7, 11, 0x6ed9eba1
.next_block: md4._.round md4._.h, ebx, ecx, edx, edi, 15, 15, 0x6ed9eba1
mov ebx, [_ctx]
mov esi, [_msg] mov eax, [_hash]
mov eax, [ebx + ctx_md4.index] add [eax + 0x0], edi
and eax, MD4_BLOCK_SIZE-1 add [eax + 0x4], ebx
jnz .copy_to_buf add [eax + 0x8], ecx
test esi, MD4_ALIGN_MASK add [eax + 0xc], edx
jnz .copy_to_buf
.no_copy: ret
; data is aligned, hash it in place without copying endp
mov ebx, [_ctx]
cmp [_size], MD4_BLOCK_SIZE
jb .copy_quit proc md4.update _ctx, _msg, _size
lea eax, [ebx + ctx_md4.hash] mov ebx, [_ctx]
stdcall md4._.block, eax mov ecx, [_size]
sub [_size], MD4_BLOCK_SIZE add [ebx + ctx_md4.msglen_0], ecx
add esi, MD4_BLOCK_SIZE adc [ebx + ctx_md4.msglen_1], 0
jmp .no_copy
.next_block:
.copy_to_buf: mov ebx, [_ctx]
lea edi, [ebx + ctx_md4.block] mov esi, [_msg]
add edi, eax mov eax, [ebx + ctx_md4.index]
mov ecx, MD4_BLOCK_SIZE and eax, MD4_BLOCK_SIZE-1
sub ecx, eax jnz .copy_to_buf
cmp [_size], ecx test esi, MD4_ALIGN_MASK
jb .copy_quit jnz .copy_to_buf
sub [_size], ecx .no_copy:
add [_msg], ecx ; data is aligned, hash it in place without copying
add [ebx + ctx_md4.index], ecx mov ebx, [_ctx]
rep movsb cmp [_size], MD4_BLOCK_SIZE
lea eax, [ebx + ctx_md4.hash] jb .copy_quit
lea esi, [ebx + ctx_md4.block] lea eax, [ebx + ctx_md4.hash]
stdcall md4._.block, eax stdcall md4._.block, eax
jmp .next_block sub [_size], MD4_BLOCK_SIZE
add esi, MD4_BLOCK_SIZE
.copy_quit: jmp .no_copy
mov ebx, [_ctx]
lea edi, [ebx + ctx_md4.block] .copy_to_buf:
mov eax, [ebx + ctx_md4.index] lea edi, [ebx + ctx_md4.block]
and eax, MD4_BLOCK_SIZE-1 add edi, eax
add edi, eax mov ecx, MD4_BLOCK_SIZE
mov ecx, [_size] sub ecx, eax
add [ebx + ctx_md4.index], ecx cmp [_size], ecx
rep movsb jb .copy_quit
.quit: sub [_size], ecx
ret add [_msg], ecx
endp add [ebx + ctx_md4.index], ecx
rep movsb
lea eax, [ebx + ctx_md4.hash]
proc md4.final _ctx lea esi, [ebx + ctx_md4.block]
mov ebx, [_ctx] stdcall md4._.block, eax
lea edi, [ebx + ctx_md4.block] jmp .next_block
mov ecx, [ebx + ctx_md4.msglen_0]
and ecx, MD4_BLOCK_SIZE-1 .copy_quit:
add edi, ecx mov ebx, [_ctx]
mov byte[edi], 0x80 lea edi, [ebx + ctx_md4.block]
inc edi mov eax, [ebx + ctx_md4.index]
neg ecx and eax, MD4_BLOCK_SIZE-1
add ecx, MD4_BLOCK_SIZE add edi, eax
cmp ecx, 8 mov ecx, [_size]
ja .last add [ebx + ctx_md4.index], ecx
rep movsb
dec ecx .quit:
xor eax, eax ret
rep stosb endp
lea esi, [ebx + ctx_md4.block]
lea eax, [ebx + ctx_md4.hash]
stdcall md4._.block, eax proc md4.final _ctx
mov ebx, [_ctx] mov ebx, [_ctx]
lea edi, [ebx + ctx_md4.block] lea edi, [ebx + ctx_md4.block]
mov ecx, MD4_BLOCK_SIZE+1 mov ecx, [ebx + ctx_md4.msglen_0]
.last: and ecx, MD4_BLOCK_SIZE-1
dec ecx add edi, ecx
sub ecx, 8 mov byte[edi], 0x80
xor eax, eax inc edi
rep stosb neg ecx
mov eax, [ebx + ctx_md4.msglen_0] add ecx, MD4_BLOCK_SIZE
mov edx, [ebx + ctx_md4.msglen_1] cmp ecx, 8
shld edx, eax, 3 ja .last
shl eax, 3
mov dword[edi], eax dec ecx
mov dword[edi+4], edx xor eax, eax
lea esi, [ebx + ctx_md4.block] rep stosb
lea eax, [ebx + ctx_md4.hash] lea esi, [ebx + ctx_md4.block]
stdcall md4._.block, eax lea eax, [ebx + ctx_md4.hash]
stdcall md4._.block, eax
ret mov ebx, [_ctx]
endp lea edi, [ebx + ctx_md4.block]
mov ecx, MD4_BLOCK_SIZE+1
.last:
align MD4_ALIGN dec ecx
sub ecx, 8
md4._.hash_init dd 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 xor eax, eax
rep stosb
mov eax, [ebx + ctx_md4.msglen_0]
mov edx, [ebx + ctx_md4.msglen_1]
shld edx, eax, 3
shl eax, 3
mov dword[edi], eax
mov dword[edi+4], edx
lea esi, [ebx + ctx_md4.block]
lea eax, [ebx + ctx_md4.hash]
stdcall md4._.block, eax
ret
endp
proc md4.oneshot _ctx, _data, _len
stdcall md4.init, [_ctx]
stdcall md4.update, [_ctx], [_data], [_len]
stdcall md4.final, [_ctx]
ret
endp
iglobal
align MD4_ALIGN
md4._.hash_init dd 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
endg

View File

@ -1,265 +1,291 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2012-2013,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2012-2013,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
macro md5._.f b, c, d MD5_HASH_SIZE = 16
{ MD5_BLOCK_SIZE = 64
push c
xor c, d MD5_ALIGN = 4
and b, c MD5_ALIGN_MASK = MD5_ALIGN - 1
xor b, d
pop c struct ctx_md5
} hash rb MD5_HASH_SIZE
block rb MD5_BLOCK_SIZE
macro md5._.g b, c, d index rd 1
{ msglen_0 rd 1
push c d msglen_1 rd 1
and b, d ends
not d
and c, d if defined sizeof.crash_ctx
or b, c assert sizeof.crash_ctx >= sizeof.ctx_md5
pop d c end if
}
macro md5._.f b, c, d
macro md5._.h b, c, d {
{ push c
xor b, c xor c, d
xor b, d and b, c
} xor b, d
pop c
macro md5._.i b, c, d }
{
push d macro md5._.g b, c, d
not d {
or b, d push c d
xor b, c and b, d
pop d not d
} and c, d
or b, c
macro md5._.round func, a, b, c, d, index, shift, ac pop d c
{ }
push b
func b, c, d macro md5._.h b, c, d
lea a, [a + b + ac] {
add a, [esi + index*4] xor b, c
rol a, shift xor b, d
pop b }
add a, b
} macro md5._.i b, c, d
{
push d
proc md5.init _ctx not d
mov ebx, [_ctx] or b, d
lea edi, [ebx + ctx_md5.hash] xor b, c
mov esi, md5._.hash_init pop d
mov ecx, MD5_HASH_SIZE/4 }
rep movsd
xor eax, eax macro md5._.round func, a, b, c, d, index, shift, ac
mov [ebx + ctx_md5.index], eax {
mov [ebx + ctx_md5.msglen_0], eax push b
mov [ebx + ctx_md5.msglen_1], eax func b, c, d
ret lea a, [a + b + ac]
endp add a, [esi + index*4]
rol a, shift
pop b
proc md5._.block _hash add a, b
}
mov edi, [_hash]
mov eax, [edi + 0x0]
mov ebx, [edi + 0x4] proc md5.init _ctx
mov ecx, [edi + 0x8] mov ebx, [_ctx]
mov edx, [edi + 0xc] lea edi, [ebx + ctx_md5.hash]
mov esi, md5._.hash_init
md5._.round md5._.f, eax, ebx, ecx, edx, 0, 7, 0xd76aa478 mov ecx, MD5_HASH_SIZE/4
md5._.round md5._.f, edx, eax, ebx, ecx, 1, 12, 0xe8c7b756 rep movsd
md5._.round md5._.f, ecx, edx, eax, ebx, 2, 17, 0x242070db xor eax, eax
md5._.round md5._.f, ebx, ecx, edx, eax, 3, 22, 0xc1bdceee mov [ebx + ctx_md5.index], eax
md5._.round md5._.f, eax, ebx, ecx, edx, 4, 7, 0xf57c0faf mov [ebx + ctx_md5.msglen_0], eax
md5._.round md5._.f, edx, eax, ebx, ecx, 5, 12, 0x4787c62a mov [ebx + ctx_md5.msglen_1], eax
md5._.round md5._.f, ecx, edx, eax, ebx, 6, 17, 0xa8304613 ret
md5._.round md5._.f, ebx, ecx, edx, eax, 7, 22, 0xfd469501 endp
md5._.round md5._.f, eax, ebx, ecx, edx, 8, 7, 0x698098d8
md5._.round md5._.f, edx, eax, ebx, ecx, 9, 12, 0x8b44f7af
md5._.round md5._.f, ecx, edx, eax, ebx, 10, 17, 0xffff5bb1 proc md5._.block _hash
md5._.round md5._.f, ebx, ecx, edx, eax, 11, 22, 0x895cd7be
md5._.round md5._.f, eax, ebx, ecx, edx, 12, 7, 0x6b901122 mov edi, [_hash]
md5._.round md5._.f, edx, eax, ebx, ecx, 13, 12, 0xfd987193 mov eax, [edi + 0x0]
md5._.round md5._.f, ecx, edx, eax, ebx, 14, 17, 0xa679438e mov ebx, [edi + 0x4]
md5._.round md5._.f, ebx, ecx, edx, eax, 15, 22, 0x49b40821 mov ecx, [edi + 0x8]
mov edx, [edi + 0xc]
md5._.round md5._.g, eax, ebx, ecx, edx, 1, 5, 0xf61e2562
md5._.round md5._.g, edx, eax, ebx, ecx, 6, 9, 0xc040b340 md5._.round md5._.f, eax, ebx, ecx, edx, 0, 7, 0xd76aa478
md5._.round md5._.g, ecx, edx, eax, ebx, 11, 14, 0x265e5a51 md5._.round md5._.f, edx, eax, ebx, ecx, 1, 12, 0xe8c7b756
md5._.round md5._.g, ebx, ecx, edx, eax, 0, 20, 0xe9b6c7aa md5._.round md5._.f, ecx, edx, eax, ebx, 2, 17, 0x242070db
md5._.round md5._.g, eax, ebx, ecx, edx, 5, 5, 0xd62f105d md5._.round md5._.f, ebx, ecx, edx, eax, 3, 22, 0xc1bdceee
md5._.round md5._.g, edx, eax, ebx, ecx, 10, 9, 0x02441453 md5._.round md5._.f, eax, ebx, ecx, edx, 4, 7, 0xf57c0faf
md5._.round md5._.g, ecx, edx, eax, ebx, 15, 14, 0xd8a1e681 md5._.round md5._.f, edx, eax, ebx, ecx, 5, 12, 0x4787c62a
md5._.round md5._.g, ebx, ecx, edx, eax, 4, 20, 0xe7d3fbc8 md5._.round md5._.f, ecx, edx, eax, ebx, 6, 17, 0xa8304613
md5._.round md5._.g, eax, ebx, ecx, edx, 9, 5, 0x21e1cde6 md5._.round md5._.f, ebx, ecx, edx, eax, 7, 22, 0xfd469501
md5._.round md5._.g, edx, eax, ebx, ecx, 14, 9, 0xc33707d6 md5._.round md5._.f, eax, ebx, ecx, edx, 8, 7, 0x698098d8
md5._.round md5._.g, ecx, edx, eax, ebx, 3, 14, 0xf4d50d87 md5._.round md5._.f, edx, eax, ebx, ecx, 9, 12, 0x8b44f7af
md5._.round md5._.g, ebx, ecx, edx, eax, 8, 20, 0x455a14ed md5._.round md5._.f, ecx, edx, eax, ebx, 10, 17, 0xffff5bb1
md5._.round md5._.g, eax, ebx, ecx, edx, 13, 5, 0xa9e3e905 md5._.round md5._.f, ebx, ecx, edx, eax, 11, 22, 0x895cd7be
md5._.round md5._.g, edx, eax, ebx, ecx, 2, 9, 0xfcefa3f8 md5._.round md5._.f, eax, ebx, ecx, edx, 12, 7, 0x6b901122
md5._.round md5._.g, ecx, edx, eax, ebx, 7, 14, 0x676f02d9 md5._.round md5._.f, edx, eax, ebx, ecx, 13, 12, 0xfd987193
md5._.round md5._.g, ebx, ecx, edx, eax, 12, 20, 0x8d2a4c8a md5._.round md5._.f, ecx, edx, eax, ebx, 14, 17, 0xa679438e
md5._.round md5._.f, ebx, ecx, edx, eax, 15, 22, 0x49b40821
md5._.round md5._.h, eax, ebx, ecx, edx, 5, 4, 0xfffa3942
md5._.round md5._.h, edx, eax, ebx, ecx, 8, 11, 0x8771f681 md5._.round md5._.g, eax, ebx, ecx, edx, 1, 5, 0xf61e2562
md5._.round md5._.h, ecx, edx, eax, ebx, 11, 16, 0x6d9d6122 md5._.round md5._.g, edx, eax, ebx, ecx, 6, 9, 0xc040b340
md5._.round md5._.h, ebx, ecx, edx, eax, 14, 23, 0xfde5380c md5._.round md5._.g, ecx, edx, eax, ebx, 11, 14, 0x265e5a51
md5._.round md5._.h, eax, ebx, ecx, edx, 1, 4, 0xa4beea44 md5._.round md5._.g, ebx, ecx, edx, eax, 0, 20, 0xe9b6c7aa
md5._.round md5._.h, edx, eax, ebx, ecx, 4, 11, 0x4bdecfa9 md5._.round md5._.g, eax, ebx, ecx, edx, 5, 5, 0xd62f105d
md5._.round md5._.h, ecx, edx, eax, ebx, 7, 16, 0xf6bb4b60 md5._.round md5._.g, edx, eax, ebx, ecx, 10, 9, 0x02441453
md5._.round md5._.h, ebx, ecx, edx, eax, 10, 23, 0xbebfbc70 md5._.round md5._.g, ecx, edx, eax, ebx, 15, 14, 0xd8a1e681
md5._.round md5._.h, eax, ebx, ecx, edx, 13, 4, 0x289b7ec6 md5._.round md5._.g, ebx, ecx, edx, eax, 4, 20, 0xe7d3fbc8
md5._.round md5._.h, edx, eax, ebx, ecx, 0, 11, 0xeaa127fa md5._.round md5._.g, eax, ebx, ecx, edx, 9, 5, 0x21e1cde6
md5._.round md5._.h, ecx, edx, eax, ebx, 3, 16, 0xd4ef3085 md5._.round md5._.g, edx, eax, ebx, ecx, 14, 9, 0xc33707d6
md5._.round md5._.h, ebx, ecx, edx, eax, 6, 23, 0x04881d05 md5._.round md5._.g, ecx, edx, eax, ebx, 3, 14, 0xf4d50d87
md5._.round md5._.h, eax, ebx, ecx, edx, 9, 4, 0xd9d4d039 md5._.round md5._.g, ebx, ecx, edx, eax, 8, 20, 0x455a14ed
md5._.round md5._.h, edx, eax, ebx, ecx, 12, 11, 0xe6db99e5 md5._.round md5._.g, eax, ebx, ecx, edx, 13, 5, 0xa9e3e905
md5._.round md5._.h, ecx, edx, eax, ebx, 15, 16, 0x1fa27cf8 md5._.round md5._.g, edx, eax, ebx, ecx, 2, 9, 0xfcefa3f8
md5._.round md5._.h, ebx, ecx, edx, eax, 2, 23, 0xc4ac5665 md5._.round md5._.g, ecx, edx, eax, ebx, 7, 14, 0x676f02d9
md5._.round md5._.g, ebx, ecx, edx, eax, 12, 20, 0x8d2a4c8a
md5._.round md5._.i, eax, ebx, ecx, edx, 0, 6, 0xf4292244
md5._.round md5._.i, edx, eax, ebx, ecx, 7, 10, 0x432aff97 md5._.round md5._.h, eax, ebx, ecx, edx, 5, 4, 0xfffa3942
md5._.round md5._.i, ecx, edx, eax, ebx, 14, 15, 0xab9423a7 md5._.round md5._.h, edx, eax, ebx, ecx, 8, 11, 0x8771f681
md5._.round md5._.i, ebx, ecx, edx, eax, 5, 21, 0xfc93a039 md5._.round md5._.h, ecx, edx, eax, ebx, 11, 16, 0x6d9d6122
md5._.round md5._.i, eax, ebx, ecx, edx, 12, 6, 0x655b59c3 md5._.round md5._.h, ebx, ecx, edx, eax, 14, 23, 0xfde5380c
md5._.round md5._.i, edx, eax, ebx, ecx, 3, 10, 0x8f0ccc92 md5._.round md5._.h, eax, ebx, ecx, edx, 1, 4, 0xa4beea44
md5._.round md5._.i, ecx, edx, eax, ebx, 10, 15, 0xffeff47d md5._.round md5._.h, edx, eax, ebx, ecx, 4, 11, 0x4bdecfa9
md5._.round md5._.i, ebx, ecx, edx, eax, 1, 21, 0x85845dd1 md5._.round md5._.h, ecx, edx, eax, ebx, 7, 16, 0xf6bb4b60
md5._.round md5._.i, eax, ebx, ecx, edx, 8, 6, 0x6fa87e4f md5._.round md5._.h, ebx, ecx, edx, eax, 10, 23, 0xbebfbc70
md5._.round md5._.i, edx, eax, ebx, ecx, 15, 10, 0xfe2ce6e0 md5._.round md5._.h, eax, ebx, ecx, edx, 13, 4, 0x289b7ec6
md5._.round md5._.i, ecx, edx, eax, ebx, 6, 15, 0xa3014314 md5._.round md5._.h, edx, eax, ebx, ecx, 0, 11, 0xeaa127fa
md5._.round md5._.i, ebx, ecx, edx, eax, 13, 21, 0x4e0811a1 md5._.round md5._.h, ecx, edx, eax, ebx, 3, 16, 0xd4ef3085
md5._.round md5._.i, eax, ebx, ecx, edx, 4, 6, 0xf7537e82 md5._.round md5._.h, ebx, ecx, edx, eax, 6, 23, 0x04881d05
md5._.round md5._.i, edx, eax, ebx, ecx, 11, 10, 0xbd3af235 md5._.round md5._.h, eax, ebx, ecx, edx, 9, 4, 0xd9d4d039
md5._.round md5._.i, ecx, edx, eax, ebx, 2, 15, 0x2ad7d2bb md5._.round md5._.h, edx, eax, ebx, ecx, 12, 11, 0xe6db99e5
md5._.round md5._.i, ebx, ecx, edx, eax, 9, 21, 0xeb86d391 md5._.round md5._.h, ecx, edx, eax, ebx, 15, 16, 0x1fa27cf8
md5._.round md5._.h, ebx, ecx, edx, eax, 2, 23, 0xc4ac5665
mov edi, [_hash]
add [edi + 0x0], eax md5._.round md5._.i, eax, ebx, ecx, edx, 0, 6, 0xf4292244
add [edi + 0x4], ebx md5._.round md5._.i, edx, eax, ebx, ecx, 7, 10, 0x432aff97
add [edi + 0x8], ecx md5._.round md5._.i, ecx, edx, eax, ebx, 14, 15, 0xab9423a7
add [edi + 0xc], edx md5._.round md5._.i, ebx, ecx, edx, eax, 5, 21, 0xfc93a039
md5._.round md5._.i, eax, ebx, ecx, edx, 12, 6, 0x655b59c3
ret md5._.round md5._.i, edx, eax, ebx, ecx, 3, 10, 0x8f0ccc92
endp md5._.round md5._.i, ecx, edx, eax, ebx, 10, 15, 0xffeff47d
md5._.round md5._.i, ebx, ecx, edx, eax, 1, 21, 0x85845dd1
md5._.round md5._.i, eax, ebx, ecx, edx, 8, 6, 0x6fa87e4f
proc md5.update _ctx, _msg, _size md5._.round md5._.i, edx, eax, ebx, ecx, 15, 10, 0xfe2ce6e0
mov ebx, [_ctx] md5._.round md5._.i, ecx, edx, eax, ebx, 6, 15, 0xa3014314
mov ecx, [_size] md5._.round md5._.i, ebx, ecx, edx, eax, 13, 21, 0x4e0811a1
add [ebx + ctx_md5.msglen_0], ecx md5._.round md5._.i, eax, ebx, ecx, edx, 4, 6, 0xf7537e82
adc [ebx + ctx_md5.msglen_1], 0 md5._.round md5._.i, edx, eax, ebx, ecx, 11, 10, 0xbd3af235
md5._.round md5._.i, ecx, edx, eax, ebx, 2, 15, 0x2ad7d2bb
.next_block: md5._.round md5._.i, ebx, ecx, edx, eax, 9, 21, 0xeb86d391
mov ebx, [_ctx]
mov esi, [_msg] mov edi, [_hash]
mov eax, [ebx + ctx_md5.index] add [edi + 0x0], eax
and eax, MD5_BLOCK_SIZE-1 add [edi + 0x4], ebx
jnz .copy_to_buf add [edi + 0x8], ecx
test esi, MD5_ALIGN_MASK add [edi + 0xc], edx
jnz .copy_to_buf
.no_copy: ret
; data is aligned, hash it in place without copying endp
mov ebx, [_ctx]
cmp [_size], MD5_BLOCK_SIZE
jb .copy_quit proc md5.update _ctx, _msg, _size
lea eax, [ebx + ctx_md5.hash] mov ebx, [_ctx]
stdcall md5._.block, eax mov ecx, [_size]
sub [_size], MD5_BLOCK_SIZE add [ebx + ctx_md5.msglen_0], ecx
add esi, MD5_BLOCK_SIZE adc [ebx + ctx_md5.msglen_1], 0
jmp .no_copy
.next_block:
.copy_to_buf: mov ebx, [_ctx]
lea edi, [ebx + ctx_md5.block] mov esi, [_msg]
add edi, eax mov eax, [ebx + ctx_md5.index]
mov ecx, MD5_BLOCK_SIZE and eax, MD5_BLOCK_SIZE-1
sub ecx, eax jnz .copy_to_buf
cmp [_size], ecx test esi, MD5_ALIGN_MASK
jb .copy_quit jnz .copy_to_buf
sub [_size], ecx .no_copy:
add [_msg], ecx ; data is aligned, hash it in place without copying
add [ebx + ctx_md5.index], ecx mov ebx, [_ctx]
rep movsb cmp [_size], MD5_BLOCK_SIZE
lea eax, [ebx + ctx_md5.hash] jb .copy_quit
lea esi, [ebx + ctx_md5.block] lea eax, [ebx + ctx_md5.hash]
stdcall md5._.block, eax stdcall md5._.block, eax
jmp .next_block sub [_size], MD5_BLOCK_SIZE
add esi, MD5_BLOCK_SIZE
.copy_quit: jmp .no_copy
mov ebx, [_ctx]
lea edi, [ebx + ctx_md5.block] .copy_to_buf:
mov eax, [ebx + ctx_md5.index] lea edi, [ebx + ctx_md5.block]
and eax, MD5_BLOCK_SIZE-1 add edi, eax
add edi, eax mov ecx, MD5_BLOCK_SIZE
mov ecx, [_size] sub ecx, eax
add [ebx + ctx_md5.index], ecx cmp [_size], ecx
rep movsb jb .copy_quit
.quit: sub [_size], ecx
add [_msg], ecx
ret add [ebx + ctx_md5.index], ecx
endp rep movsb
lea eax, [ebx + ctx_md5.hash]
lea esi, [ebx + ctx_md5.block]
proc md5.final _ctx stdcall md5._.block, eax
mov ebx, [_ctx] jmp .next_block
lea edi, [ebx + ctx_md5.block]
mov ecx, [ebx + ctx_md5.msglen_0] .copy_quit:
and ecx, MD5_BLOCK_SIZE-1 mov ebx, [_ctx]
add edi, ecx lea edi, [ebx + ctx_md5.block]
mov byte[edi], 0x80 mov eax, [ebx + ctx_md5.index]
inc edi and eax, MD5_BLOCK_SIZE-1
neg ecx add edi, eax
add ecx, MD5_BLOCK_SIZE mov ecx, [_size]
cmp ecx, 8 add [ebx + ctx_md5.index], ecx
ja .last rep movsb
.quit:
dec ecx
xor eax, eax ret
rep stosb endp
lea esi, [ebx + ctx_md5.block]
lea eax, [ebx + ctx_md5.hash]
stdcall md5._.block, eax proc md5.final _ctx
mov ebx, [_ctx] mov ebx, [_ctx]
lea edi, [ebx + ctx_md5.block] lea edi, [ebx + ctx_md5.block]
mov ecx, MD5_BLOCK_SIZE+1 mov ecx, [ebx + ctx_md5.msglen_0]
.last: and ecx, MD5_BLOCK_SIZE-1
dec ecx add edi, ecx
sub ecx, 8 mov byte[edi], 0x80
xor eax, eax inc edi
rep stosb neg ecx
mov eax, [ebx + ctx_md5.msglen_0] add ecx, MD5_BLOCK_SIZE
mov edx, [ebx + ctx_md5.msglen_1] cmp ecx, 8
shld edx, eax, 3 ja .last
shl eax, 3
mov dword[edi], eax dec ecx
mov dword[edi+4], edx xor eax, eax
lea esi, [ebx + ctx_md5.block] rep stosb
lea eax, [ebx + ctx_md5.hash] lea esi, [ebx + ctx_md5.block]
stdcall md5._.block, eax lea eax, [ebx + ctx_md5.hash]
stdcall md5._.block, eax
ret mov ebx, [_ctx]
endp lea edi, [ebx + ctx_md5.block]
mov ecx, MD5_BLOCK_SIZE+1
.last:
align MD5_ALIGN dec ecx
sub ecx, 8
md5._.hash_init dd 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 xor eax, eax
rep stosb
mov eax, [ebx + ctx_md5.msglen_0]
mov edx, [ebx + ctx_md5.msglen_1]
shld edx, eax, 3
shl eax, 3
mov dword[edi], eax
mov dword[edi+4], edx
lea esi, [ebx + ctx_md5.block]
lea eax, [ebx + ctx_md5.hash]
stdcall md5._.block, eax
ret
endp
proc md5.oneshot _ctx, _data, _len
stdcall md5.init, [_ctx]
stdcall md5.update, [_ctx], [_data], [_len]
stdcall md5.final, [_ctx]
ret
endp
iglobal
align MD5_ALIGN
md5._.hash_init dd 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
endg

View File

@ -1,273 +1,299 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2012-2013,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2012-2013,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
proc sha1._.f SHA1_HASH_SIZE = 20
push ebx ecx edx SHA1_BLOCK_SIZE = 64
xor ecx, edx
and ebx, ecx SHA1_ALIGN = 4
xor ebx, edx SHA1_ALIGN_MASK = SHA1_ALIGN - 1
mov esi, ebx
pop edx ecx ebx struct ctx_sha1
ret hash rb SHA1_HASH_SIZE
endp block rb SHA1_BLOCK_SIZE
index rd 1
proc sha1._.g msglen_0 rd 1
push ebx ecx edx msglen_1 rd 1
xor ebx, ecx ends
xor ebx, edx
mov esi, ebx if defined sizeof.crash_ctx
pop edx ecx ebx assert sizeof.crash_ctx >= sizeof.ctx_sha1
ret end if
endp
proc sha1._.f
proc sha1._.h push ebx ecx edx
push ebx ecx edx xor ecx, edx
mov esi, ebx and ebx, ecx
and ebx, ecx xor ebx, edx
and ecx, edx mov esi, ebx
and esi, edx pop edx ecx ebx
or ebx, ecx ret
or esi, ebx endp
pop edx ecx ebx
ret proc sha1._.g
endp push ebx ecx edx
xor ebx, ecx
macro sha1._.round f, k, c xor ebx, edx
{ mov esi, ebx
mov esi, eax pop edx ecx ebx
rol esi, 5 ret
mov [temp], esi endp
call f
proc sha1._.h
add esi, edi push ebx ecx edx
add [temp], esi mov esi, ebx
mov esi, [w + (c)*4] and ebx, ecx
add esi, k and ecx, edx
add [temp], esi and esi, edx
or ebx, ecx
mov edi, edx or esi, ebx
mov edx, ecx pop edx ecx ebx
mov ecx, ebx ret
rol ecx, 30 endp
mov ebx, eax
mov eax, [temp] macro sha1._.round f, k, c
} {
mov esi, eax
rol esi, 5
proc sha1.init _ctx mov [temp], esi
mov ebx, [_ctx] call f
lea edi, [ebx + ctx_sha1.hash]
mov esi, sha1._.hash_init add esi, edi
mov ecx, SHA1_HASH_SIZE/4 add [temp], esi
rep movsd mov esi, [w + (c)*4]
xor eax, eax add esi, k
mov [ebx + ctx_sha1.index], eax add [temp], esi
mov [ebx + ctx_sha1.msglen_0], eax
mov [ebx + ctx_sha1.msglen_1], eax mov edi, edx
ret mov edx, ecx
endp mov ecx, ebx
rol ecx, 30
mov ebx, eax
proc sha1._.block _hash mov eax, [temp]
locals }
temp rd 1
w rd 80
endl proc sha1.init _ctx
lea edi, [w] mov ebx, [_ctx]
xor ecx, ecx lea edi, [ebx + ctx_sha1.hash]
@@: mov esi, sha1._.hash_init
mov eax, [esi] mov ecx, SHA1_HASH_SIZE/4
add esi, 4 rep movsd
bswap eax xor eax, eax
mov [edi], eax mov [ebx + ctx_sha1.index], eax
add edi, 4 mov [ebx + ctx_sha1.msglen_0], eax
add ecx, 1 mov [ebx + ctx_sha1.msglen_1], eax
cmp ecx, 16 ret
jne @b endp
@@:
mov eax, [w + (ecx - 3)*4]
xor eax, [w + (ecx - 8)*4] proc sha1._.block _hash
xor eax, [w + (ecx - 14)*4] locals
xor eax, [w + (ecx - 16)*4] temp rd 1
rol eax, 1 w rd 80
mov [w + ecx*4], eax endl
add ecx, 1 lea edi, [w]
cmp ecx, 80 xor ecx, ecx
jne @b @@:
mov eax, [esi]
mov edi, [_hash] add esi, 4
mov eax, [edi + 0x00] bswap eax
mov ebx, [edi + 0x04] mov [edi], eax
mov ecx, [edi + 0x08] add edi, 4
mov edx, [edi + 0x0c] add ecx, 1
mov edi, [edi + 0x10] cmp ecx, 16
jne @b
push esi @@:
mov eax, [w + (ecx - 3)*4]
repeat 20 xor eax, [w + (ecx - 8)*4]
sha1._.round sha1._.f, 0x5a827999, %-1 xor eax, [w + (ecx - 14)*4]
end repeat xor eax, [w + (ecx - 16)*4]
rol eax, 1
repeat 20 mov [w + ecx*4], eax
sha1._.round sha1._.g, 0x6ed9eba1, %-1+20 add ecx, 1
end repeat cmp ecx, 80
jne @b
repeat 20
sha1._.round sha1._.h, 0x8f1bbcdc, %-1+40 mov edi, [_hash]
end repeat mov eax, [edi + 0x00]
mov ebx, [edi + 0x04]
repeat 20 mov ecx, [edi + 0x08]
sha1._.round sha1._.g, 0xca62c1d6, %-1+60 mov edx, [edi + 0x0c]
end repeat mov edi, [edi + 0x10]
pop esi push esi
mov [temp], edi repeat 20
mov edi, [_hash] sha1._.round sha1._.f, 0x5a827999, %-1
add [edi + 0x00], eax end repeat
add [edi + 0x04], ebx
add [edi + 0x08], ecx repeat 20
add [edi + 0x0c], edx sha1._.round sha1._.g, 0x6ed9eba1, %-1+20
mov eax, [temp] end repeat
add [edi + 0x10], eax
repeat 20
ret sha1._.round sha1._.h, 0x8f1bbcdc, %-1+40
endp end repeat
repeat 20
proc sha1.update _ctx, _msg, _size sha1._.round sha1._.g, 0xca62c1d6, %-1+60
mov ebx, [_ctx] end repeat
mov ecx, [_size]
add [ebx + ctx_sha1.msglen_0], ecx pop esi
adc [ebx + ctx_sha1.msglen_1], 0
mov [temp], edi
.next_block: mov edi, [_hash]
mov ebx, [_ctx] add [edi + 0x00], eax
mov esi, [_msg] add [edi + 0x04], ebx
mov eax, [ebx + ctx_sha1.index] add [edi + 0x08], ecx
and eax, SHA1_BLOCK_SIZE-1 add [edi + 0x0c], edx
jnz .copy_to_buf mov eax, [temp]
test esi, SHA1_ALIGN_MASK add [edi + 0x10], eax
jnz .copy_to_buf
.no_copy: ret
; data is aligned, hash it in place without copying endp
mov ebx, [_ctx]
cmp [_size], SHA1_BLOCK_SIZE
jb .copy_quit proc sha1.update _ctx, _msg, _size
lea eax, [ebx + ctx_sha1.hash] mov ebx, [_ctx]
stdcall sha1._.block, eax mov ecx, [_size]
sub [_size], SHA1_BLOCK_SIZE add [ebx + ctx_sha1.msglen_0], ecx
; add esi, SHA1_BLOCK_SIZE ; FIXME adc [ebx + ctx_sha1.msglen_1], 0
jmp .no_copy
.next_block:
.copy_to_buf: mov ebx, [_ctx]
lea edi, [ebx + ctx_sha1.block] mov esi, [_msg]
add edi, eax mov eax, [ebx + ctx_sha1.index]
mov ecx, SHA1_BLOCK_SIZE and eax, SHA1_BLOCK_SIZE-1
sub ecx, eax jnz .copy_to_buf
cmp [_size], ecx test esi, SHA1_ALIGN_MASK
jb .copy_quit jnz .copy_to_buf
sub [_size], ecx .no_copy:
add [_msg], ecx ; data is aligned, hash it in place without copying
add [ebx + ctx_sha1.index], ecx mov ebx, [_ctx]
rep movsb cmp [_size], SHA1_BLOCK_SIZE
lea eax, [ebx + ctx_sha1.hash] jb .copy_quit
lea esi, [ebx + ctx_sha1.block] lea eax, [ebx + ctx_sha1.hash]
stdcall sha1._.block, eax stdcall sha1._.block, eax
jmp .next_block sub [_size], SHA1_BLOCK_SIZE
; add esi, SHA1_BLOCK_SIZE ; FIXME
.copy_quit: jmp .no_copy
mov ebx, [_ctx]
lea edi, [ebx + ctx_sha1.block] .copy_to_buf:
mov eax, [ebx + ctx_sha1.index] lea edi, [ebx + ctx_sha1.block]
and eax, SHA1_BLOCK_SIZE-1 add edi, eax
add edi, eax mov ecx, SHA1_BLOCK_SIZE
mov ecx, [_size] sub ecx, eax
add [ebx + ctx_sha1.index], ecx cmp [_size], ecx
rep movsb jb .copy_quit
.quit: sub [_size], ecx
add [_msg], ecx
ret add [ebx + ctx_sha1.index], ecx
endp rep movsb
lea eax, [ebx + ctx_sha1.hash]
lea esi, [ebx + ctx_sha1.block]
proc sha1.final _ctx stdcall sha1._.block, eax
mov ebx, [_ctx] jmp .next_block
lea edi, [ebx + ctx_sha1.block]
mov ecx, [ebx + ctx_sha1.msglen_0] .copy_quit:
and ecx, SHA1_BLOCK_SIZE-1 mov ebx, [_ctx]
add edi, ecx lea edi, [ebx + ctx_sha1.block]
mov byte[edi], 0x80 mov eax, [ebx + ctx_sha1.index]
inc edi and eax, SHA1_BLOCK_SIZE-1
neg ecx add edi, eax
add ecx, SHA1_BLOCK_SIZE mov ecx, [_size]
cmp ecx, 8 add [ebx + ctx_sha1.index], ecx
ja .last rep movsb
.quit:
dec ecx
xor eax, eax ret
rep stosb endp
lea esi, [ebx + ctx_sha1.block]
lea eax, [ebx + ctx_sha1.hash]
stdcall sha1._.block, eax proc sha1.final _ctx
mov ebx, [_ctx] mov ebx, [_ctx]
lea edi, [ebx + ctx_sha1.block] lea edi, [ebx + ctx_sha1.block]
mov ecx, SHA1_BLOCK_SIZE+1 mov ecx, [ebx + ctx_sha1.msglen_0]
.last: and ecx, SHA1_BLOCK_SIZE-1
dec ecx add edi, ecx
sub ecx, 8 mov byte[edi], 0x80
xor eax, eax inc edi
rep stosb neg ecx
mov eax, [ebx + ctx_sha1.msglen_0] add ecx, SHA1_BLOCK_SIZE
mov edx, [ebx + ctx_sha1.msglen_1] cmp ecx, 8
shld edx, eax, 3 ja .last
shl eax, 3
bswap eax dec ecx
bswap edx xor eax, eax
mov dword[edi], edx rep stosb
mov dword[edi+4], eax lea esi, [ebx + ctx_sha1.block]
lea esi, [ebx + ctx_sha1.block] lea eax, [ebx + ctx_sha1.hash]
lea eax, [ebx + ctx_sha1.hash] stdcall sha1._.block, eax
stdcall sha1._.block, eax mov ebx, [_ctx]
lea edi, [ebx + ctx_sha1.block]
mov ebx, [_ctx] mov ecx, SHA1_BLOCK_SIZE+1
lea eax, [ebx + ctx_sha1.hash] .last:
stdcall sha1._.postprocess, ebx, eax dec ecx
sub ecx, 8
ret xor eax, eax
endp rep stosb
mov eax, [ebx + ctx_sha1.msglen_0]
mov edx, [ebx + ctx_sha1.msglen_1]
proc sha1._.postprocess _ctx, _hash shld edx, eax, 3
mov ecx, 5 shl eax, 3
mov esi, [_hash] bswap eax
mov edi, esi bswap edx
@@: mov dword[edi], edx
lodsd mov dword[edi+4], eax
bswap eax lea esi, [ebx + ctx_sha1.block]
stosd lea eax, [ebx + ctx_sha1.hash]
dec ecx stdcall sha1._.block, eax
jnz @b
ret mov ebx, [_ctx]
endp lea eax, [ebx + ctx_sha1.hash]
stdcall sha1._.postprocess, ebx, eax
align SHA1_ALIGN ret
endp
sha1._.hash_init dd 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
proc sha1._.postprocess _ctx, _hash
mov ecx, 5
mov esi, [_hash]
mov edi, esi
@@:
lodsd
bswap eax
stosd
dec ecx
jnz @b
ret
endp
proc sha1.oneshot _ctx, _data, _len
stdcall sha1.init, [_ctx]
stdcall sha1.update, [_ctx], [_data], [_len]
stdcall sha1.final, [_ctx]
ret
endp
iglobal
align SHA1_ALIGN
sha1._.hash_init dd 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
endg

View File

@ -1,399 +1,441 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2012-2013,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2012-2013,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
macro sha224256._.chn x, y, z SHA224256_BLOCK_SIZE = 64
{ SHA224_BLOCK_SIZE = SHA224256_BLOCK_SIZE
mov eax, [y] SHA256_BLOCK_SIZE = SHA224256_BLOCK_SIZE
xor eax, [z] SHA224_HASH_SIZE = 28
and eax, [x] SHA256_HASH_SIZE = 32
xor eax, [z]
} SHA224256_INIT_SIZE = 32
SHA224256_ALIGN = 4
macro sha224256._.maj x, y, z SHA224256_ALIGN_MASK = SHA224256_ALIGN - 1
{
mov eax, [x] struct ctx_sha224256
xor eax, [y] hash rb SHA224256_INIT_SIZE
and eax, [z] block rb SHA224256_BLOCK_SIZE
mov ecx, [x] index rd 1
and ecx, [y] msglen_0 rd 1
xor eax, ecx msglen_1 rd 1
} ends
macro sha224256._.Sigma0 x if defined sizeof.crash_ctx
{ assert sizeof.crash_ctx >= sizeof.ctx_sha224256
mov eax, x end if
mov ecx, eax
ror ecx, 2
ror eax, 13 macro sha224256._.chn x, y, z
xor eax, ecx {
mov ecx, x mov eax, [y]
ror ecx, 22 xor eax, [z]
xor eax, ecx and eax, [x]
} xor eax, [z]
}
macro sha224256._.Sigma1 x
{ macro sha224256._.maj x, y, z
mov eax, x {
mov ecx, eax mov eax, [x]
ror ecx, 6 xor eax, [y]
ror eax, 11 and eax, [z]
xor eax, ecx mov ecx, [x]
mov ecx, x and ecx, [y]
ror ecx, 25 xor eax, ecx
xor eax, ecx }
}
macro sha224256._.Sigma0 x
macro sha224256._.sigma0 x {
{ mov eax, x
mov eax, x mov ecx, eax
mov ecx, eax ror ecx, 2
ror ecx, 7 ror eax, 13
ror eax, 18 xor eax, ecx
xor eax, ecx mov ecx, x
mov ecx, x ror ecx, 22
shr ecx, 3 xor eax, ecx
xor eax, ecx }
}
macro sha224256._.Sigma1 x
macro sha224256._.sigma1 x {
{ mov eax, x
mov eax, x mov ecx, eax
mov ecx, eax ror ecx, 6
ror ecx, 17 ror eax, 11
ror eax, 19 xor eax, ecx
xor eax, ecx mov ecx, x
mov ecx, x ror ecx, 25
shr ecx, 10 xor eax, ecx
xor eax, ecx }
}
macro sha224256._.sigma0 x
macro sha224256._.recalculate_w n {
{ mov eax, x
mov edx, [w + ((n-2) and 15)*4] mov ecx, eax
sha224256._.sigma1 edx ror ecx, 7
add eax, [w + ((n-7) and 15)*4] ror eax, 18
push eax xor eax, ecx
mov edx, [w + ((n-15) and 15)*4] mov ecx, x
sha224256._.sigma0 edx shr ecx, 3
pop ecx xor eax, ecx
add eax, ecx }
add [w + (n)*4], eax
} macro sha224256._.sigma1 x
{
macro sha224256._.round a, b, c, d, e, f, g, h, k mov eax, x
{ mov ecx, eax
mov ebx, [h] ror ecx, 17
mov edx, [e] ror eax, 19
sha224256._.Sigma1 edx xor eax, ecx
mov ecx, x
add ebx, eax shr ecx, 10
sha224256._.chn e, f, g xor eax, ecx
}
add ebx, eax
add ebx, [k] macro sha224256._.recalculate_w n
add ebx, edi {
mov edx, [w + ((n-2) and 15)*4]
add [d], ebx sha224256._.sigma1 edx
add eax, [w + ((n-7) and 15)*4]
mov edx, [a] push eax
sha224256._.Sigma0 edx mov edx, [w + ((n-15) and 15)*4]
add ebx, eax sha224256._.sigma0 edx
sha224256._.maj a, b, c pop ecx
add eax, ebx add eax, ecx
mov [h], eax add [w + (n)*4], eax
} }
macro sha224256._.round a, b, c, d, e, f, g, h, k
macro sha224256._.round_1_16 a, b, c, d, e, f, g, h, n {
{ mov ebx, [h]
mov edx, [e]
mov eax, [esi + (n)*4] sha224256._.Sigma1 edx
bswap eax
add ebx, eax
mov dword[w + (n)*4], eax sha224256._.chn e, f, g
mov edi, eax
sha224256._.round a, b, c, d, e, f, g, h, (sha256_table + (n)*4) add ebx, eax
} add ebx, [k]
add ebx, edi
macro sha224256._.round_17_64 a, b, c, d, e, f, g, h, n, rep_num
{ add [d], ebx
sha224256._.recalculate_w n
mov edi, [w + (n)*4] mov edx, [a]
sha224256._.round a, b, c, d, e, f, g, h, (sha256_table + (n+16*rep_num)*4) sha224256._.Sigma0 edx
} add ebx, eax
sha224256._.maj a, b, c
add eax, ebx
proc sha224.init _ctx mov [h], eax
mov ebx, [_ctx] }
lea edi, [ebx + ctx_sha224256.hash]
mov esi, sha224._.hash_init
mov ecx, SHA224256_INIT_SIZE/4 macro sha224256._.round_1_16 a, b, c, d, e, f, g, h, n
rep movsd {
xor eax, eax
mov [ebx + ctx_sha224256.index], eax mov eax, [esi + (n)*4]
mov [ebx + ctx_sha224256.msglen_0], eax bswap eax
mov [ebx + ctx_sha224256.msglen_1], eax
ret mov dword[w + (n)*4], eax
endp mov edi, eax
sha224256._.round a, b, c, d, e, f, g, h, (sha256_table + (n)*4)
}
proc sha256.init _ctx
mov ebx, [_ctx] macro sha224256._.round_17_64 a, b, c, d, e, f, g, h, n, rep_num
lea edi, [ebx + ctx_sha224256.hash] {
mov esi, sha256._.hash_init sha224256._.recalculate_w n
mov ecx, SHA224256_INIT_SIZE/4 mov edi, [w + (n)*4]
rep movsd sha224256._.round a, b, c, d, e, f, g, h, (sha256_table + (n+16*rep_num)*4)
xor eax, eax }
mov [ebx + ctx_sha224256.index], eax
mov [ebx + ctx_sha224256.msglen_0], eax
mov [ebx + ctx_sha224256.msglen_1], eax proc sha224.init _ctx
ret mov ebx, [_ctx]
endp lea edi, [ebx + ctx_sha224256.hash]
mov esi, sha224._.hash_init
mov ecx, SHA224256_INIT_SIZE/4
proc sha224256._.block _hash rep movsd
locals xor eax, eax
w rd 64 mov [ebx + ctx_sha224256.index], eax
A rd 1 mov [ebx + ctx_sha224256.msglen_0], eax
B rd 1 mov [ebx + ctx_sha224256.msglen_1], eax
C rd 1 ret
D rd 1 endp
E rd 1
F rd 1
G rd 1 proc sha256.init _ctx
H rd 1 mov ebx, [_ctx]
endl lea edi, [ebx + ctx_sha224256.hash]
mov edi, [_hash] mov esi, sha256._.hash_init
mov eax, [edi + 0x00] mov ecx, SHA224256_INIT_SIZE/4
mov [A], eax rep movsd
mov eax, [edi + 0x04] xor eax, eax
mov [B], eax mov [ebx + ctx_sha224256.index], eax
mov eax, [edi + 0x08] mov [ebx + ctx_sha224256.msglen_0], eax
mov [C], eax mov [ebx + ctx_sha224256.msglen_1], eax
mov eax, [edi + 0x0c] ret
mov [D], eax endp
mov eax, [edi + 0x10]
mov [E], eax
mov eax, [edi + 0x14] proc sha224256._.block _hash
mov [F], eax locals
mov eax, [edi + 0x18] w rd 64
mov [G], eax A rd 1
mov eax, [edi + 0x1c] B rd 1
mov [H], eax C rd 1
D rd 1
sha224256._.round_1_16 A, B, C, D, E, F, G, H, 0 E rd 1
sha224256._.round_1_16 H, A, B, C, D, E, F, G, 1 F rd 1
sha224256._.round_1_16 G, H, A, B, C, D, E, F, 2 G rd 1
sha224256._.round_1_16 F, G, H, A, B, C, D, E, 3 H rd 1
sha224256._.round_1_16 E, F, G, H, A, B, C, D, 4 endl
sha224256._.round_1_16 D, E, F, G, H, A, B, C, 5 mov edi, [_hash]
sha224256._.round_1_16 C, D, E, F, G, H, A, B, 6 mov eax, [edi + 0x00]
sha224256._.round_1_16 B, C, D, E, F, G, H, A, 7 mov [A], eax
sha224256._.round_1_16 A, B, C, D, E, F, G, H, 8 mov eax, [edi + 0x04]
sha224256._.round_1_16 H, A, B, C, D, E, F, G, 9 mov [B], eax
sha224256._.round_1_16 G, H, A, B, C, D, E, F, 10 mov eax, [edi + 0x08]
sha224256._.round_1_16 F, G, H, A, B, C, D, E, 11 mov [C], eax
sha224256._.round_1_16 E, F, G, H, A, B, C, D, 12 mov eax, [edi + 0x0c]
sha224256._.round_1_16 D, E, F, G, H, A, B, C, 13 mov [D], eax
sha224256._.round_1_16 C, D, E, F, G, H, A, B, 14 mov eax, [edi + 0x10]
sha224256._.round_1_16 B, C, D, E, F, G, H, A, 15 mov [E], eax
mov eax, [edi + 0x14]
repeat 3 mov [F], eax
sha224256._.round_17_64 A, B, C, D, E, F, G, H, 0, % mov eax, [edi + 0x18]
sha224256._.round_17_64 H, A, B, C, D, E, F, G, 1, % mov [G], eax
sha224256._.round_17_64 G, H, A, B, C, D, E, F, 2, % mov eax, [edi + 0x1c]
sha224256._.round_17_64 F, G, H, A, B, C, D, E, 3, % mov [H], eax
sha224256._.round_17_64 E, F, G, H, A, B, C, D, 4, %
sha224256._.round_17_64 D, E, F, G, H, A, B, C, 5, % sha224256._.round_1_16 A, B, C, D, E, F, G, H, 0
sha224256._.round_17_64 C, D, E, F, G, H, A, B, 6, % sha224256._.round_1_16 H, A, B, C, D, E, F, G, 1
sha224256._.round_17_64 B, C, D, E, F, G, H, A, 7, % sha224256._.round_1_16 G, H, A, B, C, D, E, F, 2
sha224256._.round_17_64 A, B, C, D, E, F, G, H, 8, % sha224256._.round_1_16 F, G, H, A, B, C, D, E, 3
sha224256._.round_17_64 H, A, B, C, D, E, F, G, 9, % sha224256._.round_1_16 E, F, G, H, A, B, C, D, 4
sha224256._.round_17_64 G, H, A, B, C, D, E, F, 10, % sha224256._.round_1_16 D, E, F, G, H, A, B, C, 5
sha224256._.round_17_64 F, G, H, A, B, C, D, E, 11, % sha224256._.round_1_16 C, D, E, F, G, H, A, B, 6
sha224256._.round_17_64 E, F, G, H, A, B, C, D, 12, % sha224256._.round_1_16 B, C, D, E, F, G, H, A, 7
sha224256._.round_17_64 D, E, F, G, H, A, B, C, 13, % sha224256._.round_1_16 A, B, C, D, E, F, G, H, 8
sha224256._.round_17_64 C, D, E, F, G, H, A, B, 14, % sha224256._.round_1_16 H, A, B, C, D, E, F, G, 9
sha224256._.round_17_64 B, C, D, E, F, G, H, A, 15, % sha224256._.round_1_16 G, H, A, B, C, D, E, F, 10
end repeat sha224256._.round_1_16 F, G, H, A, B, C, D, E, 11
sha224256._.round_1_16 E, F, G, H, A, B, C, D, 12
mov edi, [_hash] sha224256._.round_1_16 D, E, F, G, H, A, B, C, 13
mov eax, [A] sha224256._.round_1_16 C, D, E, F, G, H, A, B, 14
add [edi + 0x00], eax sha224256._.round_1_16 B, C, D, E, F, G, H, A, 15
mov eax, [B]
add [edi + 0x04], eax repeat 3
mov eax, [C] sha224256._.round_17_64 A, B, C, D, E, F, G, H, 0, %
add [edi + 0x08], eax sha224256._.round_17_64 H, A, B, C, D, E, F, G, 1, %
mov eax, [D] sha224256._.round_17_64 G, H, A, B, C, D, E, F, 2, %
add [edi + 0x0c], eax sha224256._.round_17_64 F, G, H, A, B, C, D, E, 3, %
mov eax, [E] sha224256._.round_17_64 E, F, G, H, A, B, C, D, 4, %
add [edi + 0x10], eax sha224256._.round_17_64 D, E, F, G, H, A, B, C, 5, %
mov eax, [F] sha224256._.round_17_64 C, D, E, F, G, H, A, B, 6, %
add [edi + 0x14], eax sha224256._.round_17_64 B, C, D, E, F, G, H, A, 7, %
mov eax, [G] sha224256._.round_17_64 A, B, C, D, E, F, G, H, 8, %
add [edi + 0x18], eax sha224256._.round_17_64 H, A, B, C, D, E, F, G, 9, %
mov eax, [H] sha224256._.round_17_64 G, H, A, B, C, D, E, F, 10, %
add [edi + 0x1c], eax sha224256._.round_17_64 F, G, H, A, B, C, D, E, 11, %
sha224256._.round_17_64 E, F, G, H, A, B, C, D, 12, %
ret sha224256._.round_17_64 D, E, F, G, H, A, B, C, 13, %
endp sha224256._.round_17_64 C, D, E, F, G, H, A, B, 14, %
sha224256._.round_17_64 B, C, D, E, F, G, H, A, 15, %
sha256.update = sha224.update end repeat
proc sha224.update _ctx, _msg, _size
mov ebx, [_ctx] mov edi, [_hash]
mov ecx, [_size] mov eax, [A]
add [ebx + ctx_sha224256.msglen_0], ecx add [edi + 0x00], eax
adc [ebx + ctx_sha224256.msglen_1], 0 mov eax, [B]
add [edi + 0x04], eax
.next_block: mov eax, [C]
mov ebx, [_ctx] add [edi + 0x08], eax
mov esi, [_msg] mov eax, [D]
mov eax, [ebx + ctx_sha224256.index] add [edi + 0x0c], eax
and eax, SHA224256_BLOCK_SIZE-1 mov eax, [E]
jnz .copy_to_buf add [edi + 0x10], eax
test esi, SHA224256_ALIGN_MASK mov eax, [F]
jnz .copy_to_buf add [edi + 0x14], eax
.no_copy: mov eax, [G]
; data is aligned, hash it in place without copying add [edi + 0x18], eax
mov ebx, [_ctx] mov eax, [H]
cmp [_size], SHA224256_BLOCK_SIZE add [edi + 0x1c], eax
jb .copy_quit
lea eax, [ebx + ctx_sha224256.hash] ret
stdcall sha224256._.block, eax endp
sub [_size], SHA224256_BLOCK_SIZE
add esi, SHA224256_BLOCK_SIZE ; FIXME
jmp .no_copy sha224.update = sha224256.update
sha256.update = sha224256.update
.copy_to_buf: proc sha224256.update _ctx, _msg, _size
lea edi, [ebx + ctx_sha224256.block] mov ebx, [_ctx]
add edi, eax mov ecx, [_size]
mov ecx, SHA224256_BLOCK_SIZE add [ebx + ctx_sha224256.msglen_0], ecx
sub ecx, eax adc [ebx + ctx_sha224256.msglen_1], 0
cmp [_size], ecx
jb .copy_quit .next_block:
sub [_size], ecx mov ebx, [_ctx]
add [_msg], ecx mov esi, [_msg]
add [ebx + ctx_sha224256.index], ecx mov eax, [ebx + ctx_sha224256.index]
rep movsb and eax, SHA224256_BLOCK_SIZE-1
lea eax, [ebx + ctx_sha224256.hash] jnz .copy_to_buf
lea esi, [ebx + ctx_sha224256.block] test esi, SHA224256_ALIGN_MASK
stdcall sha224256._.block, eax jnz .copy_to_buf
jmp .next_block .no_copy:
; data is aligned, hash it in place without copying
.copy_quit: mov ebx, [_ctx]
mov ebx, [_ctx] cmp [_size], SHA224256_BLOCK_SIZE
lea edi, [ebx + ctx_sha224256.block] jb .copy_quit
mov eax, [ebx + ctx_sha224256.index] lea eax, [ebx + ctx_sha224256.hash]
and eax, SHA224256_BLOCK_SIZE-1 stdcall sha224256._.block, eax
add edi, eax sub [_size], SHA224256_BLOCK_SIZE
mov ecx, [_size] add esi, SHA224256_BLOCK_SIZE ; FIXME
add [ebx + ctx_sha224256.index], ecx jmp .no_copy
rep movsb
.quit: .copy_to_buf:
lea edi, [ebx + ctx_sha224256.block]
ret add edi, eax
endp mov ecx, SHA224256_BLOCK_SIZE
sub ecx, eax
cmp [_size], ecx
sha256.final = sha224.final jb .copy_quit
proc sha224.final _ctx sub [_size], ecx
mov ebx, [_ctx] add [_msg], ecx
lea edi, [ebx + ctx_sha224256.block] add [ebx + ctx_sha224256.index], ecx
mov ecx, [ebx + ctx_sha224256.msglen_0] rep movsb
and ecx, SHA224256_BLOCK_SIZE-1 lea eax, [ebx + ctx_sha224256.hash]
add edi, ecx lea esi, [ebx + ctx_sha224256.block]
mov byte[edi], 0x80 stdcall sha224256._.block, eax
inc edi jmp .next_block
neg ecx
add ecx, SHA224256_BLOCK_SIZE .copy_quit:
cmp ecx, 8 mov ebx, [_ctx]
ja .last lea edi, [ebx + ctx_sha224256.block]
mov eax, [ebx + ctx_sha224256.index]
dec ecx and eax, SHA224256_BLOCK_SIZE-1
xor eax, eax add edi, eax
rep stosb mov ecx, [_size]
lea esi, [ebx + ctx_sha224256.block] add [ebx + ctx_sha224256.index], ecx
lea eax, [ebx + ctx_sha224256.hash] rep movsb
stdcall sha224256._.block, eax .quit:
mov ebx, [_ctx]
lea edi, [ebx + ctx_sha224256.block] ret
mov ecx, SHA224256_BLOCK_SIZE+1 endp
.last:
dec ecx
sub ecx, 8 sha224.final = sha224256.final
xor eax, eax sha256.final = sha224256.final
rep stosb proc sha224256.final _ctx
mov eax, [ebx + ctx_sha224256.msglen_0] mov ebx, [_ctx]
mov edx, [ebx + ctx_sha224256.msglen_1] lea edi, [ebx + ctx_sha224256.block]
shld edx, eax, 3 mov ecx, [ebx + ctx_sha224256.msglen_0]
shl eax, 3 and ecx, SHA224256_BLOCK_SIZE-1
bswap eax add edi, ecx
bswap edx mov byte[edi], 0x80
mov dword[edi], edx inc edi
mov dword[edi+4], eax neg ecx
lea esi, [ebx + ctx_sha224256.block] add ecx, SHA224256_BLOCK_SIZE
lea eax, [ebx + ctx_sha224256.hash] cmp ecx, 8
stdcall sha224256._.block, eax ja .last
mov ebx, [_ctx] dec ecx
lea eax, [ebx + ctx_sha224256.hash] xor eax, eax
stdcall sha224256._.postprocess, ebx, eax rep stosb
lea esi, [ebx + ctx_sha224256.block]
ret lea eax, [ebx + ctx_sha224256.hash]
endp stdcall sha224256._.block, eax
mov ebx, [_ctx]
lea edi, [ebx + ctx_sha224256.block]
proc sha224256._.postprocess _ctx, _hash mov ecx, SHA224256_BLOCK_SIZE+1
mov ecx, 8 .last:
mov esi, [_hash] dec ecx
mov edi, esi sub ecx, 8
@@: xor eax, eax
lodsd rep stosb
bswap eax mov eax, [ebx + ctx_sha224256.msglen_0]
stosd mov edx, [ebx + ctx_sha224256.msglen_1]
dec ecx shld edx, eax, 3
jnz @b shl eax, 3
ret bswap eax
endp bswap edx
mov dword[edi], edx
mov dword[edi+4], eax
align SHA224256_ALIGN lea esi, [ebx + ctx_sha224256.block]
lea eax, [ebx + ctx_sha224256.hash]
sha224._.hash_init dd 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,\ stdcall sha224256._.block, eax
0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
mov ebx, [_ctx]
sha256._.hash_init dd 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\ lea eax, [ebx + ctx_sha224256.hash]
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 stdcall sha224256._.postprocess, ebx, eax
sha256_table dd 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\ ret
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\ endp
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\ proc sha224256._.postprocess _ctx, _hash
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\ mov ecx, 8
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\ mov esi, [_hash]
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\ mov edi, esi
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\ @@:
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\ lodsd
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\ bswap eax
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\ stosd
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\ dec ecx
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\ jnz @b
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\ ret
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 endp
proc sha224.oneshot _ctx, _data, _len
stdcall sha224.init, [_ctx]
stdcall sha224.update, [_ctx], [_data], [_len]
stdcall sha224.final, [_ctx]
ret
endp
proc sha256.oneshot _ctx, _data, _len
stdcall sha256.init, [_ctx]
stdcall sha256.update, [_ctx], [_data], [_len]
stdcall sha256.final, [_ctx]
ret
endp
iglobal
align SHA224256_ALIGN
sha224._.hash_init dd 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,\
0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
sha256._.hash_init dd 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
sha256_table dd 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
endg

View File

@ -1,417 +1,482 @@
; libcrash -- cryptographic hash functions ; libcrash -- cryptographic hash functions
; ;
; Copyright (C) 2013,2016 Ivan Baravy (dunkaist) ; Copyright (C) 2013,2016,2019 Ivan Baravy (dunkaist)
; ;
; This program is free software: you can redistribute it and/or modify ; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by ; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or ; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version. ; (at your option) any later version.
; ;
; This program is distributed in the hope that it will be useful, ; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of ; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details. ; GNU General Public License for more details.
; ;
; You should have received a copy of the GNU General Public License ; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>. ; along with this program. If not, see <http://www.gnu.org/licenses/>.
macro sha3._.rol_xor nd, ncl, ncr SHA3_224_HASH_SIZE = 28
{ SHA3_256_HASH_SIZE = 32
movq mm0, [C + 8*(ncl)] SHA3_384_HASH_SIZE = 48
movq mm1, mm0 SHA3_512_HASH_SIZE = 64
psllq mm0, 1
psrlq mm1, 63 SHA3_224_BLOCK_SIZE = 144
por mm0, mm1 SHA3_256_BLOCK_SIZE = 136
pxor mm0, [C + 8*(ncr)] SHA3_384_BLOCK_SIZE = 104
movq [D + 8*(nd)], mm0 SHA3_512_BLOCK_SIZE = 72
} SHA3MAX_BLOCK_SIZE = SHA3_224_BLOCK_SIZE
proc sha3._.theta SHA3_INIT_SIZE = 200
;locals SHA3_ALIGN = 16
; C rq 5 SHA3_ALIGN_MASK = SHA3_ALIGN-1
; D rq 5
;endl struct ctx_sha3
C equ ebx + ctx_sha3.C hash rb SHA3_INIT_SIZE
D equ ebx + ctx_sha3.D rb SHA3_ALIGN - (SHA3_INIT_SIZE mod SHA3_ALIGN)
block rb SHA3MAX_BLOCK_SIZE
repeat 5 rb SHA3_ALIGN - (SHA3MAX_BLOCK_SIZE mod SHA3_ALIGN)
movq mm0, [edi + 8*(%-1 + 0)] index rd 1
pxor mm0, [edi + 8*(%-1 + 5)] block_size rd 1
pxor mm0, [edi + 8*(%-1 + 10)] rounds_cnt rd 1
pxor mm0, [edi + 8*(%-1 + 15)] rd 1 ; align
pxor mm0, [edi + 8*(%-1 + 20)] ; tmp vars
movq [C + 8*(%-1)], mm0 C rq 5
end repeat D rq 5
ends
sha3._.rol_xor 0, 1, 4
sha3._.rol_xor 1, 2, 0 if defined sizeof.crash_ctx
sha3._.rol_xor 2, 3, 1 assert sizeof.crash_ctx >= sizeof.ctx_sha3
sha3._.rol_xor 3, 4, 2 end if
sha3._.rol_xor 4, 0, 3
macro sha3._.rol_xor nd, ncl, ncr
repeat 5 {
movq mm1, [D + 8*(%-1)] movq mm0, [C + 8*(ncl)]
movq mm0, mm1 movq mm1, mm0
pxor mm0, [edi + 8*(%-1 + 0)] psllq mm0, 1
movq [edi + 8*(%-1 + 0)], mm0 psrlq mm1, 63
movq mm0, mm1 por mm0, mm1
pxor mm0, [edi + 8*(%-1 + 5)] pxor mm0, [C + 8*(ncr)]
movq [edi + 8*(%-1 + 5)], mm0 movq [D + 8*(nd)], mm0
movq mm0, mm1 }
pxor mm0, [edi + 8*(%-1 + 10)]
movq [edi + 8*(%-1 + 10)], mm0 proc sha3._.theta
movq mm0, mm1 ;locals
pxor mm0, [edi + 8*(%-1 + 15)] ; C rq 5
movq [edi + 8*(%-1 + 15)], mm0 ; D rq 5
movq mm0, mm1 ;endl
pxor mm0, [edi + 8*(%-1 + 20)] C equ ebx + ctx_sha3.C
movq [edi + 8*(%-1 + 20)], mm0 D equ ebx + ctx_sha3.D
end repeat
repeat 5
restore C,D movq mm0, [edi + 8*(%-1 + 0)]
ret pxor mm0, [edi + 8*(%-1 + 5)]
endp pxor mm0, [edi + 8*(%-1 + 10)]
pxor mm0, [edi + 8*(%-1 + 15)]
pxor mm0, [edi + 8*(%-1 + 20)]
proc sha3._.pi movq [C + 8*(%-1)], mm0
movq mm1, [edi + 8*1] end repeat
movq mm0, [edi + 8*6]
movq [edi + 8*1], mm0 sha3._.rol_xor 0, 1, 4
movq mm0, [edi + 8*9] sha3._.rol_xor 1, 2, 0
movq [edi + 8*6], mm0 sha3._.rol_xor 2, 3, 1
movq mm0, [edi + 8*22] sha3._.rol_xor 3, 4, 2
movq [edi + 8*9], mm0 sha3._.rol_xor 4, 0, 3
movq mm0, [edi + 8*14]
movq [edi + 8*22], mm0 repeat 5
movq mm0, [edi + 8*20] movq mm1, [D + 8*(%-1)]
movq [edi + 8*14], mm0 movq mm0, mm1
movq mm0, [edi + 8*2] pxor mm0, [edi + 8*(%-1 + 0)]
movq [edi + 8*20], mm0 movq [edi + 8*(%-1 + 0)], mm0
movq mm0, [edi + 8*12] movq mm0, mm1
movq [edi + 8*2], mm0 pxor mm0, [edi + 8*(%-1 + 5)]
movq mm0, [edi + 8*13] movq [edi + 8*(%-1 + 5)], mm0
movq [edi + 8*12], mm0 movq mm0, mm1
movq mm0, [edi + 8*19] pxor mm0, [edi + 8*(%-1 + 10)]
movq [edi + 8*13], mm0 movq [edi + 8*(%-1 + 10)], mm0
movq mm0, [edi + 8*23] movq mm0, mm1
movq [edi + 8*19], mm0 pxor mm0, [edi + 8*(%-1 + 15)]
movq mm0, [edi + 8*15] movq [edi + 8*(%-1 + 15)], mm0
movq [edi + 8*23], mm0 movq mm0, mm1
movq mm0, [edi + 8*4] pxor mm0, [edi + 8*(%-1 + 20)]
movq [edi + 8*15], mm0 movq [edi + 8*(%-1 + 20)], mm0
movq mm0, [edi + 8*24] end repeat
movq [edi + 8*4], mm0
movq mm0, [edi + 8*21] restore C,D
movq [edi + 8*24], mm0 ret
movq mm0, [edi + 8*8] endp
movq [edi + 8*21], mm0
movq mm0, [edi + 8*16]
movq [edi + 8*8], mm0 proc sha3._.pi
movq mm0, [edi + 8*5] movq mm1, [edi + 8*1]
movq [edi + 8*16], mm0 movq mm0, [edi + 8*6]
movq mm0, [edi + 8*3] movq [edi + 8*1], mm0
movq [edi + 8*5], mm0 movq mm0, [edi + 8*9]
movq mm0, [edi + 8*18] movq [edi + 8*6], mm0
movq [edi + 8*3], mm0 movq mm0, [edi + 8*22]
movq mm0, [edi + 8*17] movq [edi + 8*9], mm0
movq [edi + 8*18], mm0 movq mm0, [edi + 8*14]
movq mm0, [edi + 8*11] movq [edi + 8*22], mm0
movq [edi + 8*17], mm0 movq mm0, [edi + 8*20]
movq mm0, [edi + 8*7] movq [edi + 8*14], mm0
movq [edi + 8*11], mm0 movq mm0, [edi + 8*2]
movq mm0, [edi + 8*10] movq [edi + 8*20], mm0
movq [edi + 8*7], mm0 movq mm0, [edi + 8*12]
movq [edi + 8*10], mm1 movq [edi + 8*2], mm0
movq mm0, [edi + 8*13]
ret movq [edi + 8*12], mm0
endp movq mm0, [edi + 8*19]
movq [edi + 8*13], mm0
movq mm0, [edi + 8*23]
proc sha3._.chi movq [edi + 8*19], mm0
movq mm0, [edi + 8*15]
mov eax, 0xffffffff movq [edi + 8*23], mm0
movd mm0, eax movq mm0, [edi + 8*4]
movq mm2, mm0 movq [edi + 8*15], mm0
punpckldq mm2, mm0 movq mm0, [edi + 8*24]
movq [edi + 8*4], mm0
repeat 5 movq mm0, [edi + 8*21]
movq mm6, [edi + 8*(0 + 5*(%-1))] movq [edi + 8*24], mm0
movq mm7, [edi + 8*(1 + 5*(%-1))] movq mm0, [edi + 8*8]
movq [edi + 8*21], mm0
movq mm0, [edi + 8*(0 + 5*(%-1))] movq mm0, [edi + 8*16]
movq mm1, mm7 movq [edi + 8*8], mm0
pandn mm1, mm2 movq mm0, [edi + 8*5]
pand mm1, [edi + 8*(2 + 5*(%-1))] movq [edi + 8*16], mm0
pxor mm0, mm1 movq mm0, [edi + 8*3]
movq [edi + 8*(0 + 5*(%-1))], mm0 movq [edi + 8*5], mm0
movq mm0, [edi + 8*18]
movq mm0, [edi + 8*(1 + 5*(%-1))] movq [edi + 8*3], mm0
movq mm1, [edi + 8*(2 + 5*(%-1))] movq mm0, [edi + 8*17]
pandn mm1, mm2 movq [edi + 8*18], mm0
pand mm1, [edi + 8*(3 + 5*(%-1))] movq mm0, [edi + 8*11]
pxor mm0, mm1 movq [edi + 8*17], mm0
movq [edi + 8*(1 + 5*(%-1))], mm0 movq mm0, [edi + 8*7]
movq [edi + 8*11], mm0
movq mm0, [edi + 8*(2 + 5*(%-1))] movq mm0, [edi + 8*10]
movq mm1, [edi + 8*(3 + 5*(%-1))] movq [edi + 8*7], mm0
pandn mm1, mm2 movq [edi + 8*10], mm1
pand mm1, [edi + 8*(4 + 5*(%-1))]
pxor mm0, mm1 ret
movq [edi + 8*(2 + 5*(%-1))], mm0 endp
movq mm0, [edi + 8*(3 + 5*(%-1))]
movq mm1, [edi + 8*(4 + 5*(%-1))] proc sha3._.chi
pandn mm1, mm2
pand mm1, mm6 mov eax, 0xffffffff
pxor mm0, mm1 movd mm0, eax
movq [edi + 8*(3 + 5*(%-1))], mm0 movq mm2, mm0
punpckldq mm2, mm0
movq mm0, [edi + 8*(4 + 5*(%-1))]
movq mm1, mm6 repeat 5
pandn mm1, mm2 movq mm6, [edi + 8*(0 + 5*(%-1))]
pand mm1, mm7 movq mm7, [edi + 8*(1 + 5*(%-1))]
pxor mm0, mm1
movq [edi + 8*(4 + 5*(%-1))], mm0 movq mm0, [edi + 8*(0 + 5*(%-1))]
end repeat movq mm1, mm7
ret pandn mm1, mm2
endp pand mm1, [edi + 8*(2 + 5*(%-1))]
pxor mm0, mm1
movq [edi + 8*(0 + 5*(%-1))], mm0
macro sha3._.rol_mov n, c
{ movq mm0, [edi + 8*(1 + 5*(%-1))]
movq mm0, [edi + 8*(n)] movq mm1, [edi + 8*(2 + 5*(%-1))]
movq mm1, mm0 pandn mm1, mm2
psllq mm0, (c) pand mm1, [edi + 8*(3 + 5*(%-1))]
psrlq mm1, (64-(c)) pxor mm0, mm1
por mm0, mm1 movq [edi + 8*(1 + 5*(%-1))], mm0
movq [edi + 8*(n)], mm0
} movq mm0, [edi + 8*(2 + 5*(%-1))]
movq mm1, [edi + 8*(3 + 5*(%-1))]
proc sha3._.permutation pandn mm1, mm2
pand mm1, [edi + 8*(4 + 5*(%-1))]
repeat 24 pxor mm0, mm1
stdcall sha3._.theta movq [edi + 8*(2 + 5*(%-1))], mm0
sha3._.rol_mov 1, 1 movq mm0, [edi + 8*(3 + 5*(%-1))]
sha3._.rol_mov 2, 62 movq mm1, [edi + 8*(4 + 5*(%-1))]
sha3._.rol_mov 3, 28 pandn mm1, mm2
sha3._.rol_mov 4, 27 pand mm1, mm6
sha3._.rol_mov 5, 36 pxor mm0, mm1
sha3._.rol_mov 6, 44 movq [edi + 8*(3 + 5*(%-1))], mm0
sha3._.rol_mov 7, 6
sha3._.rol_mov 8, 55 movq mm0, [edi + 8*(4 + 5*(%-1))]
sha3._.rol_mov 9, 20 movq mm1, mm6
sha3._.rol_mov 10, 3 pandn mm1, mm2
sha3._.rol_mov 11, 10 pand mm1, mm7
sha3._.rol_mov 12, 43 pxor mm0, mm1
sha3._.rol_mov 13, 25 movq [edi + 8*(4 + 5*(%-1))], mm0
sha3._.rol_mov 14, 39 end repeat
sha3._.rol_mov 15, 41 ret
sha3._.rol_mov 16, 45 endp
sha3._.rol_mov 17, 15
sha3._.rol_mov 18, 21
sha3._.rol_mov 19, 8 macro sha3._.rol_mov n, c
sha3._.rol_mov 20, 18 {
sha3._.rol_mov 21, 2 movq mm0, [edi + 8*(n)]
sha3._.rol_mov 22, 61 movq mm1, mm0
sha3._.rol_mov 23, 56 psllq mm0, (c)
sha3._.rol_mov 24, 14 psrlq mm1, (64-(c))
por mm0, mm1
stdcall sha3._.pi movq [edi + 8*(n)], mm0
stdcall sha3._.chi }
movq mm0, [edi + 8*(0)] proc sha3._.permutation
pxor mm0, [sha3._.round + 8*(%-1)]
movq [edi + 8*(0)], mm0 repeat 24
end repeat stdcall sha3._.theta
ret sha3._.rol_mov 1, 1
endp sha3._.rol_mov 2, 62
sha3._.rol_mov 3, 28
sha3._.rol_mov 4, 27
proc sha3._.init _ctx sha3._.rol_mov 5, 36
mov [ebx + ctx_sha3.block_size], eax sha3._.rol_mov 6, 44
shr eax, 3 sha3._.rol_mov 7, 6
dec eax sha3._.rol_mov 8, 55
mov [ebx + ctx_sha3.rounds_cnt], eax sha3._.rol_mov 9, 20
xor eax, eax sha3._.rol_mov 10, 3
lea edi, [ebx + ctx_sha3.hash] sha3._.rol_mov 11, 10
mov ecx, SHA3_INIT_SIZE/4 sha3._.rol_mov 12, 43
rep stosd sha3._.rol_mov 13, 25
mov [ebx + ctx_sha3.index], eax sha3._.rol_mov 14, 39
ret sha3._.rol_mov 15, 41
endp sha3._.rol_mov 16, 45
sha3._.rol_mov 17, 15
sha3._.rol_mov 18, 21
proc sha3224.init _ctx sha3._.rol_mov 19, 8
mov ebx, [_ctx] sha3._.rol_mov 20, 18
mov eax, SHA3224_BLOCK_SIZE sha3._.rol_mov 21, 2
stdcall sha3._.init sha3._.rol_mov 22, 61
ret sha3._.rol_mov 23, 56
endp sha3._.rol_mov 24, 14
stdcall sha3._.pi
proc sha3256.init _ctx stdcall sha3._.chi
mov ebx, [_ctx]
mov eax, SHA3256_BLOCK_SIZE movq mm0, [edi + 8*(0)]
stdcall sha3._.init pxor mm0, [sha3._.round + 8*(%-1)]
ret movq [edi + 8*(0)], mm0
endp end repeat
ret
proc sha3384.init _ctx endp
mov ebx, [_ctx]
mov eax, SHA3384_BLOCK_SIZE
stdcall sha3._.init proc sha3._.init _ctx
ret mov [ebx + ctx_sha3.block_size], eax
endp shr eax, 3
dec eax
mov [ebx + ctx_sha3.rounds_cnt], eax
proc sha3512.init _ctx xor eax, eax
mov ebx, [_ctx] lea edi, [ebx + ctx_sha3.hash]
mov eax, SHA3512_BLOCK_SIZE mov ecx, SHA3_INIT_SIZE/4
stdcall sha3._.init rep stosd
ret mov [ebx + ctx_sha3.index], eax
endp ret
endp
proc sha3._.block _hash
mov ecx, [ebx + ctx_sha3.rounds_cnt] proc sha3_224.init _ctx
mov edi, [_hash] mov ebx, [_ctx]
mov eax, SHA3_224_BLOCK_SIZE
@@: stdcall sha3._.init
movq mm0, [esi + 8*ecx] ret
pxor mm0, [edi + 8*ecx] endp
movq [edi + 8*ecx], mm0
dec ecx
jns @b proc sha3_256.init _ctx
mov ebx, [_ctx]
stdcall sha3._.permutation mov eax, SHA3_256_BLOCK_SIZE
stdcall sha3._.init
ret ret
endp endp
sha3224.update = sha3.update proc sha3_384.init _ctx
sha3256.update = sha3.update mov ebx, [_ctx]
sha3384.update = sha3.update mov eax, SHA3_384_BLOCK_SIZE
sha3512.update = sha3.update stdcall sha3._.init
proc sha3.update _ctx, _msg, _size ret
.next_block: endp
mov ebx, [_ctx]
mov esi, [_msg]
mov eax, [ebx + ctx_sha3.index] proc sha3_512.init _ctx
test eax, eax mov ebx, [_ctx]
jnz .copy_to_buf mov eax, SHA3_512_BLOCK_SIZE
test esi, SHA3_ALIGN_MASK stdcall sha3._.init
jnz .copy_to_buf ret
.no_copy: endp
; data is aligned, hash it in place without copying
mov ebx, [_ctx]
mov eax, [ebx + ctx_sha3.block_size] proc sha3._.block _hash
cmp [_size], eax mov ecx, [ebx + ctx_sha3.rounds_cnt]
jb .copy_quit mov edi, [_hash]
lea eax, [ebx + ctx_sha3.hash]
push ebx esi @@:
stdcall sha3._.block, eax movq mm0, [esi + 8*ecx]
pop esi ebx pxor mm0, [edi + 8*ecx]
mov eax, [ebx + ctx_sha3.block_size] movq [edi + 8*ecx], mm0
sub [_size], eax dec ecx
add esi, [ebx + ctx_sha3.block_size] jns @b
jmp .no_copy
stdcall sha3._.permutation
.copy_to_buf:
lea edi, [ebx + ctx_sha3.block] ret
add edi, eax endp
mov ecx, [ebx + ctx_sha3.block_size]
sub ecx, eax
cmp [_size], ecx sha3_224.update = sha3.update
jb .copy_quit sha3_256.update = sha3.update
sub [_size], ecx sha3_384.update = sha3.update
add [_msg], ecx sha3_512.update = sha3.update
add [ebx + ctx_sha3.index], ecx proc sha3.update _ctx, _msg, _size
mov eax, [ebx + ctx_sha3.block_size] .next_block:
cmp [ebx + ctx_sha3.index], eax mov ebx, [_ctx]
jb @f mov esi, [_msg]
sub [ebx + ctx_sha3.index], eax mov eax, [ebx + ctx_sha3.index]
@@: test eax, eax
rep movsb jnz .copy_to_buf
lea eax, [ebx + ctx_sha3.hash] test esi, SHA3_ALIGN_MASK
lea esi, [ebx + ctx_sha3.block] jnz .copy_to_buf
stdcall sha3._.block, eax .no_copy:
jmp .next_block ; data is aligned, hash it in place without copying
mov ebx, [_ctx]
.copy_quit: mov eax, [ebx + ctx_sha3.block_size]
mov ebx, [_ctx] cmp [_size], eax
lea edi, [ebx + ctx_sha3.block] jb .copy_quit
mov eax, [ebx + ctx_sha3.index] lea eax, [ebx + ctx_sha3.hash]
add edi, eax push ebx esi
mov ecx, [_size] stdcall sha3._.block, eax
add [ebx + ctx_sha3.index], ecx pop esi ebx
rep movsb mov eax, [ebx + ctx_sha3.block_size]
.quit: sub [_size], eax
ret add esi, [ebx + ctx_sha3.block_size]
endp jmp .no_copy
.copy_to_buf:
sha3224.final = sha3.final lea edi, [ebx + ctx_sha3.block]
sha3256.final = sha3.final add edi, eax
sha3384.final = sha3.final mov ecx, [ebx + ctx_sha3.block_size]
sha3512.final = sha3.final sub ecx, eax
proc sha3.final _ctx cmp [_size], ecx
pushad jb .copy_quit
mov ebx, [_ctx] sub [_size], ecx
mov eax, [ebx + ctx_sha3.index] add [_msg], ecx
xor edx, edx add [ebx + ctx_sha3.index], ecx
mov ecx, [ebx + ctx_sha3.block_size] mov eax, [ebx + ctx_sha3.block_size]
div ecx cmp [ebx + ctx_sha3.index], eax
sub ecx, edx jb @f
ja @f sub [ebx + ctx_sha3.index], eax
add ecx, [ebx + ctx_sha3.block_size] @@:
@@: rep movsb
add [ebx + ctx_sha3.index], ecx lea eax, [ebx + ctx_sha3.hash]
mov eax, [ebx + ctx_sha3.block_size] lea esi, [ebx + ctx_sha3.block]
cmp [ebx + ctx_sha3.index], eax stdcall sha3._.block, eax
jb @f jmp .next_block
sub [ebx + ctx_sha3.index], eax
@@: .copy_quit:
mov ebx, [_ctx]
mov byte[edi], 0x06 lea edi, [ebx + ctx_sha3.block]
inc edi mov eax, [ebx + ctx_sha3.index]
dec ecx add edi, eax
xor eax, eax mov ecx, [_size]
rep stosb add [ebx + ctx_sha3.index], ecx
or byte[edi - 1], 0x80 rep movsb
.quit:
mov ebx, [_ctx] ret
lea esi, [ebx + ctx_sha3.block] endp
lea eax, [ebx + ctx_sha3.hash]
stdcall sha3._.block, eax
sha3_224.final = sha3.final
mov ebx, [_ctx] sha3_256.final = sha3.final
lea eax, [ebx + ctx_sha3.hash] sha3_384.final = sha3.final
stdcall sha3._.postprocess, ebx, eax sha3_512.final = sha3.final
proc sha3.final _ctx
popad pushad
ret mov ebx, [_ctx]
endp mov eax, [ebx + ctx_sha3.index]
xor edx, edx
mov ecx, [ebx + ctx_sha3.block_size]
proc sha3._.postprocess _ctx, _hash div ecx
emms sub ecx, edx
ret ja @f
endp add ecx, [ebx + ctx_sha3.block_size]
@@:
add [ebx + ctx_sha3.index], ecx
align SHA3_ALIGN mov eax, [ebx + ctx_sha3.block_size]
cmp [ebx + ctx_sha3.index], eax
sha3._.round dq 0x0000000000000001, 0x0000000000008082, 0x800000000000808A,\ jb @f
0x8000000080008000, 0x000000000000808B, 0x0000000080000001,\ sub [ebx + ctx_sha3.index], eax
0x8000000080008081, 0x8000000000008009, 0x000000000000008A,\ @@:
0x0000000000000088, 0x0000000080008009, 0x000000008000000A,\
0x000000008000808B, 0x800000000000008B, 0x8000000000008089,\ mov byte[edi], 0x06
0x8000000000008003, 0x8000000000008002, 0x8000000000000080,\ inc edi
0x000000000000800A, 0x800000008000000A, 0x8000000080008081,\ dec ecx
0x8000000000008080, 0x0000000080000001, 0x8000000080008008 xor eax, eax
rep stosb
or byte[edi - 1], 0x80
mov ebx, [_ctx]
lea esi, [ebx + ctx_sha3.block]
lea eax, [ebx + ctx_sha3.hash]
stdcall sha3._.block, eax
mov ebx, [_ctx]
lea eax, [ebx + ctx_sha3.hash]
stdcall sha3._.postprocess, ebx, eax
popad
ret
endp
proc sha3._.postprocess _ctx, _hash
emms
ret
endp
proc sha3_224.oneshot _ctx, _data, _len
stdcall sha3_224.init, [_ctx]
stdcall sha3.update, [_ctx], [_data], [_len]
stdcall sha3.final, [_ctx]
ret
endp
proc sha3_256.oneshot _ctx, _data, _len
stdcall sha3_256.init, [_ctx]
stdcall sha3.update, [_ctx], [_data], [_len]
stdcall sha3.final, [_ctx]
ret
endp
proc sha3_384.oneshot _ctx, _data, _len
stdcall sha3_384.init, [_ctx]
stdcall sha3.update, [_ctx], [_data], [_len]
stdcall sha3.final, [_ctx]
ret
endp
proc sha3_512.oneshot _ctx, _data, _len
stdcall sha3_512.init, [_ctx]
stdcall sha3.update, [_ctx], [_data], [_len]
stdcall sha3.final, [_ctx]
ret
endp
iglobal
align SHA3_ALIGN
sha3._.round dq 0x0000000000000001, 0x0000000000008082, 0x800000000000808A,\
0x8000000080008000, 0x000000000000808B, 0x0000000080000001,\
0x8000000080008081, 0x8000000000008009, 0x000000000000008A,\
0x0000000000000088, 0x0000000080008009, 0x000000008000000A,\
0x000000008000808B, 0x800000000000008B, 0x8000000000008089,\
0x8000000000008003, 0x8000000000008002, 0x8000000000000080,\
0x000000000000800A, 0x800000008000000A, 0x8000000080008081,\
0x8000000000008080, 0x0000000080000001, 0x8000000080008008
endg

File diff suppressed because it is too large Load Diff

View File

@ -231,7 +231,7 @@ end if
mov esi, con.k_h_ctx mov esi, con.k_h_ctx
mov edi, con.temp_ctx mov edi, con.temp_ctx
mov ecx, sizeof.ctx_sha224256/4 mov ecx, sizeof.crash_ctx
rep movsd rep movsd
mov [con.session_id_prefix], 'A' mov [con.session_id_prefix], 'A'
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1
@ -249,7 +249,7 @@ end if
mov esi, con.k_h_ctx mov esi, con.k_h_ctx
mov edi, con.temp_ctx mov edi, con.temp_ctx
mov ecx, sizeof.ctx_sha224256/4 mov ecx, sizeof.crash_ctx/4
rep movsd rep movsd
inc [con.session_id_prefix] inc [con.session_id_prefix]
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1
@ -267,7 +267,7 @@ end if
mov esi, con.k_h_ctx mov esi, con.k_h_ctx
mov edi, con.temp_ctx mov edi, con.temp_ctx
mov ecx, sizeof.ctx_sha224256/4 mov ecx, sizeof.crash_ctx
rep movsd rep movsd
inc [con.session_id_prefix] inc [con.session_id_prefix]
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1
@ -285,7 +285,7 @@ end if
mov esi, con.k_h_ctx mov esi, con.k_h_ctx
mov edi, con.temp_ctx mov edi, con.temp_ctx
mov ecx, sizeof.ctx_sha224256/4 mov ecx, sizeof.crash_ctx/4
rep movsd rep movsd
inc [con.session_id_prefix] inc [con.session_id_prefix]
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1
@ -303,7 +303,7 @@ end if
mov esi, con.k_h_ctx mov esi, con.k_h_ctx
mov edi, con.temp_ctx mov edi, con.temp_ctx
mov ecx, sizeof.ctx_sha224256/4 mov ecx, sizeof.crash_ctx/4
rep movsd rep movsd
inc [con.session_id_prefix] inc [con.session_id_prefix]
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1
@ -321,7 +321,7 @@ end if
mov esi, con.k_h_ctx mov esi, con.k_h_ctx
mov edi, con.temp_ctx mov edi, con.temp_ctx
mov ecx, sizeof.ctx_sha224256/4 mov ecx, sizeof.crash_ctx/4
rep movsd rep movsd
inc [con.session_id_prefix] inc [con.session_id_prefix]
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1

View File

@ -22,8 +22,8 @@
struct hmac_md5_context struct hmac_md5_context
hash rb MD5_HASH_SIZE hash rb MD5_HASH_SIZE
ipad_ctx ctx_md5 ipad_ctx crash_ctx
opad_ctx ctx_md5 opad_ctx crash_ctx
ends ends
; We will precompute partial hashes of K XOR ipad and K XOR opad, ; We will precompute partial hashes of K XOR ipad and K XOR opad,

View File

@ -22,8 +22,8 @@
struct hmac_sha1_context struct hmac_sha1_context
hash rb SHA1_HASH_SIZE hash rb SHA1_HASH_SIZE
ipad_ctx ctx_sha1 ipad_ctx crash_ctx
opad_ctx ctx_sha1 opad_ctx crash_ctx
ends ends
; We will precompute partial hashes of K XOR ipad and K XOR opad, ; We will precompute partial hashes of K XOR ipad and K XOR opad,

View File

@ -22,8 +22,8 @@
struct hmac_sha256_context struct hmac_sha256_context
hash rb SHA256_HASH_SIZE hash rb SHA256_HASH_SIZE
ipad_ctx ctx_sha224256 ipad_ctx crash_ctx
opad_ctx ctx_sha224256 opad_ctx crash_ctx
ends ends
; We will precompute partial hashes of K XOR ipad and K XOR opad, ; We will precompute partial hashes of K XOR ipad and K XOR opad,
@ -32,21 +32,21 @@ ends
proc hmac_sha256_setkey ctx, key, key_length proc hmac_sha256_setkey ctx, key, key_length
locals locals
k_temp rb SHA224256_BLOCK_SIZE k_temp rb SHA256_BLOCK_SIZE
endl endl
pusha pusha
; input esi = key, ecx=key_length ; input esi = key, ecx=key_length
mov ecx, [key_length] mov ecx, [key_length]
cmp ecx, SHA224256_BLOCK_SIZE cmp ecx, SHA256_BLOCK_SIZE
ja .hash_it ja .hash_it
; Key is smaller then or equal to blocksize, ; Key is smaller then or equal to blocksize,
; copy key to ipad ; copy key to ipad
mov esi, [key] mov esi, [key]
lea edi, [k_temp] lea edi, [k_temp]
rep movsb rep movsb
mov ecx, SHA224256_BLOCK_SIZE mov ecx, SHA256_BLOCK_SIZE
sub ecx, [key_length] sub ecx, [key_length]
jz .finish jz .finish
; append zeros to the key ; append zeros to the key
@ -64,13 +64,13 @@ endl
mov ecx, SHA256_HASH_SIZE/4 mov ecx, SHA256_HASH_SIZE/4
rep movsd rep movsd
xor eax, eax xor eax, eax
mov ecx, (SHA224256_BLOCK_SIZE-SHA256_HASH_SIZE)/4 mov ecx, (SHA256_BLOCK_SIZE-SHA256_HASH_SIZE)/4
rep stosd rep stosd
.finish: .finish:
; xor ipad buffer with 0x36363... ; xor ipad buffer with 0x36363...
lea esi, [k_temp] lea esi, [k_temp]
mov ecx, SHA224256_BLOCK_SIZE/4 mov ecx, SHA256_BLOCK_SIZE/4
@@: @@:
xor dword[esi], 0x36363636 ; ipad constant xor dword[esi], 0x36363636 ; ipad constant
add esi, 4 add esi, 4
@ -84,15 +84,15 @@ endl
lea esi, [k_temp] lea esi, [k_temp]
DEBUGF 1, "HASH: " DEBUGF 1, "HASH: "
stdcall dump_hex, esi, SHA224256_BLOCK_SIZE/4 stdcall dump_hex, esi, SHA256_BLOCK_SIZE/4
mov ebx, [ctx] mov ebx, [ctx]
lea edi, [ebx+hmac_sha256_context.ipad_ctx] lea edi, [ebx+hmac_sha256_context.ipad_ctx]
invoke sha256_update, edi, esi, SHA224256_BLOCK_SIZE invoke sha256_update, edi, esi, SHA256_BLOCK_SIZE
; xor opad buffer with 0x5c5c5... ; xor opad buffer with 0x5c5c5...
lea esi, [k_temp] lea esi, [k_temp]
mov ecx, SHA224256_BLOCK_SIZE/4 mov ecx, SHA256_BLOCK_SIZE/4
@@: @@:
xor dword[esi], 0x36363636 xor 0x5c5c5c5c ; opad constant xor dword[esi], 0x36363636 xor 0x5c5c5c5c ; opad constant
add esi, 4 add esi, 4
@ -106,11 +106,11 @@ endl
lea esi, [k_temp] lea esi, [k_temp]
DEBUGF 1, "HASH: " DEBUGF 1, "HASH: "
stdcall dump_hex, esi, SHA224256_BLOCK_SIZE/4 stdcall dump_hex, esi, SHA256_BLOCK_SIZE/4
mov ebx, [ctx] mov ebx, [ctx]
lea edi, [ebx+hmac_sha256_context.opad_ctx] lea edi, [ebx+hmac_sha256_context.opad_ctx]
invoke sha256_update, edi, esi, SHA224256_BLOCK_SIZE invoke sha256_update, edi, esi, SHA256_BLOCK_SIZE
popa popa
ret ret
@ -124,8 +124,8 @@ endp
proc hmac_sha256 ctx, _data, _length proc hmac_sha256 ctx, _data, _length
locals locals
inner_ctx ctx_sha224256 inner_ctx crash_ctx
outer_ctx ctx_sha224256 outer_ctx crash_ctx
endl endl
pusha pusha
@ -138,7 +138,7 @@ endl
mov esi, [ctx] mov esi, [ctx]
lea esi, [esi+hmac_sha256_context.ipad_ctx] lea esi, [esi+hmac_sha256_context.ipad_ctx]
lea edi, [inner_ctx] lea edi, [inner_ctx]
repeat (sizeof.ctx_sha224256)/4*2 repeat (sizeof.crash_ctx)/4*2
movsd movsd
end repeat end repeat

View File

@ -165,8 +165,8 @@ struct ssh_connection
dh_signature dd ? dh_signature dd ?
rb MAX_BITS/8 rb MAX_BITS/8
temp_ctx ctx_sha224256 temp_ctx crash_ctx
k_h_ctx ctx_sha224256 k_h_ctx crash_ctx
mpint_tmp dd ? mpint_tmp dd ?
rb MAX_BITS/8 rb MAX_BITS/8