Xin Zhang / azure-iot-c-sdk-f767zi

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   samplemqtt

c-utility/src/sha224.c@0:f7f1f0d76dd6, 2018-08-23 (annotated)

Committer:
XinZhangMS
Date:
Thu Aug 23 06:52:14 2018 +0000
Revision:
0:f7f1f0d76dd6
azure-c-sdk for mbed os supporting NUCLEO_F767ZI

Who changed what in which revision?

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