PureBoard

Code: Alles auswählen

    ;======================================================================
    ; Module:          SHA3.pbi
    ;
    ; Author:          sec
    ; Date:            Sep 03, 2013
    ; Version:         1.4.4
    ; Target Compiler: PureBasic 5.20+
    ; Target OS:       All
    ; License:         Free, unrestricted, no warranty whatsoever
    ;                  Use at your own risk
    ;======================================================================

    DeclareModule SHA3 
      Declare$ sha224(*Buffer, Size)
      Declare$ sha256(*Buffer, Size)
      Declare$ sha384(*Buffer, Size)
      Declare$ sha512(*Buffer, Size)   
    EndDeclareModule

    Module SHA3
      EnableExplicit
      ;-Internal functions 
     
      ;credit: Danilo
      DataSection
        _rndc:
        Data.q $0000000000000001, $0000000000008082, $800000000000808a
        Data.q $8000000080008000, $000000000000808b, $0000000080000001
        Data.q $8000000080008081, $8000000000008009, $000000000000008a
        Data.q $0000000000000088, $0000000080008009, $000000008000000a
        Data.q $000000008000808b, $800000000000008b, $8000000000008089
        Data.q $8000000000008003, $8000000000008002, $8000000000000080
        Data.q $000000000000800a, $800000008000000a, $8000000080008081
        Data.q $8000000000008080, $0000000080000001, $8000000080008008
       
        _rotc:
        Data.l 1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14
        Data.l 27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44
       
        _piln:
        Data.l 10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4
        Data.l 15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1
      EndDataSection
      Structure QuadArray : q.q[0] : EndStructure
      Structure LongArray : l.l[0] : EndStructure
     
     
      ;credit: wilbert
      Procedure.q Rotl64(val.q, n)   
        !mov ecx, [p.v_n]
        CompilerIf #PB_Compiler_Processor = #PB_Processor_x64
          !mov rax, [p.v_val]
          !rol rax, cl
        CompilerElse
          !btr ecx, 5
          !jc rotl64_1
          !mov eax, [p.v_val]
          !mov edx, [p.v_val + 4]
          !jmp rotl64_2
          !rotl64_1:
          !mov edx, [p.v_val]
          !mov eax, [p.v_val + 4]
          !rotl64_2:
          !push ebx
          !mov ebx, eax
          !shld eax, edx, cl
          !shld edx, ebx, cl
          !pop ebx
        CompilerEndIf
        ProcedureReturn
      EndProcedure

      #KECCAK_ROUNDS = 24
     
      Procedure keccakf(Array st.q(1), rounds.i)
        Define *rndc.QuadArray = ?_rndc
        Define *rotc.LongArray = ?_rotc
        Define *piln.LongArray = ?_piln
        Define.i i, j, round
        Define.q t
        Dim bc.q(5-1)
       
        For round = 0 To rounds -1
         
          ;Theta
          For i = 0 To 4 
            bc(i) = st(i) ! st(i + 5) ! st(i + 10) ! st(i + 15) ! st(i + 20)
           
          Next           
          For i = 0 To 4
            t = bc((i + 4) % 5) ! ROTL64(bc((i + 1) % 5), 1)       
            For j = 0 To 24 Step 5
              st(j + i) ! t
            Next
          Next
         
          ;Rho Pi
          t = st(1)     
          For i = 0 To 23
            j = *piln\l[i]       
            bc(0) = st(j)
            st(j) = ROTL64(t, *rotc\l[i])
           
            t = bc(0)
          Next
         
          ;Chi
          For j = 0 To 24 Step 5       
            For i = 0 To 4
              bc(i) = st(j + i)
            Next       
            For i = 0 To 4
              st(j + i) ! ((~bc((i + 1) % 5)) & bc((i + 2) % 5))
            Next
           
          Next
         
          ;Iota
          st(0) ! *rndc\q[round]
        Next
       
      EndProcedure   
     
     
      Procedure$ keccak(in, inlen, mdlen)
        Dim st.q(25)
        Dim temp.a(144)
        Define.i i, rsiz, rsizw
        Define stemp$
       
        rsiz = 200 - 2 * mdlen
        rsizw = rsiz / 8
       
        FillMemory(@st(),SizeOf(Quad) + SizeOf(Quad)*ArraySize(st()))
       
        While inlen >= rsiz
          For i = 0 To rsizw-1       
            st(i) ! PeekQ(in+i*SizeOf(Quad))       
          Next
          keccakf(st(), #KECCAK_ROUNDS)
          inlen - rsiz
          in + rsiz
        Wend   
       
        ;last block And padding
        CopyMemory(in, @temp(), inlen)
       
        temp(inlen) = 1
        inlen+1   
       
        FillMemory(@temp() + inlen,rsiz - inlen + 1 ,0)   
       
        temp(rsiz - 1) | $80       
        For i = 0 To rsizw -1   
          st(i) ! PeekQ(@temp(i*SizeOf(Quad)))
        Next   
       
        keccakf(st(), #KECCAK_ROUNDS)
       
       
        stemp$=""
        For i = 0 To mdlen -1
          stemp$ + RSet(Hex(PeekA(@st()+i)),2,"0")
        Next
        ProcedureReturn stemp$
      EndProcedure
     
     
      ;-SHA3 functions
      Procedure$ sha224(*Buffer, Size)   
        ProcedureReturn keccak(*Buffer, Size, 28)
      EndProcedure
     
      Procedure$ sha256(*Buffer, Size)   
        ProcedureReturn keccak(*Buffer, Size, 32)
      EndProcedure
     
      Procedure$ sha384(*Buffer, Size)
        ProcedureReturn keccak(*Buffer, Size, 48)
      EndProcedure
     
      Procedure$ sha512(*Buffer, Size)
        ProcedureReturn keccak(*Buffer, Size, 64)
      EndProcedure
     
     
    EndModule

    ;-Usage - Example
    CompilerIf #PB_Compiler_IsMainFile
      EnableExplicit
     
      Define msg$ = "The quick brown fox jumps over the lazy dog."
      Define msglen = StringByteLength(msg$)
     
      Debug SHA3::sha224(@msg$, msglen)
      Debug SHA3::sha256(@msg$, msglen)
      Debug SHA3::sha384(@msg$, msglen)
      Debug SHA3::sha512(@msg$, msglen)
     
     
    CompilerEndIf