Branch data Line data Source code
1 : : /**********************************************************************
2 : : * gosthash.c *
3 : : * Copyright (c) 2005-2006 Cryptocom LTD *
4 : : * This file is distributed under the same license as OpenSSL *
5 : : * *
6 : : * Implementation of GOST R 34.11-94 hash function *
7 : : * uses on gost89.c and gost89.h Doesn't need OpenSSL *
8 : : **********************************************************************/
9 : : #include <string.h>
10 : :
11 : : #include "gost89.h"
12 : : #include "gosthash.h"
13 : :
14 : :
15 : : /* Use OPENSSL_malloc for memory allocation if compiled with
16 : : * -DOPENSSL_BUILD, and libc malloc otherwise
17 : : */
18 : : #ifndef MYALLOC
19 : : # ifdef OPENSSL_BUILD
20 : : # include <openssl/crypto.h>
21 : : # define MYALLOC(size) OPENSSL_malloc(size)
22 : : # define MYFREE(ptr) OPENSSL_free(ptr)
23 : : # else
24 : : # define MYALLOC(size) malloc(size)
25 : : # define MYFREE(ptr) free(ptr)
26 : : # endif
27 : : #endif
28 : : /* Following functions are various bit meshing routines used in
29 : : * GOST R 34.11-94 algorithms */
30 : 276 : static void swap_bytes (byte *w, byte *k)
31 : : {
32 : : int i,j;
33 [ + + ]: 1380 : for (i=0;i<4;i++)
34 [ + + ]: 9936 : for (j=0;j<8;j++)
35 : 8832 : k[i+4*j]=w[8*i+j];
36 : :
37 : 276 : }
38 : :
39 : : /* was A_A */
40 : 621 : static void circle_xor8 (const byte *w, byte *k)
41 : : {
42 : : byte buf[8];
43 : : int i;
44 : : memcpy(buf,w,8);
45 : 621 : memmove(k,w+8,24);
46 [ + + ]: 5589 : for(i=0;i<8;i++)
47 : 4968 : k[i+24]=buf[i]^k[i];
48 : 621 : }
49 : :
50 : : /* was R_R */
51 : 5106 : static void transform_3 (byte *data)
52 : : {
53 : : unsigned short int acc;
54 : 10212 : acc=(data[0]^data[2]^data[4]^data[6]^data[24]^data[30])|
55 : 5106 : ((data[1]^data[3]^data[5]^data[7]^data[25]^data[31])<<8);
56 : 5106 : memmove(data,data+2,30);
57 : : data[30]=acc&0xff;
58 : 5106 : data[31]=acc>>8;
59 : 5106 : }
60 : :
61 : : /* Adds blocks of N bytes modulo 2**(8*n). Returns carry*/
62 : 23 : static int add_blocks(int n,byte *left, const byte *right)
63 : : {
64 : : int i;
65 : 23 : int carry=0;
66 : : int sum;
67 [ + + ]: 759 : for (i=0;i<n;i++)
68 : : {
69 : 736 : sum=(int)left[i]+(int)right[i]+carry;
70 : 736 : left[i]=sum & 0xff;
71 : 736 : carry=sum>>8;
72 : : }
73 : 23 : return carry;
74 : : }
75 : :
76 : : /* Xor two sequences of bytes */
77 : 414 : static void xor_blocks (byte *result,const byte *a,const byte *b,size_t len)
78 : : {
79 : : size_t i;
80 [ + + ]: 13662 : for (i=0;i<len;i++) result[i]=a[i]^b[i];
81 : 414 : }
82 : :
83 : : /*
84 : : * Calculate H(i+1) = Hash(Hi,Mi)
85 : : * Where H and M are 32 bytes long
86 : : */
87 : 69 : static int hash_step(gost_ctx *c,byte *H,const byte *M)
88 : : {
89 : : byte U[32],W[32],V[32],S[32],Key[32];
90 : : int i;
91 : : /* Compute first key */
92 : 69 : xor_blocks(W,H,M,32);
93 : 69 : swap_bytes(W,Key);
94 : : /* Encrypt first 8 bytes of H with first key*/
95 : 69 : gost_enc_with_key(c,Key,H,S);
96 : : /* Compute second key*/
97 : 69 : circle_xor8(H,U);
98 : 69 : circle_xor8(M,V);
99 : 69 : circle_xor8(V,V);
100 : 69 : xor_blocks(W,U,V,32);
101 : 69 : swap_bytes(W,Key);
102 : : /* encrypt second 8 bytes of H with second key*/
103 : 69 : gost_enc_with_key(c,Key,H+8,S+8);
104 : : /* compute third key */
105 : 69 : circle_xor8(U,U);
106 : 69 : U[31]=~U[31]; U[29]=~U[29]; U[28]=~U[28]; U[24]=~U[24];
107 : 69 : U[23]=~U[23]; U[20]=~U[20]; U[18]=~U[18]; U[17]=~U[17];
108 : 69 : U[14]=~U[14]; U[12]=~U[12]; U[10]=~U[10]; U[ 8]=~U[ 8];
109 : 69 : U[ 7]=~U[ 7]; U[ 5]=~U[ 5]; U[ 3]=~U[ 3]; U[ 1]=~U[ 1];
110 : 69 : circle_xor8(V,V);
111 : 69 : circle_xor8(V,V);
112 : 69 : xor_blocks(W,U,V,32);
113 : 69 : swap_bytes(W,Key);
114 : : /* encrypt third 8 bytes of H with third key*/
115 : 69 : gost_enc_with_key(c,Key,H+16,S+16);
116 : : /* Compute fourth key */
117 : 69 : circle_xor8(U,U);
118 : 69 : circle_xor8(V,V);
119 : 69 : circle_xor8(V,V);
120 : 69 : xor_blocks(W,U,V,32);
121 : 69 : swap_bytes(W,Key);
122 : : /* Encrypt last 8 bytes with fourth key */
123 : 69 : gost_enc_with_key(c,Key,H+24,S+24);
124 [ + + ]: 897 : for (i=0;i<12;i++)
125 : 828 : transform_3(S);
126 : 69 : xor_blocks(S,S,M,32);
127 : 69 : transform_3(S);
128 : 69 : xor_blocks(S,S,H,32);
129 [ + + ]: 4278 : for (i=0;i<61;i++)
130 : 4209 : transform_3(S);
131 : : memcpy(H,S,32);
132 : 69 : return 1;
133 : : }
134 : :
135 : : /* Initialize gost_hash ctx - cleans up temporary structures and
136 : : * set up substitution blocks
137 : : */
138 : 0 : int init_gost_hash_ctx(gost_hash_ctx *ctx, const gost_subst_block *subst_block)
139 : : {
140 : : memset(ctx,0,sizeof(gost_hash_ctx));
141 : 0 : ctx->cipher_ctx = (gost_ctx *)MYALLOC(sizeof(gost_ctx));
142 [ # # ]: 0 : if (!ctx->cipher_ctx)
143 : : {
144 : : return 0;
145 : : }
146 : 0 : gost_init(ctx->cipher_ctx,subst_block);
147 : 0 : return 1;
148 : : }
149 : :
150 : : /*
151 : : * Free cipher CTX if it is dynamically allocated. Do not use
152 : : * if cipher ctx is statically allocated as in OpenSSL implementation of
153 : : * GOST hash algroritm
154 : : *
155 : : */
156 : 0 : void done_gost_hash_ctx(gost_hash_ctx *ctx)
157 : : {
158 : : /* No need to use gost_destroy, because cipher keys are not really
159 : : * secret when hashing */
160 : 0 : MYFREE(ctx->cipher_ctx);
161 : 0 : }
162 : :
163 : : /*
164 : : * reset state of hash context to begin hashing new message
165 : : */
166 : 0 : int start_hash(gost_hash_ctx *ctx)
167 : : {
168 [ # # ]: 0 : if (!ctx->cipher_ctx) return 0;
169 : 0 : memset(&(ctx->H),0,32);
170 : 0 : memset(&(ctx->S),0,32);
171 : 0 : ctx->len = 0L;
172 : 0 : ctx->left=0;
173 : 0 : return 1;
174 : : }
175 : :
176 : : /*
177 : : * Hash block of arbitrary length
178 : : *
179 : : *
180 : : */
181 : 23 : int hash_block(gost_hash_ctx *ctx,const byte *block, size_t length)
182 : : {
183 [ - + ]: 23 : if (ctx->left)
184 : : {
185 : : /*There are some bytes from previous step*/
186 : 0 : unsigned int add_bytes = 32-ctx->left;
187 [ # # ]: 0 : if (add_bytes>length)
188 : : {
189 : 0 : add_bytes = length;
190 : : }
191 : 0 : memcpy(&(ctx->remainder[ctx->left]),block,add_bytes);
192 : 0 : ctx->left+=add_bytes;
193 [ # # ]: 0 : if (ctx->left<32)
194 : : {
195 : : return 1;
196 : : }
197 : 0 : block+=add_bytes;
198 : 0 : length-=add_bytes;
199 : 0 : hash_step(ctx->cipher_ctx,ctx->H,ctx->remainder);
200 : 0 : add_blocks(32,ctx->S,ctx->remainder);
201 : 0 : ctx->len+=32;
202 : 23 : ctx->left=0;
203 : : }
204 [ - + ]: 23 : while (length>=32)
205 : : {
206 : 0 : hash_step(ctx->cipher_ctx,ctx->H,block);
207 : :
208 : 0 : add_blocks(32,ctx->S,block);
209 : 0 : ctx->len+=32;
210 : 0 : block+=32;
211 : 0 : length-=32;
212 : : }
213 [ + - ]: 23 : if (length)
214 : : {
215 : 23 : memcpy(ctx->remainder,block,ctx->left=length);
216 : : }
217 : : return 1;
218 : : }
219 : :
220 : : /*
221 : : * Compute hash value from current state of ctx
222 : : * state of hash ctx becomes invalid and cannot be used for further
223 : : * hashing.
224 : : */
225 : 23 : int finish_hash(gost_hash_ctx *ctx,byte *hashval)
226 : : {
227 : : byte buf[32];
228 : : byte H[32];
229 : : byte S[32];
230 : 23 : ghosthash_len fin_len=ctx->len;
231 : : byte *bptr;
232 : 23 : memcpy(H,ctx->H,32);
233 : 23 : memcpy(S,ctx->S,32);
234 [ + - ]: 23 : if (ctx->left)
235 : : {
236 : : memset(buf,0,32);
237 : 23 : memcpy(buf,ctx->remainder,ctx->left);
238 : 23 : hash_step(ctx->cipher_ctx,H,buf);
239 : 23 : add_blocks(32,S,buf);
240 : 23 : fin_len+=ctx->left;
241 : : }
242 : : memset(buf,0,32);
243 : 23 : bptr=buf;
244 : 23 : fin_len<<=3; /* Hash length in BITS!!*/
245 [ + + ]: 46 : while(fin_len>0)
246 : : {
247 : 23 : *(bptr++)=(byte)(fin_len&0xFF);
248 : 23 : fin_len>>=8;
249 : : };
250 : 23 : hash_step(ctx->cipher_ctx,H,buf);
251 : 23 : hash_step(ctx->cipher_ctx,H,S);
252 : : memcpy(hashval,H,32);
253 : 23 : return 1;
254 : : }
|
