ГОСТ 34.11-2012 Стрибог на flat assembler (x86)

в 20:51, , рубрики: Алгоритмы, гост, ГОСТ 34.11-2012, криптография, Стрибог, метки: , , ,

image

В продолжение темы OS Systemicus (т.к. там используется этот алгоритм) привожу полный код реализации ГОСТ 34.11-2012 на ассемблере. Эта же «библиотека» используется и в данной программе — http://omegicus.com/gost_34.11-2012_stribog

Не буду ничего описывать — написано уже достаточно, просто выложу код. Кого интересует не код, а подробности алгоритма — просьба не читать и не минусовать…

Сразу предупреждаю, код не оптимизирован. Отдаю код целиком в добрые руки оптимизаторов) Если у кого получится ускорить ее — выкладывайте тоже.

Как использовать:

        mov     ebx, 512                         ; 512 bit version
        mov     esi, buff
        mov     edi, MH
        mov     ecx, dword[m_sz]
        call    GOST_3411_2012
        ;
        mov     ebx, 256                         ; 512 bit version
        mov     esi, buff
        mov     edi, MH
        mov     ecx, dword[m_sz]
        call    GOST_3411_2012

В первом случае используется 512-битная версия, исходник в ^buff, результат в ^MH, длина исходных данных в ^m_sz.
Во втором случае всё аналогично, но используется 256-битная версия алгоритма.

Итак, секция кода:


align 4
GOST_3411_2012: ;( EBX variant, ESI const unsigned char *message, ECX length, EDI unsigned char *out)
        ; *hash = IV
        shl     ecx, 0x00000003             ; convert bytes to bits
        pushad
        mov     edi, G12_VARS
        mov     ecx, G12_VARS_SZ / 4
        xor     eax, eax
        cld
        rep     stosd
        ;
        mov     eax, 0x00000000
        cmp     ebx, 256
        jne    .h512
        mov     eax, 0x01010101
      .h512:
        mov     edi, gosth_hash
        mov     ecx, 64/4
        cld
        rep     stosd
        ;
        mov     byte[hash_X_v512 + 62], 0x02       ; init hash_X_v512
        popad
        ;
        ; Stage 2
       ;; while (len >= 512)
       ;; {
       ;;         memcpy(m, message + len/8 - 63 - ( (len & 0x7) == 0 ), 64);
       ;;         g_N(N,hash,m);
       ;;         AddModulo512(N,v512,N);
       ;;         AddModulo512(hash_X_Sigma,m,hash_X_Sigma);
       ;;         len -= 512;
       ;; }
        align 4
  .stage_2:
        cmp     ecx, 512
        jb     .stage_25
        ;
        push    ecx esi edi
        mov     edi, g12_X_m
        push    ecx
        shr     ecx, 0x00000003
        add     esi, ecx
        sub     esi, 64
        pop     ecx
        mov     ecx, 64/4
        cld
        rep     movsd
        pop     edi esi ecx
        ; g_N(N,hash,m)
        push    edx esi edi
        mov     edi, hash_X_N
        mov     esi, gosth_hash
        mov     edx, g12_X_m
        call    fn_g_N  ; EDI *N, ESI *h, EDX *m  ; +++++
        pop     edi esi edx
        ; AddModulo512(N,v512,N)
        push    eax esi edi
        mov     eax, hash_X_N
        mov     esi, hash_X_v512
        mov     edi, hash_X_N
        call    AddModulo512 ; eax *a  esi *b  edi *c
        pop     edi esi eax
        ; AddModulo512(hash_X_Sigma,m,hash_X_Sigma)
        push    eax esi edi
        mov     eax, hash_X_Sigma
        mov     esi, g12_X_m
        mov     edi, hash_X_Sigma
        call    AddModulo512 ; eax *a  esi *b  edi *c
        pop     edi esi eax
        ; len -= 512;
        sub     ecx, 512
        cmp     ecx, 512
        jae    .stage_2
        ; }
  .stage_25:
        ; +OK memset(m,0,64)
        push    edi ecx eax
        mov     edi, g12_X_m
        xor     eax, eax
        mov     ecx, 64/4
        cld
        rep     stosd
        pop     eax ecx edi
        ; +OK memcpy(m + 63 - len/8 + ( (len & 0x7) == 0 ), message, len/8 + 1 - ( (len & 0x7) == 0 ))
        push    eax ecx esi edi
        mov     eax, 64
        shr     ecx, 0x00000003
        sub     eax, ecx
        mov     edi, g12_X_m
        add     edi, eax
        cld
        rep     movsb
        pop     edi esi ecx eax
        ;
        ;
        ; Stage 3
        ; m[ 63 - len/8 ] |= (1 << (len & 0x7))
        push    ebx ecx edx
        push    ecx
        and     ecx, 0x00000007
        mov     ebx, 0x00000001
        shl     ebx, cl
        pop     ecx
        push    ecx
        shr     ecx, 0x00000003
        mov     edx, 63
        sub     edx, ecx
        pop     ecx
        add     edx, g12_X_m
        or      byte[edx], bl
        pop     edx ecx ebx






        ; g_N(N,hash,m);
        push    edx esi edi
        mov     edi, hash_X_N
        mov     esi, gosth_hash
        mov     edx, g12_X_m
        call    fn_g_N  ; EDI *N, ESI *h, EDX *m
        pop     edi esi edx
        ; v512[63] = len & 0xFF;
       ; push    ecx
       ; and     ecx, 0x000000FF
        mov     byte[hash_X_v512 + 63], cl
       ; pop     ecx
        ; v512[62] = len >> 8;
        push    ecx
        shr     ecx, 0x00000008
        mov     byte[hash_X_v512 + 62], cl
        pop     ecx
        ; AddModulo512(N,v512,N);
        push    esi edi
        mov     eax, hash_X_N
        mov     esi, hash_X_v512
        mov     edi, hash_X_N
        call    AddModulo512 ; eax *a  esi *b  edi *c
        pop     edi esi
        ; AddModulo512(hash_X_Sigma, m, hash_X_Sigma)
        push    esi edi
        mov     eax, hash_X_Sigma
        mov     esi, g12_X_m
        mov     edi, hash_X_Sigma
        call    AddModulo512 ; eax *a  esi *b  edi *c
        pop     edi esi
        ; g_N(v0,hash,N);
        push    esi edi
        mov     edi, hash_X_v0
        mov     esi, gosth_hash
        mov     edx, hash_X_N
        call    fn_g_N  ; EDI *N, ESI *h, EDX *m
        ; g_N(v0,hash,hash_X_Sigma);
        mov     edi, hash_X_v0
        mov     esi, gosth_hash
        mov     edx, hash_X_Sigma
        call    fn_g_N  ; EDI *N, ESI *h, EDX *m
        pop     edi esi
        ; memcpy(out, hash, 64)
        push    ecx esi edi
        mov     esi, gosth_hash

        mov     ecx, 64/4
        cmp     ebx, 256
        jne    .h512c
        mov     ecx, 32/4
      .h512c:
        cld
        rep     movsd
        pop     edi esi ecx
