1

Тема: [FASM] sha256

sha256. Не імплементація, а ріп, бо треба було швидко і чотко. Також для порівняння створено proc на CryptoApi

sha256.asm

    use32

sha256:
    push ebp
    mov ebp, esp
    and esp, 0FFFFFFF8h
    sub esp, 70h
    xor ecx, ecx
    mov dword[esp + 50h], 6A09E667h
    and dword[esp + 48h], ecx
    and dword[esp + 4Ch], ecx
    push esi
    xor esi, esi
    mov dword[esp + 44h], ecx
    push edi
    mov dword[esp + 5Ch], 0BB67AE85h
    mov dword[esp + 60h], 3C6EF372h
    mov dword[esp + 64h], 0A54FF53Ah
    mov dword[esp + 68h], 510E527Fh
    mov dword[esp + 6Ch], 9B05688Ch
    mov dword[esp + 70h], 1F83D9ABh
    mov dword[esp + 74h], 5BE0CD19h
    cmp dword[ebp + 0Ch], ecx
    jbe @04
    mov edi, dword[ebp + 8h]

@02:
    mov al, byte[edi + esi]
    mov byte[ecx + esp + 8h], al
    mov ecx, dword[esp + 48h]
    inc ecx
    mov dword[esp + 48h], ecx
    cmp ecx, 40h
    jne @03
    lea edx, [esp + 8h]
    mov ecx, edx
    call @05
    add dword[esp + 50h], 200h
    adc dword[esp + 54h], 0h
    xor ecx, ecx
    mov dword[esp + 48h], ecx

@03:
    inc esi
    cmp esi, dword[ebp + 0Ch]
    jb @02

@04:
    mov edx, dword[ebp + 10h]
    lea ecx, [esp + 8h]
    call @11
    pop edi
    pop esi
    mov esp, ebp
    pop ebp
    ret 0Ch

@05:
    push ebp
    mov ebp, esp
    sub esp, 128h
    push ebx
    push esi
    push edi
    xor ebx, ebx
    mov edi, ecx
    mov dword[ebp - 20h], edi
    mov esi, ebx
    inc edx

@06:
    movzx ecx, byte[edx - 1h]
    movzx eax, byte[edx]
    lea edx, [edx + 4h]
    shl ecx, 8h
    or ecx, eax
    movzx eax, byte[edx - 3h]
    shl ecx, 8h
    or ecx, eax
    movzx eax, byte[edx - 2h]
    shl ecx, 8h
    or ecx, eax
    mov dword[esi * 4h + ebp - 128h], ecx
    inc esi
    cmp esi, 10h
    jb @06
    push 40h
    pop eax
    cmp esi, eax
    jae @08
    sub eax, esi
    lea ebx, [esi * 4h + ebp - 130h]
    mov dword[ebp - 4h], eax
    mov edi, eax

@07:
    mov ecx, dword[ebx]
    mov esi, ecx
    mov edx, dword[ebx - 34h]
    lea ebx, [ebx + 4h]
    mov eax, ecx
    rol esi, 0Fh
    rol eax, 0Dh
    xor esi, eax
    shr ecx, 0Ah
    xor esi, ecx
    mov eax, edx
    mov ecx, edx
    ror eax, 7h
    rol ecx, 0Eh
    xor ecx, eax
    shr edx, 3h
    xor ecx, edx
    add esi, ecx
    add esi, dword[ebx - 3Ch]
    add esi, dword[ebx - 18h]
    mov dword[ebx + 4h], esi
    dec edi
    jne @07
    mov edi, dword[ebp - 20h]
    xor ebx, ebx

@08:
    mov eax, dword[edi + 50h]
    mov edx, dword[edi + 64h]
    mov dword[ebp - 24h], eax
    mov dword[ebp - 28h], eax
    mov eax, dword[edi + 54h]
    mov dword[ebp - 14h], eax
    mov eax, dword[edi + 58h]
    mov dword[ebp - 10h], eax
    mov eax, dword[edi + 5Ch]
    mov dword[ebp - 18h], eax
    mov eax, dword[edi + 60h]
    mov ecx, eax
    mov dword[ebp - 1Ch], eax
    mov eax, dword[edi + 68h]
    mov dword[ebp - 0Ch], eax
    mov eax, dword[edi + 6Ch]
    mov edi, dword[ebp - 24h]
    mov dword[ebp - 8h], edx
    mov dword[ebp - 4h], eax
    jmp @10

