| 0,0 → 1,468 |
|---|
| ; libcrash -- cryptographic hash (and other) functions |
| ; |
| ; Copyright (C) <2012-2014,2016,2019,2021> Ivan Baravy |
| ; |
| ; SPDX-License-Identifier: GPL-2.0-or-later |
| ; |
| ; 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 the Free Software |
| ; Foundation, either version 2 of the License, or (at your option) any later |
| ; version. |
| ; |
| ; This program is distributed in the hope that it will be useful, but WITHOUT |
| ; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| ; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
| ; |
| ; You should have received a copy of the GNU General Public License along with |
| ; this program. If not, see <http://www.gnu.org/licenses/>. |
| |
| format MS COFF |
| |
| public @EXPORT as 'EXPORTS' |
| |
| include 'proc32.inc' |
| include 'struct.inc' |
| include 'macros.inc' |
| include 'kglobals.inc' |
| |
| purge section,mov,add,sub |
| section '.flat' code readable align 16 |
| |
| include 'libcrash.inc' |
| include 'hash/crc32.asm' |
| include 'hash/md5.asm' |
| include 'hash/sha1.asm' |
| include 'hash/sha2_224_256.asm' |
| include 'hash/sha2_384_512.asm' |
| include 'hash/sha3.asm' |
| include 'mac/poly1305.asm' |
| include 'mac/hmac.asm' |
| include 'cipher/chacha20.asm' |
| include 'cipher/mode/ctr.asm' |
| include 'cipher/mode/cbc.asm' |
| include 'cipher/aes.asm' |
| include 'cipher/aes_ctr.asm' |
| include 'cipher/aes_cbc.asm' |
| |
| LIBCRASH_BUF_SIZE = 0x1000 |
| |
| struct hash_item |
| init dd ? |
| update dd ? |
| finish dd ? |
| oneshot dd ? |
| ctx_size dd ? |
| out_size dd ? |
| ends |
| |
| struct mac_item |
| init dd ? |
| update dd ? |
| finish dd ? |
| oneshot dd ? |
| ctx_size dd ? |
| out_size dd ? |
| ends |
| |
| struct cipher_item ; FIXME merge *_item, why not |
| init dd ? |
| update dd ? |
| finish dd ? |
| oneshot dd ? |
| ctx_size dd ? |
| dd ? ; placeholder for out_size |
| ends |
| |
| ; Initialize the library. |
| ; This must be the first called function of the library. |
| ; Parameters: |
| ; eax = function pointer to allocate memory: |
| ; stdcall void *alloc(size_t size) |
| ; ebx = function pointer to free memory: |
| ; stdcall void free(void *ptr) |
| ; Return value: none |
| proc crash.init |
| mov [mem.alloc], eax |
| mov [mem.free], ebx |
| ret |
| endp |
| |
| ; Hash data read by a callback read function. |
| ; The function calls the read callback until it returns 0, and hashes the read |
| ; data with the specified algorithm. The result is written to the specified |
| ; buffer in binary format. |
| ; Parameters: |
| ; [_id] = ID of a hash function to use. |
| ; [_clbk_read] = function pointer to read data: |
| ; stdcall ssize_t clbk_read(void *user, void *buf, size_t size) |
| ; [_user] = pointer to user-specified data passed to the read callback as is. |
| ; [_out] = buffer pointer where a hash value is to be written to. |
| ; Return value: |
| ; binary hash value in [_out] buffer. |
| proc crash.hash uses ebx esi edi, _id, _clbk_read, _user, _out |
| locals |
| .ctx dd ? |
| .buf dd ? |
| endl |
| ; alloc buf |
| mov eax, [io_buf_size] |
| add eax, LIBCRASH_MAX_PAD_LEN |
| stdcall [mem.alloc], eax |
| test eax, eax |
| jz .quit |
| mov [.buf], eax |
| ; alloc ctx |
| mov eax, [_id] |
| imul eax, sizeof.hash_item |
| lea ebx, [crash._.hash_table+eax] |
| stdcall [mem.alloc], [ebx+hash_item.ctx_size] |
| test eax, eax |
| jz .quit_free_buf |
| mov [.ctx], eax |
| |
| stdcall [ebx+hash_item.init], [.ctx] |
| .update: |
| stdcall [_clbk_read], [_user], [.buf], [io_buf_size] |
| test eax, eax |
| jz .finish |
| stdcall [ebx+hash_item.update], [.ctx], [.buf], eax |
| jmp .update |
| .finish: |
| stdcall [ebx+hash_item.finish], [.ctx] |
| mov esi, [.ctx] |
| mov edi, [_out] |
| mov ecx, [ebx+hash_item.out_size] |
| rep movsd |
| .quit_free_buf_ctx: |
| stdcall [mem.free], [.ctx] |
| .quit_free_buf: |
| stdcall [mem.free], [.buf] |
| .quit: |
| ret |
| endp |
| |
| ; Calculate MAC of data read by a callback read function. |
| ; The function calls the read callback until it returns 0, and calculates a MAC |
| ; using a specified algorithm and a key. The result is written to the specified |
| ; buffer. |
| ; Parameters: |
| ; [_id] = ID of a MAC function to use. |
| ; [_key] = key pointer, no NULL terminator is needed |
| ; [_key_len] = length of the [_key] data, in bytes |
| ; [_clbk_read] = function pointer to read data: |
| ; stdcall ssize_t clbk_read(void *user, void *buf, size_t size) |
| ; [_user] = pointer to user-specified data passed to the read callback as is. |
| ; [_out] = buffer pointer where a MAC value is to be written to. |
| ; Return value: |
| ; Binary MAC value in [_out] buffer. |
| proc crash.mac uses ebx esi edi, _id, _key, _key_len, _clbk_read, _user, _out |
| locals |
| .ctx dd ? |
| .buf dd ? |
| endl |
| ; alloc buf |
| mov eax, [io_buf_size] |
| add eax, LIBCRASH_MAX_PAD_LEN |
| stdcall [mem.alloc], eax |
| test eax, eax |
| jz .quit |
| mov [.buf], eax |
| ; alloc ctx |
| mov eax, [_id] |
| imul eax, sizeof.mac_item |
| lea ebx, [crash._.mac_table+eax] |
| stdcall [mem.alloc], [ebx+mac_item.ctx_size] |
| test eax, eax |
| jz .quit_free_buf |
| mov [.ctx], eax |
| |
| stdcall [ebx+mac_item.init], [.ctx], [_key], [_key_len] |
| .update: |
| stdcall [_clbk_read], [_user], [.buf], [io_buf_size] |
| test eax, eax |
| jz .finish |
| stdcall [ebx+mac_item.update], [.ctx], [.buf], eax |
| jmp .update |
| .finish: |
| stdcall [ebx+mac_item.finish], [.ctx] |
| mov esi, [.ctx] |
| mov edi, [_out] |
| mov ecx, [ebx+mac_item.out_size] |
| rep movsd |
| .quit_free_buf_ctx: |
| stdcall [mem.free], [.ctx] |
| .quit_free_buf: |
| stdcall [mem.free], [.buf] |
| .quit: |
| ret |
| endp |
| |
| ; Encrypt or decrypt data read by a callback read function. |
| ; The function calls the read callback until it returns 0, and encrypts or |
| ; decrypts the data using a specified algorithm, a key and an input vector. |
| ; The result is passed to the write callback function. |
| ; * The maximum difference in input/output data lengths is LIBCRASH_MAX_PAD_LEN. |
| ; * The input and output buffers can sometimes be the same buffer depending on |
| ; the cipher. If unsure, use different buffers. |
| ; Parameters: |
| ; [_id] = ID of a MAC function to use. |
| ; [_flags] = see LIBCRASH_CIPHER_* in libcrash.inc |
| ; [_key] = key pointer, NULL terminated |
| ; [_iv] = input vector pointer, no NULL terminator is needed |
| ; [_clbk_read] = function pointer to read data: |
| ; stdcall ssize_t clbk_read(void *user, void *buf, size_t size) |
| ; [_user_read] = pointer to user-specified data passed to the read callback. |
| ; [_clbk_write] = function pointer to write data: |
| ; stdcall void clbk_write(void *user, void *buf, size_t size) |
| ; [_user_write] = pointer to user-specified data passed to the write callback. |
| ; Return value: none |
| proc crash.crypt uses ebx esi edi, _id, _flags, _key, _iv, _clbk_read, \ |
| _user_read, _clbk_write, _user_write |
| locals |
| .ctx dd ? |
| .buf dd ? |
| .buf_in dd ? |
| .buf_out dd ? |
| endl |
| ; alloc buf |
| mov eax, [io_buf_size] |
| mov [.buf_out], eax |
| shl eax, 1 |
| add eax, LIBCRASH_MAX_PAD_LEN |
| stdcall [mem.alloc], eax |
| test eax, eax |
| jz .quit |
| mov [.buf], eax |
| mov [.buf_in], eax |
| add [.buf_out], eax |
| ; alloc ctx |
| mov eax, [_id] |
| imul eax, sizeof.cipher_item |
| lea ebx, [crash._.cipher_table+eax] |
| stdcall [mem.alloc], [ebx+cipher_item.ctx_size] |
| test eax, eax |
| jz .quit_free_buf |
| mov [.ctx], eax |
| |
| stdcall [ebx+cipher_item.init], [.ctx], [_key], [_iv], [_flags] |
| .update: |
| stdcall [_clbk_read], [_user_read], [.buf_in], [io_buf_size] |
| test eax, eax |
| jz .finish |
| stdcall [ebx+cipher_item.update], [.ctx], [.buf_in], eax, [.buf_out] |
| stdcall [_clbk_write], [_user_write], [.buf_out], eax |
| jmp .update |
| .finish: |
| stdcall [ebx+cipher_item.finish], [.ctx], [.buf_out] |
| stdcall [_clbk_write], [_user_write], [.buf_out], eax |
| .quit_free_buf_ctx: |
| stdcall [mem.free], [.ctx] |
| .quit_free_buf: |
| stdcall [mem.free], [.buf] |
| .quit: |
| ret |
| endp |
| |
| ; These crash.*_oneshot functions below are wrappers to <hash_name>.oneshot, |
| ; <mac_name>.oneshot and <cipher_name>.oneshot functions. The functions pop |
| ; [_id] argument from the stack and jump to the oneshot function of the |
| ; corresponding algorithm with all the other arguments in place. |
| ; You can also call <hash_name/mac_name/cipher_name>.oneshot functions directly. |
| |
| ; Hash data in a buffer. |
| ; The function hashes data in the specified buffer with the specified algorithm. |
| ; The result is written to the very beginning of the specified context buffer in |
| ; binary format. |
| ; Parameters: |
| ; [_id] = ID of a hash function to use. |
| ; [_ctx] = buffer pointer for internal use, LIBCRASH_CTX_LEN bytes is enough. |
| ; [_in] = pointer to input data |
| ; [_len] = length of input data |
| ; Return value: |
| ; binary hash value in [_ctx] buffer. |
| crash.hash_oneshot: ; _id, _ctx, _in, _len |
| pop eax |
| xchg eax, [esp] |
| imul eax, sizeof.hash_item |
| lea eax, [crash._.hash_table+eax] |
| jmp [eax+hash_item.oneshot] |
| |
| ; Calculate MAC of data in the buffer. |
| ; The function calculates a MAC of data in the specified buffer with the |
| ; specified algorithm and key. The result is written to the very beginning of |
| ; the specified context buffer in binary format. |
| ; Parameters: |
| ; [_id] = ID of a hash function to use. |
| ; [_ctx] = buffer pointer for internal use, LIBCRASH_CTX_LEN bytes is enough. |
| ; [_in] = pointer to input data |
| ; [_len] = length of input data |
| ; [_key] = key pointer, no NULL terminator is needed |
| ; [_key_len] = length of the [_key] data, in bytes |
| ; Return value: |
| ; binary MAC value in [_ctx] buffer. |
| crash.mac_oneshot: ; _id, _ctx, _in, _len, _key, _key_len |
| pop eax |
| xchg eax, [esp] |
| imul eax, sizeof.mac_item |
| lea eax, [crash._.mac_table+eax] |
| jmp [eax+mac_item.oneshot] |
| |
| ; Encrypt or decrypt data in buffer. |
| ; The function encrypts or decrypts data in the specified buffer using a |
| ; specified algorithm, a key and an input vector. The result is written to |
| ; another specified buffer. |
| ; * The input and output buffers can sometimes be the same buffer depending on |
| ; the cipher. If unsure, use different buffers. |
| ; * The maximum difference in input/output data lengths is LIBCRASH_MAX_PAD_LEN. |
| ; Parameters: |
| ; [_id] = ID of a MAC function to use. |
| ; [_ctx] = buffer pointer for internal use, LIBCRASH_CTX_LEN bytes is enough. |
| ; [_key] = key pointer, NULL terminated |
| ; [_iv] = input vector pointer, no NULL terminator is needed |
| ; [_flags] = see LIBCRASH_CIPHER_* in libcrash.inc |
| ; [_in] = pointer to input data |
| ; [_len] = length of input data |
| ; [_out] = pointer to output data |
| ; Return value: none |
| crash.crypt_oneshot: ; _id, _ctx, _key, _iv, _flags, _in, _len, _out |
| pop eax |
| xchg eax, [esp] |
| imul eax, sizeof.cipher_item |
| lea eax, [crash._.cipher_table+eax] |
| jmp [eax+cipher_item.oneshot] |
| |
| section '.data' writeable align 16 |
| mem.alloc dd ? |
| mem.free dd ? |
| io_buf_size dd LIBCRASH_BUF_SIZE |
| ; FIXME: IDs shouldn't be indexes, should they? |
| align 4 |
| crash._.hash_table dd \ |
| crc32.init, crc32.update, crc32.finish, crc32.oneshot, \ |
| sizeof.ctx_crc32, CRC32_LEN/4, \ |
| md5.init, md5.update, md5.finish, md5.oneshot, \ |
| sizeof.ctx_md5, MD5_LEN/4, \ |
| sha1.init, sha1.update, sha1.finish, sha1.oneshot, \ |
| sizeof.ctx_sha1, SHA1_LEN/4, \ |
| sha2_224.init, sha2_224.update, sha2_224.finish, sha2_224.oneshot, \ |
| sizeof.ctx_sha2_224256, SHA2_224_LEN/4, \ |
| sha2_256.init, sha2_256.update, sha2_256.finish, sha2_256.oneshot, \ |
| sizeof.ctx_sha2_224256, SHA2_256_LEN/4, \ |
| sha2_384.init, sha2_384.update, sha2_384.finish, sha2_384.oneshot, \ |
| sizeof.ctx_sha2_384512, SHA2_384_LEN/4, \ |
| sha2_512.init, sha2_512.update, sha2_512.finish, sha2_512.oneshot, \ |
| sizeof.ctx_sha2_384512, SHA2_512_LEN/4, \ |
| sha3_224.init, sha3.update, sha3.finish, sha3_224.oneshot, \ |
| sizeof.ctx_sha3, SHA3_224_LEN/4, \ |
| sha3_256.init, sha3.update, sha3.finish, sha3_256.oneshot, \ |
| sizeof.ctx_sha3, SHA3_256_LEN/4, \ |
| sha3_384.init, sha3.update, sha3.finish, sha3_384.oneshot, \ |
| sizeof.ctx_sha3, SHA3_384_LEN/4, \ |
| sha3_512.init, sha3.update, sha3.finish, sha3_512.oneshot, \ |
| sizeof.ctx_sha3, SHA3_512_LEN/4, \ |
| 0 |
| |
| align 4 |
| crash._.mac_table dd \ |
| poly1305.init, poly1305.update, poly1305.finish, \ |
| poly1305.oneshot, sizeof.ctx_poly1305, POLY1305_LEN/4, \ |
| hmac_sha2_256.init, hmac_sha2_256.update, hmac_sha2_256.finish, \ |
| hmac_sha2_256.oneshot, sizeof.ctx_hmac, HMAC_SHA2_256_LEN/4, \ |
| hmac_sha2_512.init, hmac_sha2_512.update, hmac_sha2_512.finish, \ |
| hmac_sha2_512.oneshot, sizeof.ctx_hmac, HMAC_SHA2_512_LEN/4, \ |
| 0 |
| |
| align 4 |
| crash._.cipher_table dd \ |
| chacha20.init, chacha20.update, chacha20.finish, chacha20.oneshot, \ |
| sizeof.ctx_chacha20, 0, \ |
| aes256ctr.init, aes256ctr.update, aes256ctr.finish, aes256ctr.oneshot, \ |
| sizeof.ctx_aes_ctr, 0, \ |
| aes256cbc.init, aes256cbc.update, aes256cbc.finish, aes256cbc.oneshot, \ |
| sizeof.ctx_aes_cbc, 0, \ |
| 0 |
| |
| IncludeIGlobals |
| |
| align 4 |
| @EXPORT: |
| |
| export \ |
| crash.init, "lib_init", \ |
| crash.hash, "crash_hash", \ |
| crash.mac, "crash_mac", \ |
| crash.crypt, "crash_crypt", \ |
| crash.hash_oneshot, "crash_hash_oneshot", \ |
| crash.mac_oneshot, "crash_mac_oneshot", \ |
| crash.crypt_oneshot, "crash_crypt_oneshot", \ |
| \ |
| crc32.init, "crc32_init", \ |
| crc32.update, "crc32_update", \ |
| crc32.finish, "crc32_finish", \ |
| crc32.oneshot, "crc32_oneshot", \ |
| md5.init, "md5_init", \ |
| md5.update, "md5_update", \ |
| md5.finish, "md5_finish", \ |
| md5.oneshot, "md5_oneshot", \ |
| sha1.init, "sha1_init", \ |
| sha1.update, "sha1_update", \ |
| sha1.finish, "sha1_finish", \ |
| sha1.oneshot, "sha1_oneshot", \ |
| sha2_224.init, "sha2_224_init", \ |
| sha2_224.update, "sha2_224_update", \ |
| sha2_224.finish, "sha2_224_finish", \ |
| sha2_224.oneshot, "sha2_224_oneshot", \ |
| sha2_256.init, "sha2_256_init", \ |
| sha2_256.update, "sha2_256_update", \ |
| sha2_256.finish, "sha2_256_finish", \ |
| sha2_256.oneshot, "sha2_256_oneshot", \ |
| sha2_384.init, "sha2_384_init", \ |
| sha2_384.update, "sha2_384_update", \ |
| sha2_384.finish, "sha2_384_finish", \ |
| sha2_384.oneshot, "sha2_384_oneshot", \ |
| sha2_512.init, "sha2_512_init", \ |
| sha2_512.update, "sha2_512_update", \ |
| sha2_512.finish, "sha2_512_finish", \ |
| sha2_512.oneshot, "sha2_512_oneshot", \ |
| sha3_224.init, "sha3_224_init", \ |
| sha3_224.update, "sha3_224_update", \ |
| sha3_224.finish, "sha3_224_finish", \ |
| sha3_224.oneshot, "sha3_224_oneshot", \ |
| sha3_256.init, "sha3_256_init", \ |
| sha3_256.update, "sha3_256_update", \ |
| sha3_256.finish, "sha3_256_finish", \ |
| sha3_256.oneshot, "sha3_256_oneshot", \ |
| sha3_384.init, "sha3_384_init", \ |
| sha3_384.update, "sha3_384_update", \ |
| sha3_384.finish, "sha3_384_finish", \ |
| sha3_384.oneshot, "sha3_384_oneshot", \ |
| sha3_512.init, "sha3_512_init", \ |
| sha3_512.update, "sha3_512_update", \ |
| sha3_512.finish, "sha3_512_finish", \ |
| sha3_512.oneshot, "sha3_512_oneshot", \ |
| \ |
| poly1305.init, "poly1305_init", \ |
| poly1305.update, "poly1305_update", \ |
| poly1305.finish, "poly1305_finish", \ |
| poly1305.oneshot, "poly1305_oneshot", \ |
| hmac_sha2_256.init, "hmac_sha2_256_init", \ |
| hmac_sha2_256.update, "hmac_sha2_256_update", \ |
| hmac_sha2_256.finish, "hmac_sha2_256_finish", \ |
| hmac_sha2_256.oneshot, "hmac_sha2_256_oneshot", \ |
| hmac_sha2_512.init, "hmac_sha2_512_init", \ |
| hmac_sha2_512.update, "hmac_sha2_512_update", \ |
| hmac_sha2_512.finish, "hmac_sha2_512_finish", \ |
| hmac_sha2_512.oneshot, "hmac_sha2_512_oneshot", \ |
| \ |
| chacha20.init, "chacha20_init", \ |
| chacha20.update, "chacha20_update", \ |
| chacha20.finish, "chacha20_finish", \ |
| chacha20.oneshot, "chacha20_oneshot", \ |
| aes256ctr.init, "aes256ctr_init", \ |
| aes256ctr.update, "aes256ctr_update", \ |
| aes256ctr.finish, "aes256ctr_finish", \ |
| aes256ctr.oneshot, "aes256ctr_oneshot", \ |
| aes256cbc.init, "aes256cbc_init", \ |
| aes256cbc.update, "aes256cbc_update", \ |
| aes256cbc.finish, "aes256cbc_finish", \ |
| aes256cbc.oneshot, "aes256cbc_oneshot" |