ret





ALIGN 4
HEX2STR_256_BIT:    ; ^ESI->, ^EDI<-
                PUSHAD
                XOR     ECX, ECX
                ;
            @@: INC     ECX
                CMP     ECX, 32
                JA     .END
                LODSB
                PUSH    ECX
                MOV     DL,  AL
                MOV     ECX, 0x02
           .L1: ROL     DL,  0x04
                MOV     EAX, 0x300F
                AND     AL,  DL
                AAA
                AAD     0x11
                STOSB
                LOOP   .L1
                POP     ECX
                JMP     @B
               .END:
                XOR     EAX, EAX
                STOSB
                POPAD
RETD

ALIGN 4
HEX2STR_512_BIT:    ; ^ESI->, ^EDI<-
                PUSHAD
                XOR     ECX, ECX
                ;
            @@: INC     ECX
                CMP     ECX, 64
                JA     .END
                LODSB
                PUSH    ECX
                MOV     DL,  AL
                MOV     ECX, 0x02
           .L1: ROL     DL,  0x04
                MOV     EAX, 0x300F
                AND     AL,  DL
                AAA
                AAD     0x11
                STOSB
                LOOP   .L1
                POP     ECX
                JMP     @B
               .END:
                XOR     EAX, EAX
                STOSB
                POPAD
RETD






 ;  Created on: May 5, 2012
 ;      Author: Oleksandr Kazymyrov
 ;              Acknowledgments: Oleksii Shevchuk
 ;
 ;    FASM x86: Vladislav Kabak


;include 'lib_gost_data.inc'

