block_cipher.inc

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

; Common funcs for Block Ciphers

struct _KEY128
  k0 dd ?
  k1 dd ?
  k2 dd ?
  k3 dd ?
ends

struct _KEY256
  k0 dd ?
  k1 dd ?
  k2 dd ?
  k3 dd ?
  k4 dd ?
  k5 dd ?
  k6 dd ?
  k7 dd ?
ends

struct _BLOCK64
  x dd ?
  y dd ?
ends

struct _BLOCK128
  a dd ?
  b dd ?
  c dd ?
  d dd ?
ends

PBLOCK64 equ DWORD
PBLOCK128 equ DWORD

macro _xorblock block1,block2,count
{
      xor ecx,ecx
@@:   cmp ecx,count
      jnb @f
      mov al,[block2+ecx]
      xor [block1+ecx],al
      inc ecx
      jmp @r
@@:
}

macro _xorblock64 block1,block2
{
      mov eax,[block2+_BLOCK64.x]
      xor [block1+_BLOCK64.x],eax
      mov eax,[block2+_BLOCK64.y]
      xor [block1+_BLOCK64.y],eax
      ;movq mm0,[block1]
      ;pxor mm0,[block2]
      ;movq [block1],mm0
}

macro _xorblock128 block1,block2
{
      mov eax,[block2+_BLOCK128.a]
      xor [block1+_BLOCK128.a],eax
      mov eax,[block2+_BLOCK128.b]
      xor [block1+_BLOCK128.b],eax
      mov eax,[block2+_BLOCK128.c]
      xor [block1+_BLOCK128.c],eax
      mov eax,[block2+_BLOCK128.d]
      xor [block1+_BLOCK128.d],eax
      ;movq mm0,[block1]
      ;movq mm1,[block1+8]
      ;pxor mm0,[block2]
      ;pxor mm1,[block2+8]
      ;movq [block1],mm0
      ;movq [block1+8],mm1
}

macro _cpyblock64 src,dest
{
      mov ecx,[src+_BLOCK64.x]
      mov [dest+_BLOCK64.x],ecx
      mov ecx,[src+_BLOCK64.y]
      mov [dest+_BLOCK64.y],ecx
      ;movq mm0,[src]
      ;movq [dest],mm0
}

macro _cpyblock128 src,dest
{
      mov ecx,[src+_BLOCK128.a]
      mov [dest+_BLOCK128.a],ecx
      mov ecx,[src+_BLOCK128.b]
      mov [dest+_BLOCK128.b],ecx
      mov ecx,[src+_BLOCK128.c]
      mov [dest+_BLOCK128.c],ecx
      mov ecx,[src+_BLOCK128.d]
      mov [dest+_BLOCK128.d],ecx
      ;movq mm0,[src]
      ;movq mm1,[src+8]
      ;movq [dest],mm0
      ;movq [dest+8],mm1
}

macro _incctr64 block
{
      mov ecx,sizeof._BLOCK64-1
      inc byte [block+ecx]
@@:   cmp byte [block+ecx],0
      jne @f
      inc byte [block+ecx-1]
      dec ecx
      jnz @r
@@:
}

macro _incctr128 block
{
      mov ecx,sizeof._BLOCK128-1
      inc byte [block+ecx]
@@:   cmp byte [block+ecx],0
      jne @f
      inc byte [block+ecx-1]
      dec ecx
      jnz @r
@@:
}

; 64-bits block ciphers

align 4
proc Cipher64_Init,IV64:PBYTE,EncryptProc:PROC
     mov eax,[IV64]
     lea edx,[chain64]
     test eax,eax
     jnz .c64_set_iv
     xor eax,eax
     mov [edx+_BLOCK64.x],eax
     mov [edx+_BLOCK64.y],eax
     push edx
     call [EncryptProc]
     jmp .c64_init_end
.c64_set_iv:
     _cpyblock64 eax,edx
.c64_init_end:
     ret
endp

align 4
proc Cipher64_CryptECB uses esi edi,Data:PBYTE,DataSize:DWORD,CryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     shr esi,3
     jz .c64_cecb_end
@@:  push edi
     call [CryptProc]
     add edi,sizeof._BLOCK64
     dec esi
     jnz @r
.c64_cecb_end:
     ret
endp

align 4
proc Cipher64_EncryptCBC uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain64]
     shr esi,3
     jz .c64_ecbc_end
@@:  _xorblock64 edi,ebx
     push edi
     call [EncryptProc]
     _cpyblock64 edi,ebx
     add edi,sizeof._BLOCK64
     dec esi
     jnz @r
.c64_ecbc_end:
     mov esi,[DataSize]
     and esi,7
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher64_DecryptCBC uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC,DecryptProc:PROC
     local temp:_BLOCK64
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain64]
     shr esi,3
     jz .c64_dcbc_end
@@:  _cpyblock64 edi,temp
     push edi
     call [DecryptProc]
     _xorblock64 edi,ebx
     _cpyblock64 temp,ebx
     add edi,sizeof._BLOCK64
     dec esi
     jnz @r
.c64_dcbc_end:
     mov esi,[DataSize]
     and esi,7
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher64_EncryptCFB uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain64]
     shr esi,3
     jz .c64_ecfb_end
@@:  push ebx
     call [EncryptProc]
     _xorblock64 edi,ebx
     _cpyblock64 edi,ebx
     add edi,sizeof._BLOCK64
     dec esi
     jnz @r
