SHA hash algorithm in PB ?

[newbie]

Hi,

I have searched on the forum but there is no SHA source code for PB.

Is anyone know where I can find PB source code for SHA-1, SHA-256, and SHA-512 ?

Thanks in advance.

[PB]

From what I've read, SHA is used for digital signature applications. If that's
what you want it for, then perhaps you could use PureBasic's MD5Fingerprint
command instead?

[newbie]

I already use MD5 currently as a workaround to do the hash of a password, which gives me a 32bytes output string, that is to say a 256 bits password.
The problem is that I would want a password greater than 256, so a greater output string.
SHA-256 could be sufficient.

Then it's also for my cryptographic PB algo collection, because I love this area even if I am very beginner in this area too, and because compared to powerbasic, PB has a tiny cryptographic libs collection.
Adding SHA would be a great extent

[blueb]

You might look at: http://www.pbcrypto.com/pbcrypto.php

They are written in PowerBasic, but should be convertible to Pure.

--blueb

[newbie]

Thanks, I'll try

EDIT : I have started for SHA-1 (not finished)

Code: Select all

Structure SHA
    H0.l
    H1.l
    H2.l
    H3.l
    H4.l
EndStructure

Procedure.l CalcSHA (Str.s, *SHA.SHA)

    DefType.l lStr, nq, n, adrW, adrWW, H0, H1, H2, H3, H4, a, b, C, D, E, temp
    Dim W.l(79)

    ;-not converted
    lStr = Len(Str)
    nq = Fix((lStr + 8) / 64) + 1
    n = 16 * nq
    ReDim WW(0 To n - 1) As Long
    
    WW(n - 1) = lStr * 8
    adrW = VarPtr(W(0))
    adrWW = VarPtr(WW(0))
    a = StrPtr(Str)
     ;-not converted
    
    !PUSH Edi
    !PUSH Esi
    
    !MOV Edi, adrWW
    !MOV Esi, a
    !MOV Ecx, lStr
    !REP MOVSB
    
    !MOV CL, &H80
    !MOV [Edi], CL
    
    !MOV Edi, adrWW
    !MOV Ecx, 2
    CalcSHA_Lbl1:
    !MOV AX, [Edi]
    !MOV dx, [Edi + 2]
    !MOV [Edi], DH
    !MOV [Edi + 1], DL
    !MOV [Edi + 2], AH
    !MOV [Edi + 3], AL
    !ADD Edi, 4
    !INC Ecx
    !CMP Ecx, n
    !JNE CalcSHA_Lbl1
    
    !MOV H0, &H67452301&
    !MOV H1, &HEFCDAB89&
    !MOV H2, &H98BADCFE&
    !MOV H3, &H10325476&
    !MOV H4, &HC3D2E1F0&
    
    CalcSHA_Lbl2:
    
    !MOV Edi, adrW
    !MOV Esi, adrWW
    !MOV Ecx, 64
    !REP MOVSB
    !MOV adrWW, Esi
    
    !MOV Ecx, 0
    CalcSHA_Lbl3:
    !MOV Esi, Ecx
    !ADD Esi, Esi
    !ADD Esi, Esi
    !ADD Esi, adrW
    
    !MOV Eax, [Esi + 52]
    !XOR Eax, [Esi + 32]
    !XOR Eax, [Esi + 8]
    !XOR Eax, [Esi]
    
    !MOV Edx, Eax
    !SHL Eax, 1
    !SHR Edx, 31
    !OR  Eax, Edx
    !MOV [Esi + 64], Eax
    
    !INC Ecx
    !CMP Ecx, 64
    !JNE CalcSHA_Lbl3
    
    !MOV Eax, H0
    !MOV a, Eax
    !MOV Eax, H1
    !MOV b, Eax
    !MOV Eax, H2
    !MOV C, Eax
    !MOV Eax, H3
    !MOV D, Eax
    !MOV Eax, H4
    !MOV E, Eax
    
    !MOV Edi, 0
    CalcSHA_Lbl4:
    !CMP Edi, 19
    !JA CalcSHA_Lbl5
    
    !MOV Ecx, b
    !AND Ecx, C
    !MOV Eax, b
    !NOT Eax
    !AND Eax, D
    !OR  Ecx, Eax
    !ADD Ecx, &H5A827999&
    !JMP CalcSHA_Lbl8
    
    CalcSHA_Lbl5:
    !CMP Edi, 39
    !JA CalcSHA_Lbl6
    
    !MOV Ecx, b
    !XOR Ecx, C
    !XOR Ecx, D
    !ADD Ecx, &H6ED9EBA1&
    !JMP CalcSHA_Lbl8
    
    CalcSHA_Lbl6:
    !CMP Edi, 59
    !JA CalcSHA_Lbl7
    
    !MOV Eax, b
    !AND Eax, C
    !MOV Ecx, b
    !AND Ecx, D
    !MOV Edx, C
    !AND Edx, D
    !OR  Ecx, Eax
    !OR  Ecx, Edx
    !ADD Ecx, &H8F1BBCDC&
    !JMP CalcSHA_Lbl8
    
    CalcSHA_Lbl7:
    !MOV Ecx, b
    !XOR Ecx, C
    !XOR Ecx, D
    !ADD Ecx, &HCA62C1D6&
    
    CalcSHA_Lbl8:
    !MOV Eax, a
    !MOV Edx, Eax
    !SHL Eax, 5
    !SHR Edx, 27
    !OR  Eax, Edx
    !ADD Eax, E
    !ADD Ecx, Eax
    
    !MOV Esi, Edi
    !ADD Esi, Esi
    !ADD Esi, Esi
    !ADD Esi, adrW
    !MOV Esi, [Esi]
    !MOV temp, Esi
    
    !ADD temp, Ecx
    !MOV Eax, D
    !MOV E, Eax
    !MOV Eax, C
    !MOV D, Eax
    !MOV Eax, b
    !MOV Edx, Eax
    !SHL Eax, 30
    !SHR Edx, 2
    !OR  Eax, Edx
    !MOV C, Eax
    !MOV Eax, a
    !MOV b, Eax
    !MOV Eax, temp
    !MOV a, Eax
    
    !INC Edi
    !CMP Edi, 80
    !JNE CalcSHA_Lbl4
    
    !MOV Eax, a
    !ADD H0, Eax
    !MOV Eax, b
    !ADD H1, Eax
    !MOV Eax, C
    !ADD H2, Eax
    !MOV Eax, D
    !ADD H3, Eax
    !MOV Eax, E
    !ADD H4, Eax
    
    !SUB nq, 1
    !JNE CalcSHA_Lbl2
    
    !POP Esi
    !POP Edi
    
    *SHA\H0 = H0 : *SHA\H1 = H1 : *SHA\H2 = H2 : *SHA\H3 = H3: *SHA\H4 = H4

