twofish.inc

The dinamyc link library that contains an implementation of SHA1, SHA512, CRC32, CRC32b, Adler32, Tw

; ----------------------------------------------------- ;
;     Twofish Encryption Algorithm ( Block Cipher )     ;
;        by Bruce Schneier, John Kelsey,                ;
;            Doug Whiting, David Wagner,                ;
;            Chris Hall, Niels Ferguson                 ;
;                                                       ;
;                                                       ;
; Block Size: 128 bits                                  ;
; Max Key Size: 256 bits                                ;
; ----------------------------------------------------- ;

align 4
proc __lfsr1
     test al,1
     jz @f
     shr eax,1
     xor eax,180
     ret
@@:  shr eax,1
     ret
endp

align 4
proc __lfsr2
     test al,2
     jz .02
     test al,1
     jz .01
     shr eax,2
     xor eax,180
     xor eax,90
     ret
.01: shr eax,2
     xor eax,180
     ret
.02: test al,1
     jz .03
     shr eax,2
     xor eax,90
     ret
.03: shr eax,2
     ret
endp

align 4
proc __mul_x
     push eax
     call __lfsr2
     xor eax,[esp]
     add esp,4
     ret
endp

align 4
proc __mul_y
     push eax
     call __lfsr1
     push eax
     mov eax,[esp+4]
     call __lfsr2
     xor eax,[esp]
     xor eax,[esp+4]
     add esp,8
     ret
endp

align 4
proc __rs_mds_encode uses ebx esi edi
     push ecx
     mov [esp],eax
     mov ecx,edx
     mov edi,4
.01: mov edx,ecx
     shr edx,24
     test dl,128
     jz .02
     mov esi,edx
     and esi,255
     add esi,esi
     xor esi,333
     and esi,255
     jmp .03
.02: mov esi,edx
     and esi,255
     add esi,esi
     and esi,255
.03: test dl,1
     jz .04
     xor ebx,ebx
     mov bl,dl
     shr ebx,1
     and ebx,127
     xor ebx,166
     xor ebx,esi
     jmp .05
.04: xor ebx,ebx
     mov bl,dl
     shr ebx,1
     and ebx,127
     xor ebx,esi
.05: shl ecx,8
     mov eax,ebx
     shl eax,24
     xor ecx,eax
     shl esi,10h
     xor ecx,esi
     shl ebx,8
     xor ecx,ebx
     xor eax,eax
     mov al,dl
     xor ecx,eax
     dec edi
     jnz .01
     xor ecx,[esp]
     mov edi,4
.06: mov edx,ecx
     shr edx,24
     test dl,128
     jz .07
     mov esi,edx
     and esi,255
     add esi,esi
     xor esi,333
     and esi,255
     jmp .08
.07: mov esi,edx
     and esi,255
     add esi,esi
     and esi,255
.08: test dl,1
     jz .09
     xor ebx,ebx
     mov bl,dl
     shr ebx,1
     and ebx,127
     xor ebx,166
     xor ebx,esi
     jmp .10
.09: xor ebx,ebx
     mov bl,dl
     shr ebx,1
     and ebx,127
     xor ebx,esi
.10: shl ecx,8
     mov eax,ebx
     shl eax,24
     xor ecx,eax
     shl esi,16
     xor ecx,esi
     shl ebx,8
     xor ecx,ebx
     xor eax,eax
     mov al,dl
     xor ecx,eax
     dec edi
     jnz .06
     mov eax,ecx
     pop edx
     ret
endp

align 4
proc __f32 uses ebx esi edi
     sub esp,12
     mov [esp+4],ecx
     mov [esp],eax
     mov ebx,[esp]
     and ebx,255
     mov ecx,[esp]
     shr ecx,8
     and ecx,255
     mov eax,[esp]
     shr eax,16
     and eax,255
     mov esi,[esp]
     shr esi,24
     mov [esp+8],esi
     cmp dword [esp+4],256
     jnz @f
     movzx ebx,byte [twofish_p8x8+256+ebx]
     mov esi,[edx+12]
     mov edi,esi
     and edi,255
     xor ebx,edi
     movzx ecx,byte [twofish_p8x8+ecx]
     mov edi,esi
     shr edi,8
     and edi,255
     xor ecx,edi
     movzx eax,byte [twofish_p8x8+eax]
     mov edi,esi
     shr edi,16
     and edi,255
     xor eax,edi
     mov edi,[esp+8]
     movzx edi,byte [twofish_p8x8+256+edi]
     shr esi,24
     xor edi,esi
     mov [esp+8],edi