.c64_ecfb_end:
     mov esi,[DataSize]
     and esi,7
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher64_DecryptCFB uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     local temp:_BLOCK64
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain64]
     shr esi,3
     jz .c64_dcfb_end
@@:  _cpyblock64 edi,temp
     push ebx
     call [EncryptProc]
     _xorblock64 edi,ebx
     _cpyblock64 temp,ebx
     add edi,sizeof._BLOCK64
     dec esi
     jnz @r
.c64_dcfb_end:
     mov esi,[DataSize]
     and esi,7
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher64_CryptOFB uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain64]
     shr esi,3
     jz .c64_cofb_end
@@:  push ebx
     call [EncryptProc]
     _xorblock64 edi,ebx
     add edi,sizeof._BLOCK64
     dec esi
     jnz @r
.c64_cofb_end:
     mov esi,[DataSize]
     and esi,7
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher64_CryptCTR uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     local temp:_BLOCK64
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain64]
     shr esi,3
     jz .c64_cctr_end
.c64_cctr_loop:
     _cpyblock64 ebx,temp
     lea eax,[temp]
     push eax
     call [EncryptProc]
     _incctr64 ebx
     _xorblock64 edi,temp
     add edi,sizeof._BLOCK64
     dec esi
     jnz .c64_cctr_loop
.c64_cctr_end:
     mov esi,[DataSize]
     and esi,7
     jz @f
     _cpyblock64 ebx,temp
     lea eax,[temp]
     push eax
     call [EncryptProc]
     _incctr64 ebx
     _xorblock edi,temp,esi
@@:  ret
endp

; 128-bits block ciphers

align 4
proc Cipher128_Init,IV128:PBYTE,EncryptProc:PROC
     mov eax,[IV128]
     lea edx,[chain128]
     test eax,eax
     jnz .c128_set_iv
     xor eax,eax
     mov [edx+_BLOCK128.a],eax
     mov [edx+_BLOCK128.b],eax
     mov [edx+_BLOCK128.c],eax
     mov [edx+_BLOCK128.d],eax
     push edx
     call [EncryptProc]
     jmp .c128_init_end
.c128_set_iv:
     _cpyblock128 eax,edx
.c128_init_end:
     ret
endp

align 4
proc Cipher128_CryptECB uses esi edi,Data:PBYTE,DataSize:DWORD,CryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     shr esi,4
     jz .c128_cecb_end
@@:  push edi
     call [CryptProc]
     add edi,sizeof._BLOCK128
     dec esi
     jnz @r
.c128_cecb_end:
     ret
endp

align 4
proc Cipher128_EncryptCBC uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain128]
     shr esi,4
     jz .c128_ecbc_end
@@:  _xorblock128 edi,ebx
     push edi
     call [EncryptProc]
     _cpyblock128 edi,ebx
     add edi,sizeof._BLOCK128
     dec esi
     jnz @r
.c128_ecbc_end:
     mov esi,[DataSize]
     and esi,15
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher128_DecryptCBC uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC,DecryptProc:PROC
     local temp:_BLOCK128
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain128]
     shr esi,4
     jz .c128_dcbc_end
@@:  _cpyblock128 edi,temp
     push edi
     call [DecryptProc]
     _xorblock128 edi,ebx
     _cpyblock128 temp,ebx
     add edi,sizeof._BLOCK128
     dec esi
     jnz @r
.c128_dcbc_end:
     mov esi,[DataSize]
     and esi,15
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher128_EncryptCFB uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain128]
     shr esi,4
     jz .c128_ecfb_end
@@:  push ebx
     call [EncryptProc]
     _xorblock128 edi,ebx
     _cpyblock128 edi,ebx
     add edi,sizeof._BLOCK128
     dec esi
     jnz @r
.c128_ecfb_end:
     mov esi,[DataSize]
     and esi,15
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher128_DecryptCFB uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     local temp:_BLOCK128
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain128]
     shr esi,4
     jz .c128_dcfb_end
@@:  _cpyblock128 edi,temp
     push ebx
     call [EncryptProc]
     _xorblock128 edi,ebx
     _cpyblock128 temp,ebx
     add edi,sizeof._BLOCK128
     dec esi
     jnz @r
.c128_dcfb_end:
     mov esi,[DataSize]
     and esi,15
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher128_CryptOFB uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain128]
     shr esi,4
     jz .c128_cofb_end
@@:  push ebx
     call [EncryptProc]
     _xorblock128 edi,ebx
     add edi,sizeof._BLOCK128
     dec esi
     jnz @r
.c128_cofb_end:
     mov esi,[DataSize]
     and esi,15
     jz @f
     push ebx
     call [EncryptProc]
     _xorblock edi,ebx,esi
@@:  ret
endp

align 4
proc Cipher128_CryptCTR uses ebx esi edi,Data:PBYTE,DataSize:DWORD,EncryptProc:PROC
     local temp:_BLOCK128
     mov edi,[Data]
     mov esi,[DataSize]
     lea ebx,[chain128]
     shr esi,4
     jz .c128_cctr_end
.c128_cctr_loop:
     _cpyblock128 ebx,temp
     lea eax,[temp]
     push eax
     call [EncryptProc]
     _incctr128 ebx
     _xorblock128 edi,temp
     add edi,sizeof._BLOCK128
     dec esi
     jnz .c128_cctr_loop
.c128_cctr_end:
     mov esi,[DataSize]
     and esi,15
     jz @f
     _cpyblock128 ebx,temp
     lea eax,[temp]
     push eax
     call [EncryptProc]
     _incctr128 ebx
     _xorblock edi,temp,esi
@@:  ret
endp