sha512.inc

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

; ----------------------------------------------------- ;
;    SHA512 Hash Algorithm                              ;
;      by NIST and the NSA of USA                       ;
;                                                       ;
; Output Digest Size: 512 bits                          ;
; ----------------------------------------------------- ;

macro MOV64 m2,m1
{
      ;mov eax,dword[m1]
      ;mov edx,dword[m1+4]
      ;mov dword [m2],eax
      ;mov dword [m2+4],edx
      movq mm0,[m1]
      movq [m2],mm0
}

macro ADD64 m2,m1
{
      mov eax,dword[m1]
      mov edx,dword[m1+4]
      add dword [m2],eax
      adc dword [m2+4],edx
}

macro ROR64 RegLo,RegHi,N
{
      if N lt 32
	 shrd RegLo,RegHi,N
	 shrd RegHi,ebp,N
      else
	 shld RegLo,RegHi,64-N
	 shld RegHi,ebp,64-N
      end if
}

macro SHR64 RegLo,RegHi,N
{
      shrd RegLo,RegHi,N
      shr RegHi,N
}

macro SHL64 RegLo,RegHi,N
{
      shld RegHi,RegLo,N
      shl RegLo,N
}
	
macro SIGMA qwX,n1,n2,n3
{
      mov eax,dword[qwX]
      mov edx,dword[qwX+4]
      mov esi,eax
      mov edi,edx
      mov ebx,eax
      mov ecx,edx
      push ebp
      mov ebp,eax
      ROR64 eax,edx,n1
      ROR64 ebx,ecx,n2
      ROR64 esi,edi,n3
      pop ebp
      xor eax,ebx
      xor edx,ecx
      xor eax,esi
      xor edx,edi
}

macro SIGMA2 qwX,n1,n2,n3
{
      mov eax,dword[qwX]
      mov edx,dword[qwX+4]
      mov ebx,eax
      mov ecx,edx
      mov esi,eax
      mov edi,edx
      mov ebx,eax
      mov ecx,edx
      push ebp
      mov ebp,eax
      ROR64 eax,edx,n1
      ROR64 ebx,ecx,n2
      SHR64 esi,edi,n3
      pop ebp
      xor eax,ebx
      xor edx,ecx
      xor eax,esi
      xor edx,edi
}

macro SHA512R qwA,qwB,qwC,qwD,qwE,qwF,qwG,qwH,Iter
{
      SIGMA qwE,14,18,41
      mov ebx,dword[qwF]
      mov ecx,dword[qwF+4]
      mov esi,dword[qwE]
      mov edi,dword[qwE+4]
      xor ebx,dword[qwG]
      xor ecx,dword[qwG+4]
      and esi,ebx
      and edi,ecx
      xor esi,dword[qwG]
      xor edi,dword[qwG+4]
      add eax,dword[qwH]
      adc edx,dword[qwH+4]
      add eax,esi
      adc edx,edi
      mov esi,[cnt]
      shl esi,3
      add esi,Iter
      add eax,[SHA512K+esi*8]
      adc edx,[SHA512K+esi*8+4]
      add eax,dword[SHA512W+esi*8]
      adc edx,dword[SHA512W+esi*8+4]
      mov dword [SHA512tmp],eax
      mov dword [SHA512tmp+4],edx
      SIGMA qwA,28,34,39
      mov ebx,dword[qwA]
      mov ecx,dword[qwA+4]
      or ebx,dword[qwB]
      or ecx,dword[qwB+4]
      and ebx,dword[qwC]
      and ecx,dword[qwC+4]
      mov esi,dword[qwB]
      mov edi,dword[qwB+4]
      and esi,dword[qwA]
      and edi,dword[qwA+4]
      or ebx,esi
      or ecx,edi
      mov esi,dword[SHA512tmp]
      mov edi,dword[SHA512tmp+4]
      add eax,ebx
      adc edx,ecx
      add eax,esi
      adc edx,edi
      mov dword [qwH],eax
      mov dword [qwH+4],edx
      add dword [qwD],esi
      adc dword [qwD+4],edi
}