@@:  cmp dword [esp+4],192
     jb @f
     movzx ebx,byte [twofish_p8x8+256+ebx]
     mov esi,[edx+8]
     mov edi,esi
     and edi,255
     xor ebx,edi
     movzx ecx,byte [twofish_p8x8+256+ecx]
     mov edi,esi
     shr edi,8
     and edi,255
     xor ecx,edi
     movzx eax,byte [twofish_p8x8+eax]
     mov edi,esi
     shr edi,16
     and edi,255
     xor eax,edi
     mov edi,[esp+8]
     movzx edi,byte [twofish_p8x8+edi]
     shr esi,24
     xor edi,esi
     mov [esp+8],edi
@@:  movzx ebx,byte [twofish_p8x8+ebx]
     mov esi,[edx+4]
     and esi,255
     xor ebx,esi
     movzx ebx,byte [twofish_p8x8+ebx]
     mov esi,[edx]
     and esi,255
     xor ebx,esi
     mov ebx,[twofish_mds+ebx*4]
     movzx ecx,byte [twofish_p8x8+256+ecx]
     mov esi,[edx+4]
     shr esi,8
     and esi,255
     xor ecx,esi
     movzx ecx,byte [twofish_p8x8+ecx]
     mov esi,[edx]
     shr esi,8
     and esi,255
     xor ecx,esi
     xor ebx,[twofish_mds+$400+ecx*4]
     movzx eax,byte [twofish_p8x8+eax]
     mov ecx,[edx+4]
     shr ecx,16
     and ecx,255
     xor eax,ecx
     movzx eax,byte [twofish_p8x8+256+eax]
     mov ecx,[edx]
     shr ecx,16
     and ecx,255
     xor eax,ecx
     xor ebx,[twofish_mds+$800+eax*4]
     mov eax,[esp+8]
     movzx eax,byte [twofish_p8x8+256+eax]
     mov ecx,[edx+4]
     shr ecx,24
     xor eax,ecx
     movzx eax,byte [twofish_p8x8+256+eax]
     mov edx,[edx]
     shr edx,24
     xor eax,edx
     xor ebx,[twofish_mds+$C00+eax*4]
     mov eax,ebx
     add esp,12
     ret
endp

align 4
proc __xor256 uses ebx esi
     xor ebx,ebx
     and ecx,255
     imul ecx,$01010101
@@:  mov esi,[edx+ebx*4]
     xor esi,ecx
     mov [eax+ebx*4], esi
     mov esi,[edx+ebx*4+4]
     xor esi,ecx
     mov [eax+ebx*4+4],esi
     mov esi,[edx+ebx*4+8]
     xor esi,ecx
     mov [eax+ebx*4+8],esi
     mov esi,[edx+ebx*4+12]
     xor esi,ecx
     mov [eax+ebx*4+12],esi
     add ebx,4
     cmp ebx,64
     jb @r
     ret
endp

align 4
proc Twofish_PrecomputeMDS uses ebx esi edi
     locals
       m1 dq ?
       mx dq ?
       my dq ?
       ni dd ?
     endl
     mov [ni],256
     mov esi,twofish_p8x8
     mov ebx,twofish_mds
@@:  movzx edi,byte [esi]
     mov dword [m1],edi
     mov eax, edi
     call __mul_x
     mov dword [mx],eax
     mov eax,edi
     call __mul_y
     mov dword [my],eax
     movzx edi,byte [esi+256]
     mov dword [m1+4],edi
     mov eax,edi
     call __mul_x
     mov dword [mx+4],eax
     mov eax,edi
     call __mul_y
     mov dword [my+4],eax
     mov eax,edi
     mov edx,dword [mx+4]
     shl edx,8
     or eax,edx
     mov edx,dword [my+4]
     shl edx,16
     or eax,edx
     mov edx,dword [my+4]
     shl edx,24
     or eax,edx
     mov [ebx],eax
     mov eax, dword [my]
     mov edx,eax
     mov ecx,eax
     shl ecx,8
     or edx,ecx
     mov ecx,dword [mx]
     shl ecx,16
     or edx,ecx
     mov ecx,dword [m1]
     shl ecx,24
     or edx,ecx
     mov [ebx+$400],edx
     mov edx,dword [mx+4]
     mov ecx,dword [my+4]
     shl ecx,8
     or edx,ecx
     shl edi,16
     or edx,edi
     mov ecx,dword [my+4]
     shl ecx,24
     or edx,ecx
     mov [ebx+$800],edx
     mov edx,dword [mx]
     mov ecx,dword [m1]
     shl ecx,8
     or edx,ecx
     shl eax,16
     or edx,eax
     mov eax,dword [mx]
     shl eax,24
     or  edx,eax
     mov [ebx+$C00],edx
     add ebx,4
     inc esi
     dec [ni]
     jnz @r
     ret
