packaging: Enable LTO and set visibility to hidden
[platform/upstream/btrfs-progs.git] / tests / sha224-256.c
1 /************************* sha224-256.c ************************/
2 /***************** See RFC 6234 for details. *******************/
3 /* Copyright (c) 2011 IETF Trust and the persons identified as */
4 /* authors of the code.  All rights reserved.                  */
5 /* See sha.h for terms of use and redistribution.              */
6
7 /*
8  * Description:
9  *   This file implements the Secure Hash Algorithms SHA-224 and
10  *   SHA-256 as defined in the U.S. National Institute of Standards
11  *   and Technology Federal Information Processing Standards
12  *   Publication (FIPS PUB) 180-3 published in October 2008
13  *   and formerly defined in its predecessors, FIPS PUB 180-1
14  *   and FIP PUB 180-2.
15  *
16  *   A combined document showing all algorithms is available at
17  *       http://csrc.nist.gov/publications/fips/
18  *              fips180-3/fips180-3_final.pdf
19  *
20  *   The SHA-224 and SHA-256 algorithms produce 224-bit and 256-bit
21  *   message digests for a given data stream.  It should take about
22  *   2**n steps to find a message with the same digest as a given
23  *   message and 2**(n/2) to find any two messages with the same
24  *   digest, when n is the digest size in bits.  Therefore, this
25  *   algorithm can serve as a means of providing a
26  *   "fingerprint" for a message.
27  *
28  * Portability Issues:
29  *   SHA-224 and SHA-256 are defined in terms of 32-bit "words".
30  *   This code uses <stdint.h> (included via "sha.h") to define 32-
31  *   and 8-bit unsigned integer types.  If your C compiler does not
32  *   support 32-bit unsigned integers, this code is not
33  *   appropriate.
34  *
35  * Caveats:
36  *   SHA-224 and SHA-256 are designed to work with messages less
37  *   than 2^64 bits long.  This implementation uses SHA224/256Input()
38  *   to hash the bits that are a multiple of the size of an 8-bit
39  *   octet, and then optionally uses SHA224/256FinalBits()
40  *   to hash the final few bits of the input.
41  */
42
43 #include "tests/sha.h"
44 #include "tests/sha-private.h"
45
46 /* Define the SHA shift, rotate left, and rotate right macros */
47 #define SHA256_SHR(bits,word)      ((word) >> (bits))
48 #define SHA256_ROTL(bits,word)                         \
49   (((word) << (bits)) | ((word) >> (32-(bits))))
50 #define SHA256_ROTR(bits,word)                         \
51   (((word) >> (bits)) | ((word) << (32-(bits))))
52
53 /* Define the SHA SIGMA and sigma macros */
54 #define SHA256_SIGMA0(word)   \
55   (SHA256_ROTR( 2,word) ^ SHA256_ROTR(13,word) ^ SHA256_ROTR(22,word))
56 #define SHA256_SIGMA1(word)   \
57   (SHA256_ROTR( 6,word) ^ SHA256_ROTR(11,word) ^ SHA256_ROTR(25,word))
58 #define SHA256_sigma0(word)   \
59   (SHA256_ROTR( 7,word) ^ SHA256_ROTR(18,word) ^ SHA256_SHR( 3,word))
60 #define SHA256_sigma1(word)   \
61   (SHA256_ROTR(17,word) ^ SHA256_ROTR(19,word) ^ SHA256_SHR(10,word))
62
63 /*
64  * Add "length" to the length.
65  * Set Corrupted when overflow has occurred.
66  */
67 static uint32_t addTemp;
68 #define SHA224_256AddLength(context, length)               \
69   (addTemp = (context)->Length_Low, (context)->Corrupted = \
70     (((context)->Length_Low += (length)) < addTemp) &&     \
71     (++(context)->Length_High == 0) ? shaInputTooLong :    \
72                                       (context)->Corrupted )
73
74 /* Local Function Prototypes */
75 static int SHA224_256Reset(SHA256Context *context, uint32_t *H0);
76 static void SHA224_256ProcessMessageBlock(SHA256Context *context);
77 static void SHA224_256Finalize(SHA256Context *context,
78   uint8_t Pad_Byte);
79 static void SHA224_256PadMessage(SHA256Context *context,
80   uint8_t Pad_Byte);
81 static int SHA224_256ResultN(SHA256Context *context,
82   uint8_t Message_Digest[ ], int HashSize);
83
84 /* Initial Hash Values: FIPS 180-3 section 5.3.2 */
85 static uint32_t SHA224_H0[SHA256HashSize/4] = {
86     0xC1059ED8, 0x367CD507, 0x3070DD17, 0xF70E5939,
87     0xFFC00B31, 0x68581511, 0x64F98FA7, 0xBEFA4FA4
88 };
89
90 /* Initial Hash Values: FIPS 180-3 section 5.3.3 */
91 static uint32_t SHA256_H0[SHA256HashSize/4] = {
92   0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
93   0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
94 };
95
96 /*
97  * SHA224Reset
98  *
99  * Description:
100  *   This function will initialize the SHA224Context in preparation
101  *   for computing a new SHA224 message digest.
102  *
103  * Parameters:
104  *   context: [in/out]
105  *     The context to reset.
106  *
107  * Returns:
108  *   sha Error Code.
109  */
110 int SHA224Reset(SHA224Context *context)
111 {
112   return SHA224_256Reset(context, SHA224_H0);
113 }
114
115 /*
116  * SHA224Input
117  *
118  * Description:
119  *   This function accepts an array of octets as the next portion
120  *   of the message.
121  *
122  * Parameters:
123  *   context: [in/out]
124  *     The SHA context to update.
125  *   message_array[ ]: [in]
126  *     An array of octets representing the next portion of
127  *     the message.
128  *   length: [in]
129  *     The length of the message in message_array.
130  *
131  * Returns:
132  *   sha Error Code.
133  *
134  */
135 int SHA224Input(SHA224Context *context, const uint8_t *message_array,
136     unsigned int length)
137 {
138   return SHA256Input(context, message_array, length);
139 }
140
141 /*
142  * SHA224FinalBits
143  *
144  * Description:
145  *   This function will add in any final bits of the message.
146  *
147  * Parameters:
148  *   context: [in/out]
149  *     The SHA context to update.
150  *   message_bits: [in]
151  *     The final bits of the message, in the upper portion of the
152  *     byte.  (Use 0b###00000 instead of 0b00000### to input the
153  *     three bits ###.)
154  *   length: [in]
155  *     The number of bits in message_bits, between 1 and 7.
156  *
157  * Returns:
158  *   sha Error Code.
159  */
160 int SHA224FinalBits(SHA224Context *context,
161                     uint8_t message_bits, unsigned int length)
162 {
163   return SHA256FinalBits(context, message_bits, length);
164 }
165
166 /*
167  * SHA224Result
168  *
169  * Description:
170  *   This function will return the 224-bit message digest
171  *   into the Message_Digest array provided by the caller.
172  *   NOTE:
173  *    The first octet of hash is stored in the element with index 0,
174  *    the last octet of hash in the element with index 27.
175  *
176  * Parameters:
177  *   context: [in/out]
178  *     The context to use to calculate the SHA hash.
179  *   Message_Digest[ ]: [out]
180  *     Where the digest is returned.
181  *
182  * Returns:
183  *   sha Error Code.
184  */
185 int SHA224Result(SHA224Context *context,
186     uint8_t Message_Digest[SHA224HashSize])
187 {
188   return SHA224_256ResultN(context, Message_Digest, SHA224HashSize);
189 }
190
191 /*
192  * SHA256Reset
193  *
194  * Description:
195  *   This function will initialize the SHA256Context in preparation
196  *   for computing a new SHA256 message digest.
197  *
198  * Parameters:
199  *   context: [in/out]
200  *     The context to reset.
201  *
202  * Returns:
203  *   sha Error Code.
204  */
205 int SHA256Reset(SHA256Context *context)
206 {
207   return SHA224_256Reset(context, SHA256_H0);
208 }
209
210 /*
211  * SHA256Input
212  *
213  * Description:
214  *   This function accepts an array of octets as the next portion
215  *   of the message.
216  *
217  * Parameters:
218  *   context: [in/out]
219  *     The SHA context to update.
220  *   message_array[ ]: [in]
221  *     An array of octets representing the next portion of
222  *     the message.
223  *   length: [in]
224  *     The length of the message in message_array.
225  *
226  * Returns:
227  *   sha Error Code.
228  */
229 int SHA256Input(SHA256Context *context, const uint8_t *message_array,
230     unsigned int length)
231 {
232   if (!context) return shaNull;
233   if (!length) return shaSuccess;
234   if (!message_array) return shaNull;
235   if (context->Computed) return context->Corrupted = shaStateError;
236   if (context->Corrupted) return context->Corrupted;
237
238   while (length--) {
239     context->Message_Block[context->Message_Block_Index++] =
240             *message_array;
241
242     if ((SHA224_256AddLength(context, 8) == shaSuccess) &&
243       (context->Message_Block_Index == SHA256_Message_Block_Size))
244       SHA224_256ProcessMessageBlock(context);
245
246     message_array++;
247   }
248
249   return context->Corrupted;
250
251 }
252
253 /*
254  * SHA256FinalBits
255  *
256  * Description:
257  *   This function will add in any final bits of the message.
258  *
259  * Parameters:
260  *   context: [in/out]
261  *     The SHA context to update.
262  *   message_bits: [in]
263  *     The final bits of the message, in the upper portion of the
264  *     byte.  (Use 0b###00000 instead of 0b00000### to input the
265  *     three bits ###.)
266  *   length: [in]
267  *     The number of bits in message_bits, between 1 and 7.
268  *
269  * Returns:
270  *   sha Error Code.
271  */
272 int SHA256FinalBits(SHA256Context *context,
273                     uint8_t message_bits, unsigned int length)
274 {
275   static uint8_t masks[8] = {
276       /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
277       /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
278       /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
279       /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
280   };
281   static uint8_t markbit[8] = {
282       /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
283       /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
284       /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
285       /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
286   };
287
288   if (!context) return shaNull;
289   if (!length) return shaSuccess;
290   if (context->Corrupted) return context->Corrupted;
291   if (context->Computed) return context->Corrupted = shaStateError;
292   if (length >= 8) return context->Corrupted = shaBadParam;
293
294   SHA224_256AddLength(context, length);
295   SHA224_256Finalize(context, (uint8_t)
296     ((message_bits & masks[length]) | markbit[length]));
297
298   return context->Corrupted;
299 }
300
301 /*
302  * SHA256Result
303  *
304  * Description:
305  *   This function will return the 256-bit message digest
306  *   into the Message_Digest array provided by the caller.
307  *   NOTE:
308  *    The first octet of hash is stored in the element with index 0,
309  *    the last octet of hash in the element with index 31.
310  *
311  * Parameters:
312  *   context: [in/out]
313  *     The context to use to calculate the SHA hash.
314  *   Message_Digest[ ]: [out]
315  *     Where the digest is returned.
316  *
317  * Returns:
318  *   sha Error Code.
319  */
320 int SHA256Result(SHA256Context *context,
321                  uint8_t Message_Digest[SHA256HashSize])
322 {
323   return SHA224_256ResultN(context, Message_Digest, SHA256HashSize);
324 }
325
326 /*
327  * SHA224_256Reset
328  *
329  * Description:
330  *   This helper function will initialize the SHA256Context in
331  *   preparation for computing a new SHA-224 or SHA-256 message digest.
332  *
333  * Parameters:
334  *   context: [in/out]
335  *     The context to reset.
336  *   H0[ ]: [in]
337  *     The initial hash value array to use.
338  *
339  * Returns:
340  *   sha Error Code.
341  */
342 static int SHA224_256Reset(SHA256Context *context, uint32_t *H0)
343 {
344   if (!context) return shaNull;
345
346   context->Length_High = context->Length_Low = 0;
347   context->Message_Block_Index  = 0;
348
349   context->Intermediate_Hash[0] = H0[0];
350   context->Intermediate_Hash[1] = H0[1];
351   context->Intermediate_Hash[2] = H0[2];
352   context->Intermediate_Hash[3] = H0[3];
353   context->Intermediate_Hash[4] = H0[4];
354   context->Intermediate_Hash[5] = H0[5];
355   context->Intermediate_Hash[6] = H0[6];
356   context->Intermediate_Hash[7] = H0[7];
357
358   context->Computed  = 0;
359   context->Corrupted = shaSuccess;
360
361   return shaSuccess;
362 }
363
364 /*
365  * SHA224_256ProcessMessageBlock
366  *
367  * Description:
368  *   This helper function will process the next 512 bits of the
369  *   message stored in the Message_Block array.
370  *
371  * Parameters:
372  *   context: [in/out]
373  *     The SHA context to update.
374  *
375  * Returns:
376  *   Nothing.
377  *
378  * Comments:
379  *   Many of the variable names in this code, especially the
380  *   single character names, were used because those were the
381  *   names used in the Secure Hash Standard.
382  */
383 static void SHA224_256ProcessMessageBlock(SHA256Context *context)
384 {
385   /* Constants defined in FIPS 180-3, section 4.2.2 */
386   static const uint32_t K[64] = {
387       0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
388       0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
389       0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
390       0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
391       0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
392       0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
393       0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
394       0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
395       0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
396       0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
397       0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
398       0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
399       0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
400   };
401   int        t, t4;                   /* Loop counter */
402   uint32_t   temp1, temp2;            /* Temporary word value */
403   uint32_t   W[64];                   /* Word sequence */
404   uint32_t   A, B, C, D, E, F, G, H;  /* Word buffers */
405
406   /*
407    * Initialize the first 16 words in the array W
408    */
409   for (t = t4 = 0; t < 16; t++, t4 += 4)
410     W[t] = (((uint32_t)context->Message_Block[t4]) << 24) |
411            (((uint32_t)context->Message_Block[t4 + 1]) << 16) |
412            (((uint32_t)context->Message_Block[t4 + 2]) << 8) |
413            (((uint32_t)context->Message_Block[t4 + 3]));
414
415   for (t = 16; t < 64; t++)
416     W[t] = SHA256_sigma1(W[t-2]) + W[t-7] +
417         SHA256_sigma0(W[t-15]) + W[t-16];
418
419   A = context->Intermediate_Hash[0];
420   B = context->Intermediate_Hash[1];
421   C = context->Intermediate_Hash[2];
422   D = context->Intermediate_Hash[3];
423   E = context->Intermediate_Hash[4];
424   F = context->Intermediate_Hash[5];
425   G = context->Intermediate_Hash[6];
426   H = context->Intermediate_Hash[7];
427
428   for (t = 0; t < 64; t++) {
429     temp1 = H + SHA256_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t];
430     temp2 = SHA256_SIGMA0(A) + SHA_Maj(A,B,C);
431     H = G;
432     G = F;
433     F = E;
434     E = D + temp1;
435     D = C;
436     C = B;
437     B = A;
438     A = temp1 + temp2;
439   }
440
441   context->Intermediate_Hash[0] += A;
442   context->Intermediate_Hash[1] += B;
443   context->Intermediate_Hash[2] += C;
444   context->Intermediate_Hash[3] += D;
445   context->Intermediate_Hash[4] += E;
446   context->Intermediate_Hash[5] += F;
447   context->Intermediate_Hash[6] += G;
448   context->Intermediate_Hash[7] += H;
449
450   context->Message_Block_Index = 0;
451 }
452
453 /*
454  * SHA224_256Finalize
455  *
456  * Description:
457  *   This helper function finishes off the digest calculations.
458  *
459  * Parameters:
460  *   context: [in/out]
461  *     The SHA context to update.
462  *   Pad_Byte: [in]
463  *     The last byte to add to the message block before the 0-padding
464  *     and length.  This will contain the last bits of the message
465  *     followed by another single bit.  If the message was an
466  *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
467  *
468  * Returns:
469  *   sha Error Code.
470  */
471 static void SHA224_256Finalize(SHA256Context *context,
472     uint8_t Pad_Byte)
473 {
474   int i;
475   SHA224_256PadMessage(context, Pad_Byte);
476   /* message may be sensitive, so clear it out */
477   for (i = 0; i < SHA256_Message_Block_Size; ++i)
478     context->Message_Block[i] = 0;
479   context->Length_High = 0;     /* and clear length */
480   context->Length_Low = 0;
481   context->Computed = 1;
482 }
483
484 /*
485  * SHA224_256PadMessage
486  *
487  * Description:
488  *   According to the standard, the message must be padded to the next
489  *   even multiple of 512 bits.  The first padding bit must be a '1'.
490  *   The last 64 bits represent the length of the original message.
491  *   All bits in between should be 0.  This helper function will pad
492  *   the message according to those rules by filling the
493  *   Message_Block array accordingly.  When it returns, it can be
494  *   assumed that the message digest has been computed.
495  *
496  * Parameters:
497  *   context: [in/out]
498  *     The context to pad.
499  *   Pad_Byte: [in]
500  *     The last byte to add to the message block before the 0-padding
501  *     and length.  This will contain the last bits of the message
502  *     followed by another single bit.  If the message was an
503  *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
504  *
505  * Returns:
506  *   Nothing.
507  */
508 static void SHA224_256PadMessage(SHA256Context *context,
509     uint8_t Pad_Byte)
510 {
511   /*
512    * Check to see if the current message block is too small to hold
513    * the initial padding bits and length.  If so, we will pad the
514    * block, process it, and then continue padding into a second
515    * block.
516    */
517   if (context->Message_Block_Index >= (SHA256_Message_Block_Size-8)) {
518     context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
519     while (context->Message_Block_Index < SHA256_Message_Block_Size)
520       context->Message_Block[context->Message_Block_Index++] = 0;
521     SHA224_256ProcessMessageBlock(context);
522   } else
523     context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
524
525   while (context->Message_Block_Index < (SHA256_Message_Block_Size-8))
526     context->Message_Block[context->Message_Block_Index++] = 0;
527
528   /*
529    * Store the message length as the last 8 octets
530    */
531   context->Message_Block[56] = (uint8_t)(context->Length_High >> 24);
532   context->Message_Block[57] = (uint8_t)(context->Length_High >> 16);
533   context->Message_Block[58] = (uint8_t)(context->Length_High >> 8);
534   context->Message_Block[59] = (uint8_t)(context->Length_High);
535   context->Message_Block[60] = (uint8_t)(context->Length_Low >> 24);
536   context->Message_Block[61] = (uint8_t)(context->Length_Low >> 16);
537   context->Message_Block[62] = (uint8_t)(context->Length_Low >> 8);
538   context->Message_Block[63] = (uint8_t)(context->Length_Low);
539
540   SHA224_256ProcessMessageBlock(context);
541 }
542
543 /*
544  * SHA224_256ResultN
545  *
546  * Description:
547  *   This helper function will return the 224-bit or 256-bit message
548  *   digest into the Message_Digest array provided by the caller.
549  *   NOTE:
550  *    The first octet of hash is stored in the element with index 0,
551  *    the last octet of hash in the element with index 27/31.
552  *
553  * Parameters:
554  *   context: [in/out]
555  *     The context to use to calculate the SHA hash.
556  *   Message_Digest[ ]: [out]
557  *     Where the digest is returned.
558  *   HashSize: [in]
559  *     The size of the hash, either 28 or 32.
560  *
561  * Returns:
562  *   sha Error Code.
563  */
564 static int SHA224_256ResultN(SHA256Context *context,
565     uint8_t Message_Digest[ ], int HashSize)
566 {
567   int i;
568
569   if (!context) return shaNull;
570   if (!Message_Digest) return shaNull;
571   if (context->Corrupted) return context->Corrupted;
572
573   if (!context->Computed)
574     SHA224_256Finalize(context, 0x80);
575
576   for (i = 0; i < HashSize; ++i)
577     Message_Digest[i] = (uint8_t)
578       (context->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) ));
579
580   return shaSuccess;
581 }