align 4
KeySchedule: ; unsigned char *K EAX, int i ECX   ; +OK
      push      eax ebx ecx esi
      ; K = K xor C[i]
      push      eax
      mov       ebx, eax
      mov       esi, eax
      mov       eax, ecx
      shl       eax, 0x06                        ; *64  (get block # by index)
      add       eax, const_C                     ; point to C-table
      call      AddXor512                        ; ebx eax esi ; AddXor512(K,C[i],K)
      pop       esi
      ;
      call      fn_S                             ; K = S(K)
      call      fn_P                             ; K = P(K)
      call      fn_L                             ; K = L(K)
      ;
      pop       esi ecx ebx eax
ret

align 4
fn_S: ; SubBytes S function. unsigned char *state [esi]               ; +OK
      push       eax ebx ecx edx
      xor        ecx, ecx                        ; int i = 0
      mov        ebx, G12_Sbox                   ; S-Box
      xor        edx, edx
      align 4                                    ; for(i=0;i<64;i++)  state[i] = Sbox[state[i]]
  @@: mov        dl,  byte[esi  + ecx]           ; edx = state[i]
      mov        al,  byte[G12_Sbox + edx]       ; al = Sbox[state[i]]
      mov        byte[esi + ecx], al             ; state[i] = Sbox[state[i]]
      inc        ecx
      cmp        ecx, 64
      jne        @b
      pop        edx ecx ebx eax
ret

align 4
fn_P: ; Transposition P function. unsigned char *state in ESI              ; +OK
      pushad
      xor       ecx, ecx                         ; int i = 0
      xor       edx, edx
      align 4
  @@: mov       dl,  byte [Tau  + ecx]           ; edx = Tau[i]
      mov       al,  byte [esi  + edx]           ; eax = state[Tau[i]]
      mov       byte[fn_P_t + ecx], al           ; t[i] = state[Tau[i]]
      inc       ecx                              ; for(i=0;i<64;i++)
      cmp       ecx, 64
      jne       @b
      ; memcpy(state,t,64)
      mov       ecx, 64/4
      mov       edi, esi
      mov       esi, fn_P_t
      cld
      rep       movsd
      popad
ret


align 4
fn_E: ; eax: ^K, ebx: *m, esi: *state            ; +OK
; unsigned char *K,  const unsigned char *m, unsigned char *state
      push      ebx ecx
      ; AddXor512(m,K,state)
      call      AddXor512                        ; m=ebx, K=eax, state=esi, safe needed
      xor       ecx, ecx                         ; int i = 0
      align 4                                    ; for(i=0;i<12;i++) {
  @@: call      fn_S                             ; state = S(state)
      call      fn_P                             ; state = P(state)
      call      fn_L                             ; state = L(state)
      ; K = KeySchedule(K, i)
      call      KeySchedule                      ; eax=K, i=ecx, safe needed
      ; AddXor512(state,K,state)
      mov       ebx, esi
      call      AddXor512                        ; (state, K, state)
      inc       ecx
      cmp       ecx, 12
      jne       @b                               ; }
      pop       ecx ebx
ret

align 4
AddXor512: ; AddRoundKey X-function. XOR 512-bytes          ; +OK  EBX EAX ESI
        push    ecx edx
        xor     ecx, ecx
        align 4
    @@: mov     edx, dword[ebx + ecx]
        xor     edx, dword[eax + ecx]
        mov     dword[esi + ecx], edx
        add     ecx, 4
        cmp     ecx, 64
        jne     @b
        pop     edx ecx
ret

; g (N,m,H)
align 4
fn_g_N:  ; EDI *N, ESI *h, EDX *m                 ; +OK
; const unsigned char *N,unsigned char *h,const unsigned char *m
      pushad
      push      esi
      ; AddXor512(N,h,K)
      mov       ebx, edi                         ; N
      mov       eax, esi                         ; h
      mov       esi, fn_g_N_K
      call      AddXor512                        ; ebx eax esi
      mov       esi, fn_g_N_K                    ;
      call      fn_S                             ; K = S(K)
      call      fn_P                             ; K = P(K)
      call      fn_L                             ; K = L(K)
      ; E(K,m,t)                                 ; t = E(K, m)
      mov       eax, fn_g_N_K                    ; K
      mov       ebx, edx                         ; m
      mov       esi, fn_g_N_t                    ; =t
      call      fn_E                             ; eax, ebx, esi
      ;
      pop       esi                              ; h
      push      esi                              ; h
      ; AddXor512(t,h,t)                         ; t = h xor t
      mov       ebx, fn_g_N_t                    ; t
      mov       eax, esi                         ; h
      mov       esi, fn_g_N_t                    ; t
      call      AddXor512                        ; ebx eax esi
      pop       esi                              ; h
      ; AddXor512(t,m,h)                         ; G = t xor m
      mov       ebx, fn_g_N_t                    ; t
      mov       eax, edx                         ; m
      call      AddXor512                        ; ebx eax esi
      popad
ret ; result = G


align 4
AddModulo512: ; eax *a  esi *b  edi *c           ; +OK
; const unsigned char *a,const unsigned char *b,unsigned char *c
      push      ebx ecx edx
      ;
      mov       ecx, 64                          ; int i = 63
      xor       ebx, ebx                         ; int t = 0
      ; for(i=63;i>=0;i--)
      ; {
      align 4
  @@: sar       ebx, 0x00000008                  ; t := t >> 8
      movzx     edx, byte[eax + ecx -1]          ; edx = a[i]
      add       ebx, edx                         ; t := (t>>8) + a[i]
      movzx     edx, byte[esi + ecx -1]          ; edx = b[i]
      add       ebx, edx                         ; t := (t>>8) + +a[i] + b[i]
      mov       byte[edi + ecx -1], bl           ; c[i] = t & 0xFF
      ;
      dec       ecx
      or        ecx, ecx
      jnz       @b
      ; }
      pop       edx ecx ebx
ret
























; L: umnozhenie 64bit vectora vhodnogo na matritsu A(64x64)
      ; unsigned long long v = 0;
      ; int i = 0, j = 0, k = 0;
      ; for(i=0;i<8;i++) {
      ;          v=0;
      ;          for(k=0;k<8;k++) {
      ;                  for(j=0;j<8;j++) {
      ;                         if ((state[i*8+k] & (1<<(7-j))) != 0)
      ;                                v ^= A[k*8+j]
      ;                  }
      ;          }
      ;          for(k=0;k<8;k++)
      ;          {
      ;                  state[i*8+k] = (v & ((unsigned long long)0xFF << (7-k)*8)) >> (7-k)*8;
      ;          }
      ;}

align 4
fn_L:  ; unsigned char *state in ESI               ;
      pushad
      ;
      xor      ecx, ecx                          ; int i = 0
      xor      ebx, ebx                          ; int j = 0
      xor      edx, edx                          ; int k = 0
      pxor     mm0, mm0                          ;
      ; for(i=0;i<8;i++) {
      align 4
 .next_i:
      pxor     mm0, mm0                          ; v = 0
      ;
      ; for(k=0;k<8;k++) {
      xor      edx, edx                          ; k = 0
      align 4
 .next_k:
      ; for(j=0;j<8;j++) {
      ;          if ((state[i*8+k] & (1<<(7-j))) != 0) v ^= A[k*8+j]
      ; }
      xor      ebx, ebx                          ; j = 0
      align 4
 .next_j:
      mov      eax, 0x00000007                   ; 7
      sub      eax, ebx                          ; 7-j
      mov      edi, 0x00000001                   ; 1
      ;
      push     ecx
      mov      ecx, eax
      shl      edi, cl                           ; (1<<(7-j))   == EDI
      pop      ecx
      ;
      mov      eax, ecx                          ; i
      shl      eax, 0x00000003                   ; i*8
      add      eax, edx                          ; (i*8+k)
      movzx    eax, byte[esi + eax]              ; state[i*8+k]
      and      eax, edi                          ; (  state[i*8+k] & (1<<(7-j)  )
      cmp      eax, 0                            ; if ((state[i*8+k] & (1<<(7-j))) != 0) v ^= A[k*8+j] ???
      jz      .next_ji                           ; == 0
      ; v ^= A[k*8+j]                            ; != 0
      mov      eax, edx                          ; k
      shl      eax, 0x00000003                   ; k*8
      add      eax, ebx                          ; k*8+j
      shl      eax, 0x00000003                   ; *8 (point from index to 64bit value (8bytes per value))
      add      eax, matrix_A                     ; ^A[k*8+j]
      movq     mm1, qword[eax]                   ; A[k*8+j]
      pxor     mm0, mm1                          ; v ^= A[k*8+j]
      jmp     .next_ji
      ; }
      jmp     .next_ki
      ; }

 .next_k2start:
      xor      edx, edx
      align 4
 .next_k2:
      mov      eax, 0x00000007                   ; 7
      sub      eax, edx                          ; (7-k)
      shl      eax, 0x00000003                   ; (7-k)*8
      mov      edi, 0x000000FF
      pxor     mm2, mm2
      movd     mm2, edi                          ; (unsigned long long)0xFF
      pxor     mm4, mm4
      movd     mm4, eax
      psllq    mm2, mm4                          ; (unsigned long long)0xFF << (7-k)*8
      movq     mm3, mm0                          ; v
      pand     mm3, mm2                          ; (v & ((unsigned long long)0xFF << (7-k)*8))
      psrlq    mm3, mm4                          ; (v & ((unsigned long long)0xFF << (7-k)*8)) >> (7-k)*8
      movd     eax, mm3
      mov      edi, ecx                          ; i
      shl      edi, 0x00000003                   ; i*8
      add      edi, edx                          ; i*8+k
      add      edi, esi                          ; ^state[i*8+k]
      mov      byte[edi], al                     ; state[i*8+k] = (v & ((unsigned long long)0xFF << (7-k)*8)) >> (7-k)*8;
      jmp     .next_k2i

      align 4
 .next_ji:
      inc      ebx
      cmp      ebx, 8
      jb      .next_j
      jmp     .next_ki
      align 4
 .next_ki:
      inc      edx
      cmp      edx, 8
      jb      .next_k
      jmp     .next_k2start
      align 4
 .next_k2i:
      inc      edx
      cmp      edx, 8
      jb      .next_k2
      jmp     .next_ii
      align 4
 .next_ii:
      inc      ecx
      cmp      ecx, 8
      jb      .next_i
      jmp     .end
 .end:
      ;
      emms
      popad
ret

 

А вот и данные для кода:


;--------------- GOST 34.11-2012 -----------------------------------------------------------------;
; Matrix A for MixColumns (L) function
align 32
matrix_A:     dq  0x8e20faa72ba0b470, 0x47107ddd9b505a38, 0xad08b0e0c3282d1c, 0xd8045870ef14980e
              dq  0x6c022c38f90a4c07, 0x3601161cf205268d, 0x1b8e0b0e798c13c8, 0x83478b07b2468764
              ;
              dq  0xa011d380818e8f40, 0x5086e740ce47c920, 0x2843fd2067adea10, 0x14aff010bdd87508
              dq  0x0ad97808d06cb404, 0x05e23c0468365a02, 0x8c711e02341b2d01, 0x46b60f011a83988e
              ;
              dq  0x90dab52a387ae76f, 0x486dd4151c3dfdb9, 0x24b86a840e90f0d2, 0x125c354207487869
              dq  0x092e94218d243cba, 0x8a174a9ec8121e5d, 0x4585254f64090fa0, 0xaccc9ca9328a8950
              ;
              dq  0x9d4df05d5f661451, 0xc0a878a0a1330aa6, 0x60543c50de970553, 0x302a1e286fc58ca7
              dq  0x18150f14b9ec46dd, 0x0c84890ad27623e0, 0x0642ca05693b9f70, 0x0321658cba93c138
              ;
              dq  0x86275df09ce8aaa8, 0x439da0784e745554, 0xafc0503c273aa42a, 0xd960281e9d1d5215
              dq  0xe230140fc0802984, 0x71180a8960409a42, 0xb60c05ca30204d21, 0x5b068c651810a89e
              ;
              dq  0x456c34887a3805b9, 0xac361a443d1c8cd2, 0x561b0d22900e4669, 0x2b838811480723ba
              dq  0x9bcf4486248d9f5d, 0xc3e9224312c8c1a0, 0xeffa11af0964ee50, 0xf97d86d98a327728
              ;
              dq  0xe4fa2054a80b329c, 0x727d102a548b194e, 0x39b008152acb8227, 0x9258048415eb419d
              dq  0x492c024284fbaec0, 0xaa16012142f35760, 0x550b8e9e21f7a530, 0xa48b474f9ef5dc18
              ;
              dq  0x70a6a56e2440598e, 0x3853dc371220a247, 0x1ca76e95091051ad, 0x0edd37c48a08a6d8
              dq  0x07e095624504536c, 0x8d70c431ac02a736, 0xc83862965601dd1b, 0x641c314b2b8ee083
; Substitution for SubBytes function
align 32
G12_Sbox:     db  0xFC, 0xEE, 0xDD, 0x11, 0xCF, 0x6E, 0x31, 0x16, 0xFB, 0xC4, 0xFA, 0xDA, 0x23, 0xC5, 0x04, 0x4D
              db  0xE9, 0x77, 0xF0, 0xDB, 0x93, 0x2E, 0x99, 0xBA, 0x17, 0x36, 0xF1, 0xBB, 0x14, 0xCD, 0x5F, 0xC1
              db  0xF9, 0x18, 0x65, 0x5A, 0xE2, 0x5C, 0xEF, 0x21, 0x81, 0x1C, 0x3C, 0x42, 0x8B, 0x01, 0x8E, 0x4F
              db  0x05, 0x84, 0x02, 0xAE, 0xE3, 0x6A, 0x8F, 0xA0, 0x06, 0x0B, 0xED, 0x98, 0x7F, 0xD4, 0xD3, 0x1F
              db  0xEB, 0x34, 0x2C, 0x51, 0xEA, 0xC8, 0x48, 0xAB, 0xF2, 0x2A, 0x68, 0xA2, 0xFD, 0x3A, 0xCE, 0xCC
              db  0xB5, 0x70, 0x0E, 0x56, 0x08, 0x0C, 0x76, 0x12, 0xBF, 0x72, 0x13, 0x47, 0x9C, 0xB7, 0x5D, 0x87
              db  0x15, 0xA1, 0x96, 0x29, 0x10, 0x7B, 0x9A, 0xC7, 0xF3, 0x91, 0x78, 0x6F, 0x9D, 0x9E, 0xB2, 0xB1
              db  0x32, 0x75, 0x19, 0x3D, 0xFF, 0x35, 0x8A, 0x7E, 0x6D, 0x54, 0xC6, 0x80, 0xC3, 0xBD, 0x0D, 0x57
              db  0xDF, 0xF5, 0x24, 0xA9, 0x3E, 0xA8, 0x43, 0xC9, 0xD7, 0x79, 0xD6, 0xF6, 0x7C, 0x22, 0xB9, 0x03
              db  0xE0, 0x0F, 0xEC, 0xDE, 0x7A, 0x94, 0xB0, 0xBC, 0xDC, 0xE8, 0x28, 0x50, 0x4E, 0x33, 0x0A, 0x4A
              db  0xA7, 0x97, 0x60, 0x73, 0x1E, 0x00, 0x62, 0x44, 0x1A, 0xB8, 0x38, 0x82, 0x64, 0x9F, 0x26, 0x41
              db  0xAD, 0x45, 0x46, 0x92, 0x27, 0x5E, 0x55, 0x2F, 0x8C, 0xA3, 0xA5, 0x7D, 0x69, 0xD5, 0x95, 0x3B
              db  0x07, 0x58, 0xB3, 0x40, 0x86, 0xAC, 0x1D, 0xF7, 0x30, 0x37, 0x6B, 0xE4, 0x88, 0xD9, 0xE7, 0x89
              db  0xE1, 0x1B, 0x83, 0x49, 0x4C, 0x3F, 0xF8, 0xFE, 0x8D, 0x53, 0xAA, 0x90, 0xCA, 0xD8, 0x85, 0x61
              db  0x20, 0x71, 0x67, 0xA4, 0x2D, 0x2B, 0x09, 0x5B, 0xCB, 0x9B, 0x25, 0xD0, 0xBE, 0xE5, 0x6C, 0x52
              db  0x59, 0xA6, 0x74, 0xD2, 0xE6, 0xF4, 0xB4, 0xC0, 0xD1, 0x66, 0xAF, 0xC2, 0x39, 0x4B, 0x63, 0xB6

; Substitution for Transposition (P) function
align 32
Tau:          db   0,  8, 16, 24, 32, 40, 48, 56
              db   1,  9, 17, 25, 33, 41, 49, 57
              db   2, 10, 18, 26, 34, 42, 50, 58
              db   3, 11, 19, 27, 35, 43, 51, 59
              db   4, 12, 20, 28, 36, 44, 52, 60
              db   5, 13, 21, 29, 37, 45, 53, 61
              db   6, 14, 22, 30, 38, 46, 54, 62
              db   7, 15, 23, 31, 39, 47, 55, 63

; Constant values for KeySchedule function [12][64]
align 32
const_C:
              db  0xb1,0x08,0x5b,0xda,0x1e,0xca,0xda,0xe9,0xeb,0xcb,0x2f,0x81,0xc0,0x65,0x7c,0x1f
              db  0x2f,0x6a,0x76,0x43,0x2e,0x45,0xd0,0x16,0x71,0x4e,0xb8,0x8d,0x75,0x85,0xc4,0xfc
              db  0x4b,0x7c,0xe0,0x91,0x92,0x67,0x69,0x01,0xa2,0x42,0x2a,0x08,0xa4,0x60,0xd3,0x15
              db  0x05,0x76,0x74,0x36,0xcc,0x74,0x4d,0x23,0xdd,0x80,0x65,0x59,0xf2,0xa6,0x45,0x07
              ;
              db  0x6f,0xa3,0xb5,0x8a,0xa9,0x9d,0x2f,0x1a,0x4f,0xe3,0x9d,0x46,0x0f,0x70,0xb5,0xd7
              db  0xf3,0xfe,0xea,0x72,0x0a,0x23,0x2b,0x98,0x61,0xd5,0x5e,0x0f,0x16,0xb5,0x01,0x31
              db  0x9a,0xb5,0x17,0x6b,0x12,0xd6,0x99,0x58,0x5c,0xb5,0x61,0xc2,0xdb,0x0a,0xa7,0xca
              db  0x55,0xdd,0xa2,0x1b,0xd7,0xcb,0xcd,0x56,0xe6,0x79,0x04,0x70,0x21,0xb1,0x9b,0xb7
              ;
              db  0xf5,0x74,0xdc,0xac,0x2b,0xce,0x2f,0xc7,0x0a,0x39,0xfc,0x28,0x6a,0x3d,0x84,0x35
              db  0x06,0xf1,0x5e,0x5f,0x52,0x9c,0x1f,0x8b,0xf2,0xea,0x75,0x14,0xb1,0x29,0x7b,0x7b
              db  0xd3,0xe2,0x0f,0xe4,0x90,0x35,0x9e,0xb1,0xc1,0xc9,0x3a,0x37,0x60,0x62,0xdb,0x09
              db  0xc2,0xb6,0xf4,0x43,0x86,0x7a,0xdb,0x31,0x99,0x1e,0x96,0xf5,0x0a,0xba,0x0a,0xb2
              ;
              db  0xef,0x1f,0xdf,0xb3,0xe8,0x15,0x66,0xd2,0xf9,0x48,0xe1,0xa0,0x5d,0x71,0xe4,0xdd
              db  0x48,0x8e,0x85,0x7e,0x33,0x5c,0x3c,0x7d,0x9d,0x72,0x1c,0xad,0x68,0x5e,0x35,0x3f
              db  0xa9,0xd7,0x2c,0x82,0xed,0x03,0xd6,0x75,0xd8,0xb7,0x13,0x33,0x93,0x52,0x03,0xbe
              db  0x34,0x53,0xea,0xa1,0x93,0xe8,0x37,0xf1,0x22,0x0c,0xbe,0xbc,0x84,0xe3,0xd1,0x2e
              ;
              db  0x4b,0xea,0x6b,0xac,0xad,0x47,0x47,0x99,0x9a,0x3f,0x41,0x0c,0x6c,0xa9,0x23,0x63
              db  0x7f,0x15,0x1c,0x1f,0x16,0x86,0x10,0x4a,0x35,0x9e,0x35,0xd7,0x80,0x0f,0xff,0xbd
              db  0xbf,0xcd,0x17,0x47,0x25,0x3a,0xf5,0xa3,0xdf,0xff,0x00,0xb7,0x23,0x27,0x1a,0x16
              db  0x7a,0x56,0xa2,0x7e,0xa9,0xea,0x63,0xf5,0x60,0x17,0x58,0xfd,0x7c,0x6c,0xfe,0x57
              ;
              db  0xae,0x4f,0xae,0xae,0x1d,0x3a,0xd3,0xd9,0x6f,0xa4,0xc3,0x3b,0x7a,0x30,0x39,0xc0
              db  0x2d,0x66,0xc4,0xf9,0x51,0x42,0xa4,0x6c,0x18,0x7f,0x9a,0xb4,0x9a,0xf0,0x8e,0xc6
              db  0xcf,0xfa,0xa6,0xb7,0x1c,0x9a,0xb7,0xb4,0x0a,0xf2,0x1f,0x66,0xc2,0xbe,0xc6,0xb6
              db  0xbf,0x71,0xc5,0x72,0x36,0x90,0x4f,0x35,0xfa,0x68,0x40,0x7a,0x46,0x64,0x7d,0x6e
              ;
              db  0xf4,0xc7,0x0e,0x16,0xee,0xaa,0xc5,0xec,0x51,0xac,0x86,0xfe,0xbf,0x24,0x09,0x54
              db  0x39,0x9e,0xc6,0xc7,0xe6,0xbf,0x87,0xc9,0xd3,0x47,0x3e,0x33,0x19,0x7a,0x93,0xc9
              db  0x09,0x92,0xab,0xc5,0x2d,0x82,0x2c,0x37,0x06,0x47,0x69,0x83,0x28,0x4a,0x05,0x04
              db  0x35,0x17,0x45,0x4c,0xa2,0x3c,0x4a,0xf3,0x88,0x86,0x56,0x4d,0x3a,0x14,0xd4,0x93
              ;
              db  0x9b,0x1f,0x5b,0x42,0x4d,0x93,0xc9,0xa7,0x03,0xe7,0xaa,0x02,0x0c,0x6e,0x41,0x41
              db  0x4e,0xb7,0xf8,0x71,0x9c,0x36,0xde,0x1e,0x89,0xb4,0x44,0x3b,0x4d,0xdb,0xc4,0x9a
              db  0xf4,0x89,0x2b,0xcb,0x92,0x9b,0x06,0x90,0x69,0xd1,0x8d,0x2b,0xd1,0xa5,0xc4,0x2f
              db  0x36,0xac,0xc2,0x35,0x59,0x51,0xa8,0xd9,0xa4,0x7f,0x0d,0xd4,0xbf,0x02,0xe7,0x1e
              ;
              db  0x37,0x8f,0x5a,0x54,0x16,0x31,0x22,0x9b,0x94,0x4c,0x9a,0xd8,0xec,0x16,0x5f,0xde
              db  0x3a,0x7d,0x3a,0x1b,0x25,0x89,0x42,0x24,0x3c,0xd9,0x55,0xb7,0xe0,0x0d,0x09,0x84
              db  0x80,0x0a,0x44,0x0b,0xdb,0xb2,0xce,0xb1,0x7b,0x2b,0x8a,0x9a,0xa6,0x07,0x9c,0x54
              db  0x0e,0x38,0xdc,0x92,0xcb,0x1f,0x2a,0x60,0x72,0x61,0x44,0x51,0x83,0x23,0x5a,0xdb
              ;
              db  0xab,0xbe,0xde,0xa6,0x80,0x05,0x6f,0x52,0x38,0x2a,0xe5,0x48,0xb2,0xe4,0xf3,0xf3
              db  0x89,0x41,0xe7,0x1c,0xff,0x8a,0x78,0xdb,0x1f,0xff,0xe1,0x8a,0x1b,0x33,0x61,0x03
              db  0x9f,0xe7,0x67,0x02,0xaf,0x69,0x33,0x4b,0x7a,0x1e,0x6c,0x30,0x3b,0x76,0x52,0xf4
              db  0x36,0x98,0xfa,0xd1,0x15,0x3b,0xb6,0xc3,0x74,0xb4,0xc7,0xfb,0x98,0x45,0x9c,0xed
              ;
              db  0x7b,0xcd,0x9e,0xd0,0xef,0xc8,0x89,0xfb,0x30,0x02,0xc6,0xcd,0x63,0x5a,0xfe,0x94
              db  0xd8,0xfa,0x6b,0xbb,0xeb,0xab,0x07,0x61,0x20,0x01,0x80,0x21,0x14,0x84,0x66,0x79
              db  0x8a,0x1d,0x71,0xef,0xea,0x48,0xb9,0xca,0xef,0xba,0xcd,0x1d,0x7d,0x47,0x6e,0x98
              db  0xde,0xa2,0x59,0x4a,0xc0,0x6f,0xd8,0x5d,0x6b,0xca,0xa4,0xcd,0x81,0xf3,0x2d,0x1b
              ;
              db  0x37,0x8e,0xe7,0x67,0xf1,0x16,0x31,0xba,0xd2,0x13,0x80,0xb0,0x04,0x49,0xb1,0x7a
              db  0xcd,0xa4,0x3c,0x32,0xbc,0xdf,0x1d,0x77,0xf8,0x20,0x12,0xd4,0x30,0x21,0x9f,0x9b
              db  0x5d,0x80,0xef,0x9d,0x18,0x91,0xcc,0x86,0xe7,0x1d,0xa4,0xaa,0x88,0xe1,0x28,0x52
              db  0xfa,0xf4,0x17,0xd5,0xd9,0xb2,0x1b,0x99,0x48,0xbc,0x92,0x4a,0xf1,0x1b,0xd7,0x20
              ;
              ;
;
align 32
G12_VARS:
fn_P_t        db    64 dup 0
fn_g_N_t      db    64 dup 0
fn_g_N_K      db    64 dup 0
g12_X_m       db    64 dup 0
gosth_hash    db    64 dup 0
hash_X_v512:  db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00
hash_X_v0:    db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
hash_X_Sigma: db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
hash_X_N:     db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
              db    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
G12_VARS_SZ   = $ - G12_VARS
;--------------- end of GOST 34.11-2012 ------------------------------------------------------------;  

Автор: omegicus

Источник

Поделиться

* - обязательные к заполнению поля