endp

align 4
proc Twofish_Init; uses ebx esi edi,Key:PBYTE,KeySize:DWORD

var_25C = dword -25Ch
var_15C = dword -15Ch
var_5C	= dword -5Ch
var_58	= dword -58h
var_54	= dword -54h
var_50	= dword -50h
var_4C	= dword -4Ch
var_3C	= dword -3Ch
var_2C	= dword -2Ch
var_28	= dword -28h
var_C	= dword -0Ch
var_8	= dword -8
var_4	= dword -4
arg_0	= dword 8
arg_4	= dword 0Ch

     push ebp
     mov ebp,esp
     sub esp,$25C
     push ebx
     push esi
     push edi
     lea edi,[ebp+var_2C]
     stdcall memset,edi,32,0
     mov ecx,[ebp+arg_4]
     mov eax,256
     cmp ecx,eax
     cmova ecx,eax
     shr ecx,3
     stdcall memcpy,edi,dword[ebp+arg_0],ecx
     cmp dword [ebp+arg_4],128
     ja @f
     mov dword [ebp+arg_4],128
     jmp .01
@@:  cmp dword [ebp+arg_4],192
     ja @f
     mov dword [ebp+arg_4],192
     jmp .01
@@:  mov dword [ebp+arg_4],256
.01: mov eax,[ebp+arg_4]
     shr eax,6
     dec eax
     mov [ebp+var_4],eax
     mov eax,[ebp+var_4]
     test eax,eax
     jb .02
     inc eax
     mov [ebp+var_C],eax
     xor ebx,ebx
     lea esi,[ebp+var_3C]
     lea edi,[ebp+var_4C]
@@:  mov eax,ebx
     add eax,eax
     mov edx,[ebp+eax*4+var_2C]
     mov [esi],edx
     mov eax,[ebp+eax*4+var_28]
     mov [edi],eax
     mov edx,[edi]
     mov eax,[esi]
     call __rs_mds_encode
     mov edx,[ebp+var_4]
     mov [ebp+edx*4+var_5C],eax
     dec dword [ebp+var_4]
     inc ebx
     add edi,4
     add esi,4
     dec dword [ebp+var_C]
     jnz @r
.02: xor eax,eax
     mov [ebp+var_8],eax
     xor ebx,ebx
@@:  lea edx,[ebp+var_3C]
     mov ecx,[ebp+arg_4]
     mov eax,[ebp+var_8]
     call __f32
     mov esi,eax
     lea edx,[ebp+var_4C]
     mov eax,[ebp+var_8]
     add eax,$01010101
     mov ecx,[ebp+arg_4]
     call __f32
     mov edx,eax
     shl edx,8
     shr eax,24
     or edx,eax
     mov eax,edx
     lea ecx,[eax+esi]
     mov edx,ebx
     add edx,edx
     mov [twofish_subkeys+edx*4],ecx
     add eax,eax
     add esi,eax
     mov eax,esi
     mov ecx,eax
     shl ecx,9
     shr eax,23
     or ecx,eax
     mov [twofish_subkeys+4+edx*4],ecx
     add dword [ebp+var_8],$02020202
     inc ebx
     cmp ebx,20
     jnz @r
     mov eax,[ebp+arg_4]
     sub eax,128
     jz .keysize128
     sub eax,64
     jz  .keysize192
     sub eax,64
     jz .keysize256
     jmp .init_end
.keysize128:
     mov cl,[ebp+var_58]
     and cl,255
     mov edx,twofish_p8x8
     lea eax,[ebp+var_15C]
     call __xor256
     mov esi,[ebp+var_5C]
     and esi,255
     xor ebx,ebx
@@:  xor edx,edx
     mov dl,[ebp+ebx+var_15C]
     movzx edx,byte [twofish_p8x8+edx]
     xor edx,esi
     mov edx,[twofish_mds+edx*4]
     mov eax,ebx
     add eax,eax
     mov [twofish_sbox+eax*4],edx
     xor edx,edx
     mov dl,[ebp+ebx+var_15C+1]
     movzx edx,byte [twofish_p8x8+edx]
     xor edx,esi
     mov edx,[twofish_mds+edx*4]
     mov [twofish_sbox+8+eax*4],edx
     add ebx,2
     cmp ebx,256
     jb @r
     mov ecx,[ebp+var_58]
     shr ecx,8
     and cl,255
     mov edx,twofish_p8x8+256
     lea eax,[ebp+var_15C]
     call __xor256
     mov esi,[ebp+var_5C]
     shr esi,8
     and esi,255
     xor ebx,ebx