@09:
    mov edx, dword[ebp - 8h]

@10:
    and edx, dword[ebp - 1Ch]
    mov esi, ecx
    mov eax, ecx
    ror esi, 0Bh
    rol eax, 7h
    xor esi, eax
    mov eax, ecx
    ror eax, 6h
    not ecx
    and ecx, dword[ebp - 0Ch]
    xor esi, eax
    xor ecx, edx
    mov eax, edi
    rol eax, 0Ah
    mov edx, edi
    ror edx, 0Dh
    add esi, ecx

;   базонезалежність
;   -------------------------------------------
;    push eax
;    call @f
;@@: pop eax
;    sub eax, @b
;    add esi, dword[eax + ebx + k]
;    pop eax

    add esi, dword[ebx + k]
;   -------------------------------------------

    xor edx, eax
    add esi, dword[ebx + ebp - 128h]
    mov eax, edi
    add esi, dword[ebp - 4h]
    add ebx, 4h
    ror eax, 2h
    xor edx, eax
    mov eax, dword[ebp - 14h]
    mov ecx, eax
    and eax, edi
    xor ecx, edi
    and ecx, dword[ebp - 10h]
    xor ecx, eax
    mov eax, dword[ebp - 0Ch]
    add edx, ecx
    mov dword[ebp - 4h], eax
    mov ecx, dword[ebp - 8h]
    mov eax, dword[ebp - 1Ch]
    mov dword[ebp - 0Ch], ecx
    mov ecx, dword[ebp - 18h]
    mov dword[ebp - 8h], eax
    add ecx, esi
    mov eax, dword[ebp - 10h]
    mov dword[ebp - 18h], eax
    mov eax, dword[ebp - 14h]
    mov dword[ebp - 14h], edi
    lea edi, [esi + edx]
    mov dword[ebp - 1Ch], ecx
    mov dword[ebp - 10h], eax
    cmp ebx, 100h
    jb @09
    mov eax, dword[ebp - 28h]
    mov edx, dword[ebp - 14h]
    add eax, edi
    mov edi, dword[ebp - 20h]
    add dword[edi + 60h], ecx
    add dword[edi + 54h], edx
    mov ecx, dword[ebp - 8h]
    add dword[edi + 64h], ecx
    mov edx, dword[ebp - 10h]
    add dword[edi + 58h], edx
    mov ecx, dword[ebp - 0Ch]
    add dword[edi + 68h], ecx
    mov edx, dword[ebp - 18h]
    add dword[edi + 5Ch], edx
    mov ecx, dword[ebp - 4h]
    add dword[edi + 6Ch], ecx
    mov dword[edi + 50h], eax
    pop edi
    pop esi
    pop ebx
    leave
    ret

@11:
    push ebp
    mov ebp, esp
    push ecx
    push ebx
    push esi
    mov esi, ecx
    mov dword[ebp - 4h], edx
    push edi
    push 38h
    xor edi, edi
    mov ecx, dword[esi + 40h]
    pop ebx
    cmp ecx, ebx
    mov byte[esi + ecx], 80h
    inc ecx
    jae @12
    cmp ecx, ebx
    jae @15
    sub ebx, ecx
    lea eax, [esi + ecx]
    push ebx
    push edi
    push eax
    jmp @14

@12:
    push 40h
    pop edx
    cmp ecx, edx
    jae @13
    sub edx, ecx
    lea eax, [esi + ecx]
    push edx
    push edi
    push eax
    call @20
    add esp, 0Ch

@13:
    mov edx, esi
    mov ecx, esi
    call @05
    push ebx
    push edi
    push esi

@14:
    call @20
    add esp, 0Ch

@15:
    mov eax, dword[esi + 40h]
    shl eax, 3h
    add dword[esi + 48h], eax
    adc dword[esi + 4Ch], edi
    mov al, byte[esi + 48h]
    mov byte[esi + 3Fh], al
    mov ecx, dword[esi + 48h]
    mov eax, dword[esi + 4Ch]
    shrd ecx, eax, 8h
    mov byte[esi + 3Eh], cl
    mov ecx, dword[esi + 48h]
    shr eax, 8h
    mov eax, dword[esi + 4Ch]
    shrd ecx, eax, 10h
    mov byte[esi + 3Dh], cl
    mov ecx, dword[esi + 48h]
    shr eax, 10h
    mov eax, dword[esi + 4Ch]
    shrd ecx, eax, 18h
    mov byte[esi + 3Ch], cl
    mov cl, 20h
    mov edx, dword[esi + 4Ch]
    shr eax, 18h
    mov eax, dword[esi + 48h]
    call @17
    mov byte[esi + 3Bh], al
    mov cl, 28h
    mov eax, dword[esi + 48h]
    mov edx, dword[esi + 4Ch]
    call @17
    mov byte[esi + 3Ah], al
    mov edx, esi
    mov al, byte[esi + 4Eh]
    mov ecx, esi
    mov byte[esi + 39h], al
    mov al, byte[esi + 4Fh]
    mov byte[esi + 38h], al
    call @05
    mov edx, dword[ebp - 4h]