EndProcedure

Procedure.s tSHA(*SHA.SHA)
    ProcedureReturn = Hex$(*SHA\H0, 8) + " " + Hex$(*SHA\H1, 8) + " " + Hex$(*SHA\H2, 8) + " " + Hex$(*SHA\H3, 8) + " " + Hex$(*SHA\H4, 8)
EndProcedure

Procedure PbMain()
    SHA.SHA
    
    ; Control samples from official document
    CalcSHA("abc", @SHA)
    If tSHA(@SHA) <> "A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D"
        Debug "Error-1"
    EndIf
    
    CalcSHA("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", @SHA)
    If tSHA(@SHA) <> "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1"
        Debug "Error-2"
    EndIf
        
    ;TEST of speed
    R.s
    Tmp.s
    t1 As Single, t2 As Single
    
        Open $FileNm For Binary As #1
            Tmp = Space$(Lof(1)): Get$ #1, Lof(1), Tmp: Close #1
            
            t1 = Timer: CalcSHA Tmp, SHA: t2 = Timer
            MsgBox Format$(Len(Tmp) / 1024 / (t2 - t1), "# Kb per second")
            
EndProcedure

between the "not converted" labels, it's stuff that I have no idea at all how to convert.
Anyway, there is other things not converted yet below, this is just to show what I am sure to not be able to convert (I don't know powerbasic, just visual basic).

I'll continue later, but if someone want to finish, feel free to do so

EDIT :
I encounter an ASM error at the line :

Code: Select all

 !MOV H0, $67452301

and I don't know ASM at all to solve this...

[Seldon]

Here it is my attempt, it does compile, but it gives an error on execution (invalid memory address). Maybe some assembly guru, could help.

First, the original PowerBasic source by Semen Matusovski:

Code: Select all

   Type SHA
      H0 As Long
      H1 As Long
      H2 As Long
      H3 As Long
      H4 As Long
   End Type

   Function CalcSHA (Str As String, SHA As SHA) As Long
      #Register None

      Dim lStr As Long, nq As Long, n As Long, adrW As Long, adrWW As Long
      Dim H0 As Long, H1 As Long, H2 As Long, H3 As Long, H4 As Long, W(0 : 79) As Long
      Dim A As Long, B As Long, C As Long, D As Long, E As Long, TEMP As Long

      lStr = Len(Str)
      nq = Fix((lStr + 8) / 64) + 1
      n = 16 * nq
      ReDim WW(0 To n - 1) As Long

      WW(n - 1) = lStr * 8
      adrW = VarPtr(W(0))
      adrWW = VarPtr(WW(0))
      A = StrPtr(Str)

      ! PUSH EDI
      ! PUSH ESI

      ! MOV EDI, adrWW
      ! MOV ESI, A
      ! MOV ECX, lStr
      ! REP MOVSB

      ! MOV CL, &H80
      ! MOV [EDI], CL

      ! MOV EDI, adrWW
      ! MOV ECX, 2
 CalcSHA_Lbl1:
      ! MOV AX, [EDI]
      ! MOV DX, [EDI + 2]
      ! MOV [EDI], DH
      ! MOV [EDI + 1], DL
      ! MOV [EDI + 2], AH
      ! MOV [EDI + 3], AL
      ! ADD EDI, 4
      ! INC ECX
      ! CMP ECX, n
      ! JNE CalcSHA_Lbl1

      ! MOV H0, &H67452301&
      ! MOV H1, &HEFCDAB89&
      ! MOV H2, &H98BADCFE&
      ! MOV H3, &H10325476&
      ! MOV H4, &HC3D2E1F0&

 CalcSHA_Lbl2:

      ! MOV EDI, adrW
      ! MOV ESI, adrWW
      ! MOV ECX, 64
      ! REP MOVSB
      ! MOV adrWW, ESI

      ! MOV ECX, 0
 CalcSHA_Lbl3:
      ! MOV ESI, ECX
      ! ADD ESI, ESI
      ! ADD ESI, ESI
      ! ADD ESI, adrW

      ! MOV EAX, [ESI + 52]
      ! XOR EAX, [ESI + 32]
      ! XOR EAX, [ESI + 8]
      ! XOR EAX, [ESI]

      ! MOV EDX, EAX
      ! SHL EAX, 1
      ! SHR EDX, 31
      ! OR  EAX, EDX
      ! MOV [ESI + 64], EAX

      ! INC ECX
      ! CMP ECX, 64
      ! JNE CalcSHA_Lbl3

      ! MOV EAX, H0
      ! MOV A, EAX
      ! MOV EAX, H1
      ! MOV B, EAX
      ! MOV EAX, H2
      ! MOV C, EAX
      ! MOV EAX, H3
      ! MOV D, EAX
      ! MOV EAX, H4
      ! MOV E, EAX

      ! MOV EDI, 0
 CalcSHA_Lbl4:
      ! CMP EDI, 19
      ! JA CalcSHA_Lbl5

      ! MOV ECX, B
      ! AND ECX, C
      ! MOV EAX, B
      ! NOT EAX
      ! AND EAX, D
      ! OR  ECX, EAX
      ! ADD ECX, &H5A827999&
      ! JMP CalcSHA_Lbl8

 CalcSHA_Lbl5:
      ! CMP EDI, 39
      ! JA CalcSHA_Lbl6

      ! MOV ECX, B
      ! XOR ECX, C
      ! XOR ECX, D
      ! ADD ECX, &H6ED9EBA1&
      ! JMP CalcSHA_Lbl8

 CalcSHA_Lbl6:
      ! CMP EDI, 59
      ! JA CalcSHA_Lbl7

      ! MOV EAX, B
      ! AND EAX, C
      ! MOV ECX, B
      ! AND ECX, D
      ! MOV EDX, C
      ! AND EDX, D
      ! OR  ECX, EAX
      ! OR  ECX, EDX
      ! ADD ECX, &H8F1BBCDC&
      ! JMP CalcSHA_Lbl8

 CalcSHA_Lbl7:
      ! MOV ECX, B
      ! XOR ECX, C
      ! XOR ECX, D
      ! ADD ECX, &HCA62C1D6&

 CalcSHA_Lbl8:
      ! MOV EAX, A
      ! MOV EDX, EAX
      ! SHL EAX, 5
      ! SHR EDX, 27
      ! OR  EAX, EDX
      ! ADD EAX, E
      ! ADD ECX, EAX

      ! MOV ESI, EDI
      ! ADD ESI, ESI
      ! ADD ESI, ESI
      ! ADD ESI, adrW
      ! MOV ESI, [ESI]
      ! MOV TEMP, ESI

      ! ADD Temp, ECX
      ! MOV EAX, D
      ! MOV E, EAX
      ! MOV EAX, C
      ! MOV D, EAX
      ! MOV EAX, B
      ! MOV EDX, EAX
      ! SHL EAX, 30
      ! SHR EDX, 2
      ! OR  EAX, EDX
      ! MOV C, EAX
      ! MOV EAX, A
      ! MOV B, EAX
      ! MOV EAX, TEMP
      ! MOV A, EAX

      ! INC EDI
      ! CMP EDI, 80
      ! JNE CalcSHA_Lbl4

      ! MOV EAX, A
      ! ADD H0, EAX
      ! MOV EAX, B
      ! ADD H1, EAX
      ! MOV EAX, C
      ! ADD H2, EAX
      ! MOV EAX, D
      ! ADD H3, EAX
      ! MOV EAX, E
      ! ADD H4, EAX

      ! SUB nq, 1
      ! JNE CalcSHA_Lbl2

      ! POP ESI
      ! POP EDI

      SHA.H0 = H0: SHA.H1 = H1: SHA.H2 = H2: SHA.H3 = H3: SHA.H4 = H4

   End Function

Here it is my PureBasic conversion:

Code: Select all

Structure SHA 
 H0.l 
 H1.l 
 H2.l 
 H3.l 
 H4.l 
EndStructure

Procedure.l CalcSHA(STR.s, *SHA.SHA)
 DefType.l lStr,nq,n,adrW,adrWW,H0,H1,H2,H3,H4,A,B,C,D,E,TEMP
 Dim W.l(79)
 
 lStr=Len(STR) 
 nq=((lStr+8)/64)+1 ;nq=Fix((lStr+8)/64)+1 
 n=16*nq 
 
 Dim WW.l(n-1)
 adrW=@W(0)
 adrWW=@WW(0)
 a=@Str
 
 PUSH edi 
 PUSH esi 
    
 MOV edi,adrWW 
 MOV esi,a 
 MOV ecx,lStr 
 REP MOVSB 
    
 MOV CL,$80 
 MOV [edi],CL 
    
 MOV edi,adrWW 
 MOV ecx,2 
 
 SHALbl1: 
 MOV AX,[edi] 
 MOV dx,[edi+2] 
 MOV [edi],DH 
 MOV [edi+1],DL 
 MOV [edi+2],AH 
 MOV [edi+3],AL 
 ADD edi,4 
 INC ecx 
 CMP ecx,n 
 JNE l_shalbl1 
    
 MOV H0,$67452301
 MOV H1,$EFCDAB89
 MOV H2,$98BADCFE 
 MOV H3,$10325476 
 MOV H4,$C3D2E1F0 
    
 SHALbl2: 
 MOV edi,adrW 
 MOV esi,adrWW 
 MOV ecx,64 
 REP MOVSB 
 MOV adrWW,esi 
    
 MOV ecx,0 
 SHALbl3: 
 MOV esi,eax 
 ADD esi,esi
 ADD esi,esi 
 ADD esi,adrW 
    
 MOV eax,[esi+52] 
 XOR eax,[esi+32] 
 XOR eax,[esi+8] 
 XOR eax,[esi] 
    
 MOV edx,eax 
 SHL eax,1 
 SHR edx,31 
 !OR  eax,edx 
 MOV [esi+64],eax 
    
 INC ecx 
 CMP ecx,64 
 JNE l_shalbl3 
    
 MOV eax,H0 
 MOV A,eax 
 MOV eax,H1 
 MOV B,eax 
 MOV eax,H2 
 MOV C,eax 
 MOV eax,H3 
 MOV D,eax 
 MOV eax,H4 
 MOV E,eax 
    
 MOV edi,0 
 SHALbl4: 
 CMP edi,19 
 JA l_shalbl5 
    
 MOV ecx,B 
 And ecx,C 
 MOV eax,B 
 NOT eax 
 And eax,D
 !OR  ecx,eax 
 ADD ecx,$5A827999
 JMP l_shalbl8 
    
 SHALbl5: 
 CMP edi,39 
 JA l_shalbl6 
    
 MOV ecx,B 
 XOR ecx,C 
 XOR ecx,D 
 ADD ecx,$6ED9EBA1
 JMP l_shalbl8 
    
 SHALbl6: 
 CMP edi,59 
 JA l_shalbl7 
   
 MOV eax,B 
 And eax,C 
 MOV ecx,B 
 And ecx,D 
 MOV edx,C 
 And edx,D 
 !OR  ecx,eax 
 !OR  ecx,edx 
 ADD ecx,$8F1BBCDC
 JMP l_shalbl8 
    
 SHALbl7: 
 MOV ecx,B 
 XOR ecx,C 
 XOR ecx,D 
 ADD ecx,$CA62C1D6
    
 SHALbl8: 
 MOV eax,A 
 MOV edx,eax 
 SHL eax,5 
 SHR edx,27 
 !OR  eax,edx 
 ADD eax,E 
 ADD ecx,eax 
    
 MOV esi,edi 
 ADD esi,esi 
 ADD esi,esi 
 ADD esi,adrW 
 MOV esi,[esi] 
 MOV TEMP,esi 
    
 ADD TEMP,ecx 
 MOV eax,D 
 MOV E,eax 
 MOV eax,C 
 MOV D,eax 
 MOV eax,B 
 MOV edx,eax 
 SHL eax,30 
 SHR edx,2 
 !OR  eax,edx 
 MOV C,eax
 MOV eax,A 
 MOV B,eax 
 MOV eax,TEMP 
 MOV A,eax 
    
 INC Edi 
 CMP Edi,80 
 JNE l_shalbl4 
   
 MOV eax,A 
 ADD H0,eax 
 MOV eax,B 
 ADD H1,eax 
 MOV eax,C 
 ADD H2,eax 
 MOV eax,D 
 ADD H3,eax 
 MOV eax,E 
 ADD H4,eax
    
 SUB nq,1 
 JNE l_shalbl2 
    
 POP esi 
 POP edi 
    
 *SHA\H0=H0
 *SHA\H1=H1
 *SHA\H2=H2
 *SHA\H3=H3
 *SHA\H4=H4 
EndProcedure

OpenConsole()
*digest.SHA
CalcSHA("Ciao mondo!",*digest)

[USCode]

You might look at: http://www.pbcrypto.com/pbcrypto.php

They are written in PowerBasic, but should be convertible to Pure.

--blueb

Wow, that page is a great resource!
Should be pretty straightforward to leverage it and convert those to PureBasic, no?
Maybe some of the more popular ones could work their way into the standard PB "Cipher" library? SHA1, Rijndael, Blowfish?