align 4
proc SHA512Transform uses ebx
     locals
       llA dq ?
       llB dq ?
       llC dq ?
       llD dq ?
       llE dq ?
       llF dq ?
       llG dq ?
       llH dq ?
       cnt dd ?
       SHA512tmp dq ?
       SHA512W dq 80 dup(?)
     endl
     mov esi,SHA512Digest
     mov edi,SHA512HashBuf
     MOV64 llA,esi+0*8
     MOV64 llB,esi+1*8
     MOV64 llC,esi+2*8
     MOV64 llD,esi+3*8
     MOV64 llE,esi+4*8
     MOV64 llF,esi+5*8
     MOV64 llG,esi+6*8
     MOV64 llH,esi+7*8
     xor esi,esi
     .repeat
	mov eax,[edi+8*esi]
	mov edx,[edi+8*esi+4]
	mov ebx,[edi+8*esi+8]
	mov ecx,[edi+8*esi+8+4]
	bswap eax
	bswap edx
	bswap ebx
	bswap ecx
	mov dword [SHA512W+8*esi],edx
	mov dword [SHA512W+8*esi+4],eax
	mov dword [SHA512W+8*esi+8],ecx
	mov dword [SHA512W+8*esi+8+4],ebx
	add esi,2
     .until esi = 16
     mov [cnt],esi
     .repeat
	mov edi,[cnt]
	lea esi,[edi-2]
	SIGMA2 SHA512W+esi*8,19,61,6
	mov edi,[cnt]
	lea esi,[edi-7]
	add eax,dword[SHA512W+esi*8]
	adc edx,dword[SHA512W+esi*8+4]
	mov dword [SHA512W+edi*8],eax
	mov dword [SHA512W+edi*8+4],edx
	mov edi,[cnt]
	lea esi,[edi-15]
	SIGMA2 SHA512W+esi*8,1,8,7
	mov edi,[cnt]
	lea esi,[edi-16]
	add eax,dword[SHA512W+esi*8]
	adc edx,dword[SHA512W+esi*8+4]
	add dword [SHA512W+edi*8],eax
	adc dword [SHA512W+edi*8+4],edx
	inc [cnt]
     .until [cnt] = 80
     xor edx,edx
     mov [cnt],edx
     .repeat
	SHA512R llA,llB,llC,llD,llE,llF,llG,llH,0
	SHA512R llH,llA,llB,llC,llD,llE,llF,llG,1
	SHA512R llG,llH,llA,llB,llC,llD,llE,llF,2
	SHA512R llF,llG,llH,llA,llB,llC,llD,llE,3
	SHA512R llE,llF,llG,llH,llA,llB,llC,llD,4
	SHA512R llD,llE,llF,llG,llH,llA,llB,llC,5
	SHA512R llC,llD,llE,llF,llG,llH,llA,llB,6
	SHA512R llB,llC,llD,llE,llF,llG,llH,llA,7
	inc [cnt]
     .until [cnt] = 10
     ADD64 SHA512Digest+0*8,llA
     ADD64 SHA512Digest+1*8,llB
     ADD64 SHA512Digest+2*8,llC
     ADD64 SHA512Digest+3*8,llD
     ADD64 SHA512Digest+4*8,llE
     ADD64 SHA512Digest+5*8,llF
     ADD64 SHA512Digest+6*8,llG
     ADD64 SHA512Digest+7*8,llH
     ret
endp

macro SHA512BURN
{
      xor eax,eax
      mov [SHA512Index],eax
      mov edi,SHA512HashBuf
      mov ecx,32
      rep stosd
}

align 4
proc SHA512_Init uses edi esi
     xor eax,eax
     mov dword [SHA512Len_Lo],eax
     mov dword [SHA512Len_Lo+4],eax
     mov edi,SHA512Digest
     mov esi,SHA512CHAIN
     mov ecx,16
     rep movsd
     SHA512BURN
     mov eax,SHA512Digest
     ret
endp

align 4
proc SHA512_Update uses esi edi ebx,Buffer:PBYTE,BufSize:DWORD
     mov ebx,[BufSize]
     mov eax,ebx
     xor edx,edx
     shld edx,eax,3
     shl eax,3
     add dword [SHA512Len_Lo],eax
     add dword [SHA512Len_Lo+4],edx
     .while ebx
	    mov eax,[SHA512Index]
	    mov edx,128
	    sub edx,eax
	    .if edx <= ebx
		lea edi,[SHA512HashBuf+eax]
		mov esi,[Buffer]
		mov ecx,edx
		rep movsb
		mov [Buffer],esi
		sub ebx,edx
		call SHA512Transform
		SHA512BURN
	   .else
		lea edi,[SHA512HashBuf+eax]
		mov esi,[Buffer]
		mov ecx,ebx
		rep movsb
		add [SHA512Index],ebx
		jmp @f
	   .endif
     .endw
@@:  ret
endp

align 4
proc SHA512_Final uses esi edi,_SHA512Digest:PBYTE
     mov ecx,[SHA512Index]
     mov byte [SHA512HashBuf+ecx],$80
     .if ecx >= 112
	 call SHA512Transform
	 SHA512BURN
     .endif
     mov eax,dword[SHA512Len_Lo]
     mov edx,dword[SHA512Len_Lo+4]
     bswap eax
     bswap edx
     mov dword [SHA512HashBuf+120],edx
     mov dword [SHA512HashBuf+120+4],eax
     call SHA512Transform
     mov eax,SHA512Digest
     xor ecx,ecx
     .repeat
	mov esi,[eax+ecx]
	mov edi,[eax+ecx+4]
	bswap edi
	bswap esi
	mov [eax+ecx+4],esi
	mov [eax+ecx],edi
	add ecx,8
     .until ecx = 64
     stdcall memcpy,[_SHA512Digest],SHA512Digest,64
     ret
endp