@16:
    push 3h
    pop eax
    sub eax, edi
    mov ecx, eax
    mov eax, dword[esi + 50h]
    shl ecx, 3h
    shr eax, cl
    mov byte[edi + edx], al
    mov eax, dword[esi + 54h]
    shr eax, cl
    mov byte[edi + edx + 4h], al
    mov eax, dword[esi + 58h]
    shr eax, cl
    mov byte[edi + edx + 8h], al
    mov eax, dword[esi + 5Ch]
    shr eax, cl
    mov byte[edi + edx + 0Ch], al
    mov eax, dword[esi + 60h]
    shr eax, cl
    mov byte[edi + edx + 10h], al
    mov eax, dword[esi + 64h]
    shr eax, cl
    mov byte[edi + edx + 14h], al
    mov eax, dword[esi + 68h]
    shr eax, cl
    mov byte[edi + edx + 18h], al
    mov eax, dword[esi + 6Ch]
    shr eax, cl
    mov byte[edi + edx + 1Ch], al
    inc edi
    cmp edi, 4h
    jb @16
    pop edi
    pop esi
    pop ebx
    leave
    ret

@17:
    cmp cl, 40h
    jae @19
    cmp cl, 20h
    jae @18
    shrd eax, edx, cl
    shr edx, cl
    ret

@18:
    mov eax, edx
    xor edx, edx
    and cl, 1Fh
    shr eax, cl
    ret

@19:
    xor eax, eax
    xor edx, edx
    ret

@20:
    push ebp
    mov ebp, esp
    push edi
    mov ecx, dword[ebp + 0x10]
    mov edi, dword[ebp + 0x08]
    mov al, byte[ebp + 0x0C]
    rep stosb
    pop edi
    leave
    retn

k:
    dd 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5
    dd 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174
    dd 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da
    dd 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967
    dd 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85
    dd 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070
    dd 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3
    dd 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2

main.asm

format pe console

section '.code' import readable writeable executable

    PROV_RSA_AES            = 24
    CALG_SHA_256            = 0x0000800C
    CRYPT_VERIFYCONTEXT     = 0xF0000000
    HP_HASHVAL              = 2

include 'win32ax.inc'

library     msvcrt, 'msvcrt.dll',\
            advapi32, 'advapi32.dll'

import      msvcrt,\
            printf, 'printf',\
            getchar, 'getchar',\
            memcmp, 'memcmp'

import      advapi32,\
            CryptAcquireContextA, 'CryptAcquireContextA',\
            CryptCreateHash, 'CryptCreateHash',\
            CryptHashData, 'CryptHashData',\
            CryptGetHashParam, 'CryptGetHashParam',\
            CryptDestroyHash, 'CryptDestroyHash',\
            CryptReleaseContext, 'CryptReleaseContext',\
            RtlGenRandom, 'SystemFunction036'


proc print, buf
    locals
        frmt db '%02X', 0
    endl

    mov esi, [buf]
    xor ecx, ecx

@@: movzx eax, byte[esi]

    push ecx
    cinvoke printf, addr frmt, eax
    pop ecx

    inc ecx
    inc esi

    cmp ecx, 32
    jne @b

    cinvoke printf, next_line

    ret
endp

proc rnd, buf
    locals
        pRandomBuffer rd 1
    endl

    mov edi, [buf]
    xor ecx, ecx
@@: push ecx

    invoke RtlGenRandom, addr pRandomBuffer, 4
    cmp eax, 0
    je .err

    mov eax, [pRandomBuffer]
    xor edx, edx
    mov ecx, 255
    div ecx
    mov eax, edx
    jmp .fin

.err:
    xor eax, eax
    dec eax
