/programs/develop/libraries/libcrash/trunk/Tupfile.lua |
---|
1,3 → 1,5 |
if tup.getconfig("NO_FASM") ~= "" then return end |
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") |
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR") |
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") |
/programs/develop/libraries/libcrash/trunk/crc32.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,19 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
CRC32_HASH_SIZE = 4 |
CRC32_ALIGN = 4 |
CRC32_ALIGN_MASK = CRC32_ALIGN - 1 |
struct ctx_crc32 |
hash rd 1 |
ends |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_crc32 |
end if |
proc crc32.init _ctx |
mov ebx, [_ctx] |
lea edi, [ebx + ctx_crc32.hash] |
61,8 → 74,16 |
endp |
proc crc32.oneshot _ctx, _data, _len |
stdcall crc32.init, [_ctx] |
stdcall crc32.update, [_ctx], [_data], [_len] |
stdcall crc32.final, [_ctx] |
ret |
endp |
iglobal |
align CRC32_ALIGN |
crc32._.hash_init dd 0xffffffff |
crc32._.table dd \ |
109,4 → 130,4 |
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,\ |
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,\ |
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d |
endg |
/programs/develop/libraries/libcrash/trunk/libcrash.asm |
---|
19,11 → 19,11 |
public @EXPORT as 'EXPORTS' |
include '../../../../struct.inc' |
include '../../../../proc32.inc' |
include '../../../../macros.inc' |
include '../../../../config.inc' |
;include '../../../../debug.inc' |
include 'struct.inc' |
include 'proc32.inc' |
include 'macros.inc' |
include 'config.inc' |
include 'kglobals.inc' |
purge section,mov,add,sub |
section '.flat' code readable align 16 |
106,19 → 106,21 |
crash._.bin2hex_table db '0123456789abcdef' |
crash._.table dd \ |
crc32.init, crc32.update, crc32.final, CRC32_HASH_SIZE, \ |
md4.init, md4.update, md4.final, MD4_HASH_SIZE, \ |
md5.init, md5.update, md5.final, MD5_HASH_SIZE, \ |
sha1.init, sha1.update, sha1.final, SHA1_HASH_SIZE, \ |
sha224.init, sha224.update, sha224.final, SHA224_HASH_SIZE, \ |
sha256.init, sha256.update, sha256.final, SHA256_HASH_SIZE, \ |
sha384.init, sha384.update, sha384.final, SHA384_HASH_SIZE, \ |
sha512.init, sha512.update, sha512.final, SHA512_HASH_SIZE, \ |
sha3224.init, sha3224.update, sha3224.final, SHA3224_HASH_SIZE,\ |
sha3256.init, sha3256.update, sha3256.final, SHA3256_HASH_SIZE,\ |
sha3384.init, sha3384.update, sha3384.final, SHA3384_HASH_SIZE,\ |
sha3512.init, sha3512.update, sha3512.final, SHA3512_HASH_SIZE |
crc32.init, crc32.update, crc32.final, crc32.oneshot, CRC32_HASH_SIZE, \ |
md4.init, md4.update, md4.final, md4.oneshot, MD4_HASH_SIZE, \ |
md5.init, md5.update, md5.final, md5.oneshot, MD5_HASH_SIZE, \ |
sha1.init, sha1.update, sha1.final, sha1.oneshot, SHA1_HASH_SIZE, \ |
sha224.init, sha224.update, sha224.final, sha224.oneshot, SHA224_HASH_SIZE, \ |
sha256.init, sha256.update, sha256.final, sha256.oneshot, SHA256_HASH_SIZE, \ |
sha384.init, sha384.update, sha384.final, sha384.oneshot, SHA384_HASH_SIZE, \ |
sha512.init, sha512.update, sha512.final, sha512.oneshot, SHA512_HASH_SIZE, \ |
sha3_224.init, sha3_224.update, sha3_224.final, sha3_224.oneshot, SHA3_224_HASH_SIZE,\ |
sha3_256.init, sha3_256.update, sha3_256.final, sha3_256.oneshot, SHA3_256_HASH_SIZE,\ |
sha3_384.init, sha3_384.update, sha3_384.final, sha3_384.oneshot, SHA3_384_HASH_SIZE,\ |
sha3_512.init, sha3_512.update, sha3_512.final, sha3_512.oneshot, SHA3_512_HASH_SIZE |
IncludeIGlobals |
align 4 |
@EXPORT: |
129,36 → 131,48 |
crc32.init, 'crc32_init' , \ |
crc32.update, 'crc32_update' , \ |
crc32.final, 'crc32_final' , \ |
crc32.oneshot, 'crc32_oneshot' , \ |
md4.init, 'md4_init' , \ |
md4.update, 'md4_update' , \ |
md4.final, 'md4_final' , \ |
md4.oneshot, 'md4_oneshot' , \ |
md5.init, 'md5_init' , \ |
md5.update, 'md5_update' , \ |
md5.final, 'md5_final' , \ |
md5.oneshot, 'md5_oneshot' , \ |
sha1.init, 'sha1_init' , \ |
sha1.update, 'sha1_update' , \ |
sha1.final, 'sha1_final' , \ |
sha1.oneshot, 'sha1_oneshot' , \ |
sha224.init, 'sha224_init' , \ |
sha224.update, 'sha224_update' , \ |
sha224.final, 'sha224_final' , \ |
sha224.oneshot, 'sha224_oneshot' , \ |
sha256.init, 'sha256_init' , \ |
sha256.update, 'sha256_update' , \ |
sha256.final, 'sha256_final' , \ |
sha256.oneshot, 'sha256_oneshot' , \ |
sha384.init, 'sha384_init' , \ |
sha384.update, 'sha384_update' , \ |
sha384.final, 'sha384_final' , \ |
sha384.oneshot, 'sha384_oneshot' , \ |
sha512.init, 'sha512_init' , \ |
sha512.update, 'sha512_update' , \ |
sha512.final, 'sha512_final' , \ |
sha3224.init, 'sha3_224_init' , \ |
sha3224.update, 'sha3_224_update' , \ |
sha3224.final, 'sha3_224_final' , \ |
sha3256.init, 'sha3_256_init' , \ |
sha3256.update, 'sha3_256_update' , \ |
sha3256.final, 'sha3_256_final' , \ |
sha3384.init, 'sha3_384_init' , \ |
sha3384.update, 'sha3_384_update' , \ |
sha3384.final, 'sha3_384_final' , \ |
sha3512.init, 'sha3_512_init' , \ |
sha3512.update, 'sha3_512_update' , \ |
sha3512.final, 'sha3_512_final' |
sha512.oneshot, 'sha512_oneshot' , \ |
sha3_224.init, 'sha3_224_init' , \ |
sha3_224.update, 'sha3_224_update' , \ |
sha3_224.final, 'sha3_224_final' , \ |
sha3_224.oneshot, 'sha3_224_oneshot' , \ |
sha3_256.init, 'sha3_256_init' , \ |
sha3_256.update, 'sha3_256_update' , \ |
sha3_256.final, 'sha3_256_final' , \ |
sha3_256.oneshot, 'sha3_256_oneshot' , \ |
sha3_384.init, 'sha3_384_init' , \ |
sha3_384.update, 'sha3_384_update' , \ |
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' |
/programs/develop/libraries/libcrash/trunk/libcrash.inc |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
35,141 → 35,47 |
init dd ? |
update dd ? |
final dd ? |
oneshot dd ? |
len_out dd ? |
ends |
; CRC32 |
struct crash_ctx |
hash rb 1024 ; context starts with hash data |
ends |
CRC32_HASH_SIZE = 4 |
CRC32_ALIGN = 4 |
CRC32_ALIGN_MASK = CRC32_ALIGN - 1 |
CRC32_BLOCK_SIZE = 1 |
struct ctx_crc32 |
hash rd 1 |
ends |
; MD4 |
MD4_HASH_SIZE = 16 |
MD4_BLOCK_SIZE = 64 |
MD4_HASH_SIZE = 16 |
MD4_ALIGN = 4 |
MD4_ALIGN_MASK = MD4_ALIGN - 1 |
struct ctx_md4 |
hash rb MD4_HASH_SIZE |
block rb MD4_BLOCK_SIZE |
index rd 1 |
msglen_0 rd 1 |
msglen_1 rd 1 |
ends |
; MD5 |
MD5_HASH_SIZE = 16 |
MD5_BLOCK_SIZE = 64 |
MD5_HASH_SIZE = 16 |
MD5_ALIGN = 4 |
MD5_ALIGN_MASK = MD5_ALIGN - 1 |
struct ctx_md5 |
hash rb MD5_HASH_SIZE |
block rb MD5_BLOCK_SIZE |
index rd 1 |
msglen_0 rd 1 |
msglen_1 rd 1 |
ends |
; SHA1 |
SHA1_HASH_SIZE = 20 |
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 |
SHA224_HASH_SIZE = 28 |
SHA224_BLOCK_SIZE = 64 |
; 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 |
SHA256_BLOCK_SIZE = 64 |
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 |
SHA384_HASH_SIZE = 48 |
SHA384_BLOCK_SIZE = 128 |
SHA384512_BLOCK_SIZE = 128 |
SHA384512_INIT_SIZE = 64 |
SHA384_HASH_SIZE = 48 |
SHA512_HASH_SIZE = 64 |
SHA512_BLOCK_SIZE = 128 |
SHA384512_ALIGN = 16 |
SHA384512_ALIGN_MASK = SHA384512_ALIGN - 1 |
SHA3_224_HASH_SIZE = 28 |
SHA3_224_BLOCK_SIZE = 144 |
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_256_HASH_SIZE = 32 |
SHA3_256_BLOCK_SIZE = 136 |
; SHA3 |
SHA3_384_HASH_SIZE = 48 |
SHA3_384_BLOCK_SIZE = 104 |
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 |
SHA3_512_HASH_SIZE = 64 |
SHA3_512_BLOCK_SIZE = 72 |
/programs/develop/libraries/libcrash/trunk/md4.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,24 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
MD4_HASH_SIZE = 16 |
MD4_BLOCK_SIZE = 64 |
MD4_ALIGN = 4 |
MD4_ALIGN_MASK = MD4_ALIGN - 1 |
struct ctx_md4 |
hash rb MD4_HASH_SIZE |
block rb MD4_BLOCK_SIZE |
index rd 1 |
msglen_0 rd 1 |
msglen_1 rd 1 |
ends |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_md4 |
end if |
macro md4._.f b, c, d |
{ |
mov eax, c |
231,7 → 249,15 |
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 |
/programs/develop/libraries/libcrash/trunk/md5.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,24 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
MD5_HASH_SIZE = 16 |
MD5_BLOCK_SIZE = 64 |
MD5_ALIGN = 4 |
MD5_ALIGN_MASK = MD5_ALIGN - 1 |
struct ctx_md5 |
hash rb MD5_HASH_SIZE |
block rb MD5_BLOCK_SIZE |
index rd 1 |
msglen_0 rd 1 |
msglen_1 rd 1 |
ends |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_md5 |
end if |
macro md5._.f b, c, d |
{ |
push c |
259,7 → 277,15 |
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 |
/programs/develop/libraries/libcrash/trunk/sha1.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,24 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
SHA1_HASH_SIZE = 20 |
SHA1_BLOCK_SIZE = 64 |
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 |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_sha1 |
end if |
proc sha1._.f |
push ebx ecx edx |
xor ecx, edx |
267,7 → 285,15 |
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 |
/programs/develop/libraries/libcrash/trunk/sha224_256.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,29 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
SHA224256_BLOCK_SIZE = 64 |
SHA224_BLOCK_SIZE = SHA224256_BLOCK_SIZE |
SHA256_BLOCK_SIZE = SHA224256_BLOCK_SIZE |
SHA224_HASH_SIZE = 28 |
SHA256_HASH_SIZE = 32 |
SHA224256_INIT_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 |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_sha224256 |
end if |
macro sha224256._.chn x, y, z |
{ |
mov eax, [y] |
253,8 → 276,10 |
ret |
endp |
sha256.update = sha224.update |
proc sha224.update _ctx, _msg, _size |
sha224.update = sha224256.update |
sha256.update = sha224256.update |
proc sha224256.update _ctx, _msg, _size |
mov ebx, [_ctx] |
mov ecx, [_size] |
add [ebx + ctx_sha224256.msglen_0], ecx |
310,8 → 335,9 |
endp |
sha256.final = sha224.final |
proc sha224.final _ctx |
sha224.final = sha224256.final |
sha256.final = sha224256.final |
proc sha224256.final _ctx |
mov ebx, [_ctx] |
lea edi, [ebx + ctx_sha224256.block] |
mov ecx, [ebx + ctx_sha224256.msglen_0] |
372,8 → 398,24 |
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 |
396,4 → 438,4 |
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\ |
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\ |
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 |
endg |
/programs/develop/libraries/libcrash/trunk/sha3.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,39 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
SHA3_224_HASH_SIZE = 28 |
SHA3_256_HASH_SIZE = 32 |
SHA3_384_HASH_SIZE = 48 |
SHA3_512_HASH_SIZE = 64 |
SHA3_224_BLOCK_SIZE = 144 |
SHA3_256_BLOCK_SIZE = 136 |
SHA3_384_BLOCK_SIZE = 104 |
SHA3_512_BLOCK_SIZE = 72 |
SHA3MAX_BLOCK_SIZE = SHA3_224_BLOCK_SIZE |
SHA3_INIT_SIZE = 200 |
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 |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_sha3 |
end if |
macro sha3._.rol_xor nd, ncl, ncr |
{ |
movq mm0, [C + 8*(ncl)] |
244,33 → 277,33 |
endp |
proc sha3224.init _ctx |
proc sha3_224.init _ctx |
mov ebx, [_ctx] |
mov eax, SHA3224_BLOCK_SIZE |
mov eax, SHA3_224_BLOCK_SIZE |
stdcall sha3._.init |
ret |
endp |
proc sha3256.init _ctx |
proc sha3_256.init _ctx |
mov ebx, [_ctx] |
mov eax, SHA3256_BLOCK_SIZE |
mov eax, SHA3_256_BLOCK_SIZE |
stdcall sha3._.init |
ret |
endp |
proc sha3384.init _ctx |
proc sha3_384.init _ctx |
mov ebx, [_ctx] |
mov eax, SHA3384_BLOCK_SIZE |
mov eax, SHA3_384_BLOCK_SIZE |
stdcall sha3._.init |
ret |
endp |
proc sha3512.init _ctx |
proc sha3_512.init _ctx |
mov ebx, [_ctx] |
mov eax, SHA3512_BLOCK_SIZE |
mov eax, SHA3_512_BLOCK_SIZE |
stdcall sha3._.init |
ret |
endp |
293,10 → 326,10 |
endp |
sha3224.update = sha3.update |
sha3256.update = sha3.update |
sha3384.update = sha3.update |
sha3512.update = sha3.update |
sha3_224.update = sha3.update |
sha3_256.update = sha3.update |
sha3_384.update = sha3.update |
sha3_512.update = sha3.update |
proc sha3.update _ctx, _msg, _size |
.next_block: |
mov ebx, [_ctx] |
355,10 → 388,10 |
endp |
sha3224.final = sha3.final |
sha3256.final = sha3.final |
sha3384.final = sha3.final |
sha3512.final = sha3.final |
sha3_224.final = sha3.final |
sha3_256.final = sha3.final |
sha3_384.final = sha3.final |
sha3_512.final = sha3.final |
proc sha3.final _ctx |
pushad |
mov ebx, [_ctx] |
404,8 → 437,40 |
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,\ |
414,4 → 479,4 |
0x8000000000008003, 0x8000000000008002, 0x8000000000000080,\ |
0x000000000000800A, 0x800000008000000A, 0x8000000080008081,\ |
0x8000000000008080, 0x0000000080000001, 0x8000000080008008 |
endg |
/programs/develop/libraries/libcrash/trunk/sha384_512.asm |
---|
1,6 → 1,6 |
; 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 |
; it under the terms of the GNU General Public License as published by |
16,6 → 16,42 |
; along with this program. If not, see <http://www.gnu.org/licenses/>. |
SHA384512_BLOCK_SIZE = 128 |
SHA384_BLOCK_SIZE = SHA384512_BLOCK_SIZE |
SHA512_BLOCK_SIZE = SHA384512_BLOCK_SIZE |
SHA384_HASH_SIZE = 48 |
SHA512_HASH_SIZE = 64 |
SHA384512_INIT_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 |
if defined sizeof.crash_ctx |
assert sizeof.crash_ctx >= sizeof.ctx_sha384512 |
end if |
macro sha384512._.chn x, y, z |
{ |
movq mm0, [y] |
318,8 → 354,10 |
restore w,A,B,C,D,E,F,G,H,temp |
endp |
sha512.update = sha384.update |
proc sha384.update _ctx, _msg, _size |
sha384.update = sha384512.update |
sha512.update = sha384512.update |
proc sha384512.update _ctx, _msg, _size |
mov ebx, [_ctx] |
mov ecx, [_size] |
add [ebx + ctx_sha384512.msglen_0], ecx |
377,8 → 415,9 |
endp |
sha512.final = sha384.final |
proc sha384.final _ctx |
sha384.final = sha384512.final |
sha512.final = sha384512.final |
proc sha384512.final _ctx |
mov ebx, [_ctx] |
lea edi, [ebx + ctx_sha384512.block] |
mov ecx, [ebx + ctx_sha384512.msglen_0] |
456,8 → 495,24 |
endp |
proc sha384.oneshot _ctx, _data, _len |
stdcall sha384.init, [_ctx] |
stdcall sha384.update, [_ctx], [_data], [_len] |
stdcall sha384.final, [_ctx] |
ret |
endp |
proc sha512.oneshot _ctx, _data, _len |
stdcall sha512.init, [_ctx] |
stdcall sha512.update, [_ctx], [_data], [_len] |
stdcall sha512.final, [_ctx] |
ret |
endp |
iglobal |
align SHA384512_ALIGN |
sha384._.hash_init dq 0xcbbb9d5dc1059ed8, 0x629a292a367cd507,\ |
0x9159015a3070dd17, 0x152fecd8f70e5939,\ |
0x67332667ffc00b31, 0x8eb44a8768581511,\ |
508,4 → 563,4 |
0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c,\ |
0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,\ |
0x5fcb6fab3ad6faec, 0x6c44198c4a475817 |
endg |
/programs/network/ssh/dh_gex.inc |
---|
231,7 → 231,7 |
mov esi, con.k_h_ctx |
mov edi, con.temp_ctx |
mov ecx, sizeof.ctx_sha224256/4 |
mov ecx, sizeof.crash_ctx |
rep movsd |
mov [con.session_id_prefix], 'A' |
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 |
249,7 → 249,7 |
mov esi, con.k_h_ctx |
mov edi, con.temp_ctx |
mov ecx, sizeof.ctx_sha224256/4 |
mov ecx, sizeof.crash_ctx/4 |
rep movsd |
inc [con.session_id_prefix] |
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 |
267,7 → 267,7 |
mov esi, con.k_h_ctx |
mov edi, con.temp_ctx |
mov ecx, sizeof.ctx_sha224256/4 |
mov ecx, sizeof.crash_ctx |
rep movsd |
inc [con.session_id_prefix] |
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 |
285,7 → 285,7 |
mov esi, con.k_h_ctx |
mov edi, con.temp_ctx |
mov ecx, sizeof.ctx_sha224256/4 |
mov ecx, sizeof.crash_ctx/4 |
rep movsd |
inc [con.session_id_prefix] |
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 |
303,7 → 303,7 |
mov esi, con.k_h_ctx |
mov edi, con.temp_ctx |
mov ecx, sizeof.ctx_sha224256/4 |
mov ecx, sizeof.crash_ctx/4 |
rep movsd |
inc [con.session_id_prefix] |
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 |
321,7 → 321,7 |
mov esi, con.k_h_ctx |
mov edi, con.temp_ctx |
mov ecx, sizeof.ctx_sha224256/4 |
mov ecx, sizeof.crash_ctx/4 |
rep movsd |
inc [con.session_id_prefix] |
invoke sha256_update, con.temp_ctx, con.session_id_prefix, 32+1 |
/programs/network/ssh/hmac_md5.inc |
---|
22,8 → 22,8 |
struct hmac_md5_context |
hash rb MD5_HASH_SIZE |
ipad_ctx ctx_md5 |
opad_ctx ctx_md5 |
ipad_ctx crash_ctx |
opad_ctx crash_ctx |
ends |
; We will precompute partial hashes of K XOR ipad and K XOR opad, |
/programs/network/ssh/hmac_sha1.inc |
---|
22,8 → 22,8 |
struct hmac_sha1_context |
hash rb SHA1_HASH_SIZE |
ipad_ctx ctx_sha1 |
opad_ctx ctx_sha1 |
ipad_ctx crash_ctx |
opad_ctx crash_ctx |
ends |
; We will precompute partial hashes of K XOR ipad and K XOR opad, |
/programs/network/ssh/hmac_sha256.inc |
---|
22,8 → 22,8 |
struct hmac_sha256_context |
hash rb SHA256_HASH_SIZE |
ipad_ctx ctx_sha224256 |
opad_ctx ctx_sha224256 |
ipad_ctx crash_ctx |
opad_ctx crash_ctx |
ends |
; We will precompute partial hashes of K XOR ipad and K XOR opad, |
32,7 → 32,7 |
proc hmac_sha256_setkey ctx, key, key_length |
locals |
k_temp rb SHA224256_BLOCK_SIZE |
k_temp rb SHA256_BLOCK_SIZE |
endl |
pusha |
39,7 → 39,7 |
; input esi = key, ecx=key_length |
mov ecx, [key_length] |
cmp ecx, SHA224256_BLOCK_SIZE |
cmp ecx, SHA256_BLOCK_SIZE |
ja .hash_it |
; Key is smaller then or equal to blocksize, |
; copy key to ipad |
46,7 → 46,7 |
mov esi, [key] |
lea edi, [k_temp] |
rep movsb |
mov ecx, SHA224256_BLOCK_SIZE |
mov ecx, SHA256_BLOCK_SIZE |
sub ecx, [key_length] |
jz .finish |
; append zeros to the key |
64,13 → 64,13 |
mov ecx, SHA256_HASH_SIZE/4 |
rep movsd |
xor eax, eax |
mov ecx, (SHA224256_BLOCK_SIZE-SHA256_HASH_SIZE)/4 |
mov ecx, (SHA256_BLOCK_SIZE-SHA256_HASH_SIZE)/4 |
rep stosd |
.finish: |
; xor ipad buffer with 0x36363... |
lea esi, [k_temp] |
mov ecx, SHA224256_BLOCK_SIZE/4 |
mov ecx, SHA256_BLOCK_SIZE/4 |
@@: |
xor dword[esi], 0x36363636 ; ipad constant |
add esi, 4 |
84,15 → 84,15 |
lea esi, [k_temp] |
DEBUGF 1, "HASH: " |
stdcall dump_hex, esi, SHA224256_BLOCK_SIZE/4 |
stdcall dump_hex, esi, SHA256_BLOCK_SIZE/4 |
mov ebx, [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... |
lea esi, [k_temp] |
mov ecx, SHA224256_BLOCK_SIZE/4 |
mov ecx, SHA256_BLOCK_SIZE/4 |
@@: |
xor dword[esi], 0x36363636 xor 0x5c5c5c5c ; opad constant |
add esi, 4 |
106,11 → 106,11 |
lea esi, [k_temp] |
DEBUGF 1, "HASH: " |
stdcall dump_hex, esi, SHA224256_BLOCK_SIZE/4 |
stdcall dump_hex, esi, SHA256_BLOCK_SIZE/4 |
mov ebx, [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 |
ret |
124,8 → 124,8 |
proc hmac_sha256 ctx, _data, _length |
locals |
inner_ctx ctx_sha224256 |
outer_ctx ctx_sha224256 |
inner_ctx crash_ctx |
outer_ctx crash_ctx |
endl |
pusha |
138,7 → 138,7 |
mov esi, [ctx] |
lea esi, [esi+hmac_sha256_context.ipad_ctx] |
lea edi, [inner_ctx] |
repeat (sizeof.ctx_sha224256)/4*2 |
repeat (sizeof.crash_ctx)/4*2 |
movsd |
end repeat |
/programs/network/ssh/ssh.asm |
---|
165,8 → 165,8 |
dh_signature dd ? |
rb MAX_BITS/8 |
temp_ctx ctx_sha224256 |
k_h_ctx ctx_sha224256 |
temp_ctx crash_ctx |
k_h_ctx crash_ctx |
mpint_tmp dd ? |
rb MAX_BITS/8 |