@@:  xor edx,edx
     mov dl,[ebp+ebx+var_15C]
     movzx edx,byte [twofish_p8x8+edx]
     xor edx,esi
     mov edx,[twofish_mds+$400+edx*4]
     mov eax,ebx
     add eax,eax
     mov [twofish_sbox+4+eax*4],edx
     xor edx,edx
     mov dl,[ebp+ebx+var_15C+1]
     movzx edx,byte [twofish_p8x8+edx]
     xor edx,esi
     mov edx,[twofish_mds+$400+edx*4]
     inc eax
     mov [twofish_sbox+8+eax*4],edx
     add ebx,2
     cmp ebx,256
     jb @r
     mov ecx,[ebp+var_58]
     shr ecx,16
     and cl,255
     mov edx,twofish_p8x8
     lea eax,[ebp+var_15C]
     call __xor256
     mov esi,[ebp+var_5C]
     shr esi,16
     and esi,255
     xor ebx,ebx
@@:  xor edx,edx
     mov dl,[ebp+ebx+var_15C]
     movzx edx,byte [twofish_p8x8+256+edx]
     xor edx,esi
     mov edx,[twofish_mds+$800+edx*4]
     mov eax,ebx
     add eax,eax
     mov [twofish_sbox+$800+eax*4],edx
     xor edx,edx
     mov dl,[ebp+ebx+var_15C+1]
     movzx edx,byte [twofish_p8x8+256+edx]
     xor edx,esi
     mov edx,[twofish_mds+$800+edx*4]
     mov [twofish_sbox+$808+eax*4],edx
     add ebx,2
     cmp ebx,256
     jb @r
     mov ecx,[ebp+var_58]
     shr ecx,24
     mov edx,twofish_p8x8+256
     lea eax,[ebp+var_15C]
     call __xor256
     mov esi,[ebp+var_5C]
     shr esi,24
     xor ebx,ebx
@@:  xor edx,edx
     mov dl,[ebp+ebx+var_15C]
     movzx edx,byte [twofish_p8x8+256+edx]
     xor edx,esi
     mov edx,[twofish_mds+$C00+edx*4]
     mov eax,ebx
     add eax,eax
     mov [twofish_sbox+$804+eax*4],edx
     xor edx,edx
     mov dl,[ebp+ebx+var_15C+1]
     movzx edx,byte [twofish_p8x8+256+edx]
     xor edx,esi
     mov edx,[twofish_mds+$C00+edx*4]
     inc eax
     mov [twofish_sbox+$808+eax*4],edx
     add ebx,2
     cmp ebx,256
     jb @r
     jmp .init_end
.keysize192:
     mov cl,[ebp+var_54]
     and cl,255
     mov edx,twofish_p8x8+256
     lea eax,[ebp+var_15C]
     call __xor256
     mov esi,[ebp+var_5C]
     and esi,255
     mov eax,[ebp+var_58]
     and eax,255
     xor ebx,ebx
@@:  xor ecx,ecx
     mov cl,[ebp+ebx+var_15C]
     movzx ecx,byte [twofish_p8x8+ecx]
     xor ecx,eax
     movzx ecx,byte [twofish_p8x8+ecx]
     xor ecx,esi
     mov ecx,[twofish_mds+ecx*4]
     mov edx,ebx
     add edx,edx
     mov [twofish_sbox+edx*4],ecx
     xor ecx,ecx
     mov cl,[ebp+ebx+var_15C+1]
     movzx ecx,byte [twofish_p8x8+ecx]
     xor ecx,eax
     movzx ecx,byte [twofish_p8x8+ecx]
     xor ecx,esi
     mov ecx,[twofish_mds+ecx*4]
     mov [twofish_sbox+8+edx*4],ecx
     add ebx,2
     cmp ebx,256
     jb @r
     mov ecx,[ebp+var_54]
     shr ecx,8
     and cl,255
     mov edx,twofish_p8x8+256
     lea eax,[ebp+var_15C]
     call __xor256
     mov esi,[ebp+var_5C]
     shr esi,8
     and esi,255
     mov eax,[ebp+var_58]
     shr eax,8
     and eax,255
     xor ebx,ebx
@@:  xor ecx,ecx
     mov cl,[ebp+ebx+var_15C]