.fin:

    mov byte[edi], al

    pop ecx

    inc edi
    inc ecx
    cmp ecx, 32
    jl @b

    ret
endp

include 'sha256.asm'

proc sha256_get_hash_api, txt, len, buf
    locals
        buf_api_size    dd 32
        hProv           rd 1
        hHash           rd 1
    endl

    invoke CryptAcquireContextA, addr hProv, 0, 0, PROV_RSA_AES, CRYPT_VERIFYCONTEXT
    cmp eax, 0
    je .fin1

    invoke CryptCreateHash, [hProv], CALG_SHA_256, 0, 0, addr hHash
    cmp eax, 0
    je .fin

    invoke CryptHashData, [hHash], [txt], [len], 0
    cmp eax, 0
    je .fin

    invoke CryptGetHashParam, [hHash], HP_HASHVAL, [buf], addr buf_api_size, 0
    cmp eax, 0
    je .fin

.fin:
    invoke CryptDestroyHash, [hHash]
.fin1:
    invoke CryptReleaseContext, [hProv], 0

    ret
endp


entry $

    xor ecx, ecx
@@: push ecx

    stdcall rnd, buf_rnd

;   ---------------------------------------------------------------------------------------------------

    stdcall sha256_get_hash_api, buf_rnd, 32, buf_api

;    stdcall print, buf_api

;   ---------------------------------------------------------------------------------------------------
    
    stdcall sha256, buf_rnd, 32, buf_shl

;    stdcall print, buf_shl

;   ---------------------------------------------------------------------------------------------------

    cinvoke memcmp, buf_api, buf_shl, 32
    cmp eax, 0
    jne not_eq

    cinvoke printf, equally
    jmp fin

not_eq:
    cinvoke printf, not_equal
    cinvoke getchar

fin:
    pop ecx
    inc ecx
    cmp ecx, 40
    jl @b

    cinvoke printf, finish
    cinvoke getchar

    xor eax, eax
    ret


    equally         db 'memcmp: equally', 13, 10,           0
    not_equal       db 'memcmp: not equal', 13, 10,         0
    finish          db 13, 10, 'finish ok!', 13, 10,        0
    next_line       db 13, 10,                              0

    buf_rnd         rb 32
    buf_api         rb 32
    buf_shl         rb 32
Подякували: 0xDADA11C71

2

Re: [FASM] sha256

товариші, я вас дуже прошу, пишіть коментарі

- Поганому трояну фаєрвол заважає
- Ніколи не програмуйте та не пийте пиво
Якщо ви з першого разу написали програму, в якій немає жодної помилки, повідомте про це системного програмісту: він виправить помилки в компіляторі

3

Re: [FASM] sha256

reverse2500 написав:

товариші, я вас дуже прошу, пишіть коментарі

Чому 32 біти? Коли зараз вже навіть мобіли обзавелися 64 бітними процами?

Віддамся на один вечір в хороші дівочі руки.. не дорого, в у.о. .. Якщо сподобається, то залишуся безкоштовно назавжди..

4

Re: [FASM] sha256

Чому 32 біти?

а до чого тут 32 біти ? Тут не зрозуміло  шо як працює, хоч описати шо робимо

- Поганому трояну фаєрвол заважає
- Ніколи не програмуйте та не пийте пиво
Якщо ви з першого разу написали програму, в якій немає жодної помилки, повідомте про це системного програмісту: він виправить помилки в компіляторі

5

Re: [FASM] sha256

reverse2500 написав:

Чому 32 біти?

а до чого тут 32 біти ? Тут не зрозуміло  шо як працює, хоч описати шо робимо

Ну так з коментарями туго. Хоча би один на два десятки строк не завадило би.

Віддамся на один вечір в хороші дівочі руки.. не дорого, в у.о. .. Якщо сподобається, то залишуся безкоштовно назавжди..

6

Re: [FASM] sha256

На жаль, не маю звички коментувати подібного розміру сирці. Час пройде, всеодно не допоможе, окрім відладчика) Тут же пара функцій..

7

Re: [FASM] sha256

Kane написав:

На жаль, не маю звички коментувати подібного розміру сирці. Час пройде, всеодно не допоможе, окрім відладчика) Тут же пара функцій..

Ну то звична річ коли не звик працювати у команді над одним проектом.

Віддамся на один вечір в хороші дівочі руки.. не дорого, в у.о. .. Якщо сподобається, то залишуся безкоштовно назавжди..