BA / SerialCom

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.

Fork of OmniWheels by Gustav Atmel

mbed-os/features/mbedtls/src/sha256.c@1:9c5af431a1f1, 2018-05-01 (annotated)

Committer:
gustavatmel
Date:
Tue May 01 15:47:08 2018 +0000
Revision:
1:9c5af431a1f1
sdf

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gustavatmel 1:9c5af431a1f1 1 /*
gustavatmel 1:9c5af431a1f1 2 * FIPS-180-2 compliant SHA-256 implementation
gustavatmel 1:9c5af431a1f1 3 *
gustavatmel 1:9c5af431a1f1 4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
gustavatmel 1:9c5af431a1f1 5 * SPDX-License-Identifier: Apache-2.0
gustavatmel 1:9c5af431a1f1 6 *
gustavatmel 1:9c5af431a1f1 7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
gustavatmel 1:9c5af431a1f1 8 * not use this file except in compliance with the License.
gustavatmel 1:9c5af431a1f1 9 * You may obtain a copy of the License at
gustavatmel 1:9c5af431a1f1 10 *
gustavatmel 1:9c5af431a1f1 11 * http://www.apache.org/licenses/LICENSE-2.0
gustavatmel 1:9c5af431a1f1 12 *
gustavatmel 1:9c5af431a1f1 13 * Unless required by applicable law or agreed to in writing, software
gustavatmel 1:9c5af431a1f1 14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
gustavatmel 1:9c5af431a1f1 15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
gustavatmel 1:9c5af431a1f1 16 * See the License for the specific language governing permissions and
gustavatmel 1:9c5af431a1f1 17 * limitations under the License.
gustavatmel 1:9c5af431a1f1 18 *
gustavatmel 1:9c5af431a1f1 19 * This file is part of mbed TLS (https://tls.mbed.org)
gustavatmel 1:9c5af431a1f1 20 */
gustavatmel 1:9c5af431a1f1 21 /*
gustavatmel 1:9c5af431a1f1 22 * The SHA-256 Secure Hash Standard was published by NIST in 2002.
gustavatmel 1:9c5af431a1f1 23 *
gustavatmel 1:9c5af431a1f1 24 * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
gustavatmel 1:9c5af431a1f1 25 */
gustavatmel 1:9c5af431a1f1 26
gustavatmel 1:9c5af431a1f1 27 #if !defined(MBEDTLS_CONFIG_FILE)
gustavatmel 1:9c5af431a1f1 28 #include "mbedtls/config.h"
gustavatmel 1:9c5af431a1f1 29 #else
gustavatmel 1:9c5af431a1f1 30 #include MBEDTLS_CONFIG_FILE
gustavatmel 1:9c5af431a1f1 31 #endif
gustavatmel 1:9c5af431a1f1 32
gustavatmel 1:9c5af431a1f1 33 #if defined(MBEDTLS_SHA256_C)
gustavatmel 1:9c5af431a1f1 34
gustavatmel 1:9c5af431a1f1 35 #include "mbedtls/sha256.h"
gustavatmel 1:9c5af431a1f1 36
gustavatmel 1:9c5af431a1f1 37 #include <string.h>
gustavatmel 1:9c5af431a1f1 38
gustavatmel 1:9c5af431a1f1 39 #if defined(MBEDTLS_SELF_TEST)
gustavatmel 1:9c5af431a1f1 40 #if defined(MBEDTLS_PLATFORM_C)
gustavatmel 1:9c5af431a1f1 41 #include "mbedtls/platform.h"
gustavatmel 1:9c5af431a1f1 42 #else
gustavatmel 1:9c5af431a1f1 43 #include <stdio.h>
gustavatmel 1:9c5af431a1f1 44 #include <stdlib.h>
gustavatmel 1:9c5af431a1f1 45 #define mbedtls_printf printf
gustavatmel 1:9c5af431a1f1 46 #define mbedtls_calloc calloc
gustavatmel 1:9c5af431a1f1 47 #define mbedtls_free free
gustavatmel 1:9c5af431a1f1 48 #endif /* MBEDTLS_PLATFORM_C */
gustavatmel 1:9c5af431a1f1 49 #endif /* MBEDTLS_SELF_TEST */
gustavatmel 1:9c5af431a1f1 50
gustavatmel 1:9c5af431a1f1 51 #if !defined(MBEDTLS_SHA256_ALT)
gustavatmel 1:9c5af431a1f1 52
gustavatmel 1:9c5af431a1f1 53 /* Implementation that should never be optimized out by the compiler */
gustavatmel 1:9c5af431a1f1 54 static void mbedtls_zeroize( void *v, size_t n ) {
gustavatmel 1:9c5af431a1f1 55 volatile unsigned char *p = v; while( n-- ) *p++ = 0;
gustavatmel 1:9c5af431a1f1 56 }
gustavatmel 1:9c5af431a1f1 57
gustavatmel 1:9c5af431a1f1 58 /*
gustavatmel 1:9c5af431a1f1 59 * 32-bit integer manipulation macros (big endian)
gustavatmel 1:9c5af431a1f1 60 */
gustavatmel 1:9c5af431a1f1 61 #ifndef GET_UINT32_BE
gustavatmel 1:9c5af431a1f1 62 #define GET_UINT32_BE(n,b,i) \
gustavatmel 1:9c5af431a1f1 63 do { \
gustavatmel 1:9c5af431a1f1 64 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
gustavatmel 1:9c5af431a1f1 65 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
gustavatmel 1:9c5af431a1f1 66 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
gustavatmel 1:9c5af431a1f1 67 | ( (uint32_t) (b)[(i) + 3] ); \
gustavatmel 1:9c5af431a1f1 68 } while( 0 )
gustavatmel 1:9c5af431a1f1 69 #endif
gustavatmel 1:9c5af431a1f1 70
gustavatmel 1:9c5af431a1f1 71 #ifndef PUT_UINT32_BE
gustavatmel 1:9c5af431a1f1 72 #define PUT_UINT32_BE(n,b,i) \
gustavatmel 1:9c5af431a1f1 73 do { \
gustavatmel 1:9c5af431a1f1 74 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
gustavatmel 1:9c5af431a1f1 75 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
gustavatmel 1:9c5af431a1f1 76 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
gustavatmel 1:9c5af431a1f1 77 (b)[(i) + 3] = (unsigned char) ( (n) ); \
gustavatmel 1:9c5af431a1f1 78 } while( 0 )
gustavatmel 1:9c5af431a1f1 79 #endif
gustavatmel 1:9c5af431a1f1 80
gustavatmel 1:9c5af431a1f1 81 void mbedtls_sha256_init( mbedtls_sha256_context *ctx )
gustavatmel 1:9c5af431a1f1 82 {
gustavatmel 1:9c5af431a1f1 83 memset( ctx, 0, sizeof( mbedtls_sha256_context ) );
gustavatmel 1:9c5af431a1f1 84 }
gustavatmel 1:9c5af431a1f1 85
gustavatmel 1:9c5af431a1f1 86 void mbedtls_sha256_free( mbedtls_sha256_context *ctx )
gustavatmel 1:9c5af431a1f1 87 {
gustavatmel 1:9c5af431a1f1 88 if( ctx == NULL )
gustavatmel 1:9c5af431a1f1 89 return;
gustavatmel 1:9c5af431a1f1 90
gustavatmel 1:9c5af431a1f1 91 mbedtls_zeroize( ctx, sizeof( mbedtls_sha256_context ) );
gustavatmel 1:9c5af431a1f1 92 }
gustavatmel 1:9c5af431a1f1 93
gustavatmel 1:9c5af431a1f1 94 void mbedtls_sha256_clone( mbedtls_sha256_context *dst,
gustavatmel 1:9c5af431a1f1 95 const mbedtls_sha256_context *src )
gustavatmel 1:9c5af431a1f1 96 {
gustavatmel 1:9c5af431a1f1 97 *dst = *src;
gustavatmel 1:9c5af431a1f1 98 }
gustavatmel 1:9c5af431a1f1 99
gustavatmel 1:9c5af431a1f1 100 /*
gustavatmel 1:9c5af431a1f1 101 * SHA-256 context setup
gustavatmel 1:9c5af431a1f1 102 */
gustavatmel 1:9c5af431a1f1 103 int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 )
gustavatmel 1:9c5af431a1f1 104 {
gustavatmel 1:9c5af431a1f1 105 ctx->total[0] = 0;
gustavatmel 1:9c5af431a1f1 106 ctx->total[1] = 0;
gustavatmel 1:9c5af431a1f1 107
gustavatmel 1:9c5af431a1f1 108 if( is224 == 0 )
gustavatmel 1:9c5af431a1f1 109 {
gustavatmel 1:9c5af431a1f1 110 /* SHA-256 */
gustavatmel 1:9c5af431a1f1 111 ctx->state[0] = 0x6A09E667;
gustavatmel 1:9c5af431a1f1 112 ctx->state[1] = 0xBB67AE85;
gustavatmel 1:9c5af431a1f1 113 ctx->state[2] = 0x3C6EF372;
gustavatmel 1:9c5af431a1f1 114 ctx->state[3] = 0xA54FF53A;
gustavatmel 1:9c5af431a1f1 115 ctx->state[4] = 0x510E527F;
gustavatmel 1:9c5af431a1f1 116 ctx->state[5] = 0x9B05688C;
gustavatmel 1:9c5af431a1f1 117 ctx->state[6] = 0x1F83D9AB;
gustavatmel 1:9c5af431a1f1 118 ctx->state[7] = 0x5BE0CD19;
gustavatmel 1:9c5af431a1f1 119 }
gustavatmel 1:9c5af431a1f1 120 else
gustavatmel 1:9c5af431a1f1 121 {
gustavatmel 1:9c5af431a1f1 122 /* SHA-224 */
gustavatmel 1:9c5af431a1f1 123 ctx->state[0] = 0xC1059ED8;
gustavatmel 1:9c5af431a1f1 124 ctx->state[1] = 0x367CD507;
gustavatmel 1:9c5af431a1f1 125 ctx->state[2] = 0x3070DD17;
gustavatmel 1:9c5af431a1f1 126 ctx->state[3] = 0xF70E5939;
gustavatmel 1:9c5af431a1f1 127 ctx->state[4] = 0xFFC00B31;
gustavatmel 1:9c5af431a1f1 128 ctx->state[5] = 0x68581511;
gustavatmel 1:9c5af431a1f1 129 ctx->state[6] = 0x64F98FA7;
gustavatmel 1:9c5af431a1f1 130 ctx->state[7] = 0xBEFA4FA4;
gustavatmel 1:9c5af431a1f1 131 }
gustavatmel 1:9c5af431a1f1 132
gustavatmel 1:9c5af431a1f1 133 ctx->is224 = is224;
gustavatmel 1:9c5af431a1f1 134
gustavatmel 1:9c5af431a1f1 135 return( 0 );
gustavatmel 1:9c5af431a1f1 136 }
gustavatmel 1:9c5af431a1f1 137
gustavatmel 1:9c5af431a1f1 138 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
gustavatmel 1:9c5af431a1f1 139 void mbedtls_sha256_starts( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 140 int is224 )
gustavatmel 1:9c5af431a1f1 141 {
gustavatmel 1:9c5af431a1f1 142 mbedtls_sha256_starts_ret( ctx, is224 );
gustavatmel 1:9c5af431a1f1 143 }
gustavatmel 1:9c5af431a1f1 144 #endif
gustavatmel 1:9c5af431a1f1 145
gustavatmel 1:9c5af431a1f1 146 #if !defined(MBEDTLS_SHA256_PROCESS_ALT)
gustavatmel 1:9c5af431a1f1 147 static const uint32_t K[] =
gustavatmel 1:9c5af431a1f1 148 {
gustavatmel 1:9c5af431a1f1 149 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
gustavatmel 1:9c5af431a1f1 150 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
gustavatmel 1:9c5af431a1f1 151 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
gustavatmel 1:9c5af431a1f1 152 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
gustavatmel 1:9c5af431a1f1 153 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
gustavatmel 1:9c5af431a1f1 154 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
gustavatmel 1:9c5af431a1f1 155 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
gustavatmel 1:9c5af431a1f1 156 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
gustavatmel 1:9c5af431a1f1 157 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
gustavatmel 1:9c5af431a1f1 158 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
gustavatmel 1:9c5af431a1f1 159 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
gustavatmel 1:9c5af431a1f1 160 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
gustavatmel 1:9c5af431a1f1 161 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
gustavatmel 1:9c5af431a1f1 162 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
gustavatmel 1:9c5af431a1f1 163 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
gustavatmel 1:9c5af431a1f1 164 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
gustavatmel 1:9c5af431a1f1 165 };
gustavatmel 1:9c5af431a1f1 166
gustavatmel 1:9c5af431a1f1 167 #define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
gustavatmel 1:9c5af431a1f1 168 #define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
gustavatmel 1:9c5af431a1f1 169
gustavatmel 1:9c5af431a1f1 170 #define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
gustavatmel 1:9c5af431a1f1 171 #define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
gustavatmel 1:9c5af431a1f1 172
gustavatmel 1:9c5af431a1f1 173 #define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
gustavatmel 1:9c5af431a1f1 174 #define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
gustavatmel 1:9c5af431a1f1 175
gustavatmel 1:9c5af431a1f1 176 #define F0(x,y,z) ((x & y) | (z & (x | y)))
gustavatmel 1:9c5af431a1f1 177 #define F1(x,y,z) (z ^ (x & (y ^ z)))
gustavatmel 1:9c5af431a1f1 178
gustavatmel 1:9c5af431a1f1 179 #define R(t) \
gustavatmel 1:9c5af431a1f1 180 ( \
gustavatmel 1:9c5af431a1f1 181 W[t] = S1(W[t - 2]) + W[t - 7] + \
gustavatmel 1:9c5af431a1f1 182 S0(W[t - 15]) + W[t - 16] \
gustavatmel 1:9c5af431a1f1 183 )
gustavatmel 1:9c5af431a1f1 184
gustavatmel 1:9c5af431a1f1 185 #define P(a,b,c,d,e,f,g,h,x,K) \
gustavatmel 1:9c5af431a1f1 186 { \
gustavatmel 1:9c5af431a1f1 187 temp1 = h + S3(e) + F1(e,f,g) + K + x; \
gustavatmel 1:9c5af431a1f1 188 temp2 = S2(a) + F0(a,b,c); \
gustavatmel 1:9c5af431a1f1 189 d += temp1; h = temp1 + temp2; \
gustavatmel 1:9c5af431a1f1 190 }
gustavatmel 1:9c5af431a1f1 191
gustavatmel 1:9c5af431a1f1 192 int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 193 const unsigned char data[64] )
gustavatmel 1:9c5af431a1f1 194 {
gustavatmel 1:9c5af431a1f1 195 uint32_t temp1, temp2, W[64];
gustavatmel 1:9c5af431a1f1 196 uint32_t A[8];
gustavatmel 1:9c5af431a1f1 197 unsigned int i;
gustavatmel 1:9c5af431a1f1 198
gustavatmel 1:9c5af431a1f1 199 for( i = 0; i < 8; i++ )
gustavatmel 1:9c5af431a1f1 200 A[i] = ctx->state[i];
gustavatmel 1:9c5af431a1f1 201
gustavatmel 1:9c5af431a1f1 202 #if defined(MBEDTLS_SHA256_SMALLER)
gustavatmel 1:9c5af431a1f1 203 for( i = 0; i < 64; i++ )
gustavatmel 1:9c5af431a1f1 204 {
gustavatmel 1:9c5af431a1f1 205 if( i < 16 )
gustavatmel 1:9c5af431a1f1 206 GET_UINT32_BE( W[i], data, 4 * i );
gustavatmel 1:9c5af431a1f1 207 else
gustavatmel 1:9c5af431a1f1 208 R( i );
gustavatmel 1:9c5af431a1f1 209
gustavatmel 1:9c5af431a1f1 210 P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] );
gustavatmel 1:9c5af431a1f1 211
gustavatmel 1:9c5af431a1f1 212 temp1 = A[7]; A[7] = A[6]; A[6] = A[5]; A[5] = A[4]; A[4] = A[3];
gustavatmel 1:9c5af431a1f1 213 A[3] = A[2]; A[2] = A[1]; A[1] = A[0]; A[0] = temp1;
gustavatmel 1:9c5af431a1f1 214 }
gustavatmel 1:9c5af431a1f1 215 #else /* MBEDTLS_SHA256_SMALLER */
gustavatmel 1:9c5af431a1f1 216 for( i = 0; i < 16; i++ )
gustavatmel 1:9c5af431a1f1 217 GET_UINT32_BE( W[i], data, 4 * i );
gustavatmel 1:9c5af431a1f1 218
gustavatmel 1:9c5af431a1f1 219 for( i = 0; i < 16; i += 8 )
gustavatmel 1:9c5af431a1f1 220 {
gustavatmel 1:9c5af431a1f1 221 P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i+0], K[i+0] );
gustavatmel 1:9c5af431a1f1 222 P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i+1], K[i+1] );
gustavatmel 1:9c5af431a1f1 223 P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i+2], K[i+2] );
gustavatmel 1:9c5af431a1f1 224 P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i+3], K[i+3] );
gustavatmel 1:9c5af431a1f1 225 P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i+4], K[i+4] );
gustavatmel 1:9c5af431a1f1 226 P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i+5], K[i+5] );
gustavatmel 1:9c5af431a1f1 227 P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i+6], K[i+6] );
gustavatmel 1:9c5af431a1f1 228 P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i+7], K[i+7] );
gustavatmel 1:9c5af431a1f1 229 }
gustavatmel 1:9c5af431a1f1 230
gustavatmel 1:9c5af431a1f1 231 for( i = 16; i < 64; i += 8 )
gustavatmel 1:9c5af431a1f1 232 {
gustavatmel 1:9c5af431a1f1 233 P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], R(i+0), K[i+0] );
gustavatmel 1:9c5af431a1f1 234 P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], R(i+1), K[i+1] );
gustavatmel 1:9c5af431a1f1 235 P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], R(i+2), K[i+2] );
gustavatmel 1:9c5af431a1f1 236 P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], R(i+3), K[i+3] );
gustavatmel 1:9c5af431a1f1 237 P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], R(i+4), K[i+4] );
gustavatmel 1:9c5af431a1f1 238 P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], R(i+5), K[i+5] );
gustavatmel 1:9c5af431a1f1 239 P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], R(i+6), K[i+6] );
gustavatmel 1:9c5af431a1f1 240 P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], R(i+7), K[i+7] );
gustavatmel 1:9c5af431a1f1 241 }
gustavatmel 1:9c5af431a1f1 242 #endif /* MBEDTLS_SHA256_SMALLER */
gustavatmel 1:9c5af431a1f1 243
gustavatmel 1:9c5af431a1f1 244 for( i = 0; i < 8; i++ )
gustavatmel 1:9c5af431a1f1 245 ctx->state[i] += A[i];
gustavatmel 1:9c5af431a1f1 246
gustavatmel 1:9c5af431a1f1 247 return( 0 );
gustavatmel 1:9c5af431a1f1 248 }
gustavatmel 1:9c5af431a1f1 249
gustavatmel 1:9c5af431a1f1 250 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
gustavatmel 1:9c5af431a1f1 251 void mbedtls_sha256_process( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 252 const unsigned char data[64] )
gustavatmel 1:9c5af431a1f1 253 {
gustavatmel 1:9c5af431a1f1 254 mbedtls_internal_sha256_process( ctx, data );
gustavatmel 1:9c5af431a1f1 255 }
gustavatmel 1:9c5af431a1f1 256 #endif
gustavatmel 1:9c5af431a1f1 257 #endif /* !MBEDTLS_SHA256_PROCESS_ALT */
gustavatmel 1:9c5af431a1f1 258
gustavatmel 1:9c5af431a1f1 259 /*
gustavatmel 1:9c5af431a1f1 260 * SHA-256 process buffer
gustavatmel 1:9c5af431a1f1 261 */
gustavatmel 1:9c5af431a1f1 262 int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 263 const unsigned char *input,
gustavatmel 1:9c5af431a1f1 264 size_t ilen )
gustavatmel 1:9c5af431a1f1 265 {
gustavatmel 1:9c5af431a1f1 266 int ret;
gustavatmel 1:9c5af431a1f1 267 size_t fill;
gustavatmel 1:9c5af431a1f1 268 uint32_t left;
gustavatmel 1:9c5af431a1f1 269
gustavatmel 1:9c5af431a1f1 270 if( ilen == 0 )
gustavatmel 1:9c5af431a1f1 271 return( 0 );
gustavatmel 1:9c5af431a1f1 272
gustavatmel 1:9c5af431a1f1 273 left = ctx->total[0] & 0x3F;
gustavatmel 1:9c5af431a1f1 274 fill = 64 - left;
gustavatmel 1:9c5af431a1f1 275
gustavatmel 1:9c5af431a1f1 276 ctx->total[0] += (uint32_t) ilen;
gustavatmel 1:9c5af431a1f1 277 ctx->total[0] &= 0xFFFFFFFF;
gustavatmel 1:9c5af431a1f1 278
gustavatmel 1:9c5af431a1f1 279 if( ctx->total[0] < (uint32_t) ilen )
gustavatmel 1:9c5af431a1f1 280 ctx->total[1]++;
gustavatmel 1:9c5af431a1f1 281
gustavatmel 1:9c5af431a1f1 282 if( left && ilen >= fill )
gustavatmel 1:9c5af431a1f1 283 {
gustavatmel 1:9c5af431a1f1 284 memcpy( (void *) (ctx->buffer + left), input, fill );
gustavatmel 1:9c5af431a1f1 285
gustavatmel 1:9c5af431a1f1 286 if( ( ret = mbedtls_internal_sha256_process( ctx, ctx->buffer ) ) != 0 )
gustavatmel 1:9c5af431a1f1 287 return( ret );
gustavatmel 1:9c5af431a1f1 288
gustavatmel 1:9c5af431a1f1 289 input += fill;
gustavatmel 1:9c5af431a1f1 290 ilen -= fill;
gustavatmel 1:9c5af431a1f1 291 left = 0;
gustavatmel 1:9c5af431a1f1 292 }
gustavatmel 1:9c5af431a1f1 293
gustavatmel 1:9c5af431a1f1 294 while( ilen >= 64 )
gustavatmel 1:9c5af431a1f1 295 {
gustavatmel 1:9c5af431a1f1 296 if( ( ret = mbedtls_internal_sha256_process( ctx, input ) ) != 0 )
gustavatmel 1:9c5af431a1f1 297 return( ret );
gustavatmel 1:9c5af431a1f1 298
gustavatmel 1:9c5af431a1f1 299 input += 64;
gustavatmel 1:9c5af431a1f1 300 ilen -= 64;
gustavatmel 1:9c5af431a1f1 301 }
gustavatmel 1:9c5af431a1f1 302
gustavatmel 1:9c5af431a1f1 303 if( ilen > 0 )
gustavatmel 1:9c5af431a1f1 304 memcpy( (void *) (ctx->buffer + left), input, ilen );
gustavatmel 1:9c5af431a1f1 305
gustavatmel 1:9c5af431a1f1 306 return( 0 );
gustavatmel 1:9c5af431a1f1 307 }
gustavatmel 1:9c5af431a1f1 308
gustavatmel 1:9c5af431a1f1 309 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
gustavatmel 1:9c5af431a1f1 310 void mbedtls_sha256_update( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 311 const unsigned char *input,
gustavatmel 1:9c5af431a1f1 312 size_t ilen )
gustavatmel 1:9c5af431a1f1 313 {
gustavatmel 1:9c5af431a1f1 314 mbedtls_sha256_update_ret( ctx, input, ilen );
gustavatmel 1:9c5af431a1f1 315 }
gustavatmel 1:9c5af431a1f1 316 #endif
gustavatmel 1:9c5af431a1f1 317
gustavatmel 1:9c5af431a1f1 318 static const unsigned char sha256_padding[64] =
gustavatmel 1:9c5af431a1f1 319 {
gustavatmel 1:9c5af431a1f1 320 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
gustavatmel 1:9c5af431a1f1 321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
gustavatmel 1:9c5af431a1f1 322 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
gustavatmel 1:9c5af431a1f1 323 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
gustavatmel 1:9c5af431a1f1 324 };
gustavatmel 1:9c5af431a1f1 325
gustavatmel 1:9c5af431a1f1 326 /*
gustavatmel 1:9c5af431a1f1 327 * SHA-256 final digest
gustavatmel 1:9c5af431a1f1 328 */
gustavatmel 1:9c5af431a1f1 329 int mbedtls_sha256_finish_ret( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 330 unsigned char output[32] )
gustavatmel 1:9c5af431a1f1 331 {
gustavatmel 1:9c5af431a1f1 332 int ret;
gustavatmel 1:9c5af431a1f1 333 uint32_t last, padn;
gustavatmel 1:9c5af431a1f1 334 uint32_t high, low;
gustavatmel 1:9c5af431a1f1 335 unsigned char msglen[8];
gustavatmel 1:9c5af431a1f1 336
gustavatmel 1:9c5af431a1f1 337 high = ( ctx->total[0] >> 29 )
gustavatmel 1:9c5af431a1f1 338 | ( ctx->total[1] << 3 );
gustavatmel 1:9c5af431a1f1 339 low = ( ctx->total[0] << 3 );
gustavatmel 1:9c5af431a1f1 340
gustavatmel 1:9c5af431a1f1 341 PUT_UINT32_BE( high, msglen, 0 );
gustavatmel 1:9c5af431a1f1 342 PUT_UINT32_BE( low, msglen, 4 );
gustavatmel 1:9c5af431a1f1 343
gustavatmel 1:9c5af431a1f1 344 last = ctx->total[0] & 0x3F;
gustavatmel 1:9c5af431a1f1 345 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
gustavatmel 1:9c5af431a1f1 346
gustavatmel 1:9c5af431a1f1 347 if( ( ret = mbedtls_sha256_update_ret( ctx, sha256_padding, padn ) ) != 0 )
gustavatmel 1:9c5af431a1f1 348 return( ret );
gustavatmel 1:9c5af431a1f1 349
gustavatmel 1:9c5af431a1f1 350 if( ( ret = mbedtls_sha256_update_ret( ctx, msglen, 8 ) ) != 0 )
gustavatmel 1:9c5af431a1f1 351 return( ret );
gustavatmel 1:9c5af431a1f1 352
gustavatmel 1:9c5af431a1f1 353 PUT_UINT32_BE( ctx->state[0], output, 0 );
gustavatmel 1:9c5af431a1f1 354 PUT_UINT32_BE( ctx->state[1], output, 4 );
gustavatmel 1:9c5af431a1f1 355 PUT_UINT32_BE( ctx->state[2], output, 8 );
gustavatmel 1:9c5af431a1f1 356 PUT_UINT32_BE( ctx->state[3], output, 12 );
gustavatmel 1:9c5af431a1f1 357 PUT_UINT32_BE( ctx->state[4], output, 16 );
gustavatmel 1:9c5af431a1f1 358 PUT_UINT32_BE( ctx->state[5], output, 20 );
gustavatmel 1:9c5af431a1f1 359 PUT_UINT32_BE( ctx->state[6], output, 24 );
gustavatmel 1:9c5af431a1f1 360
gustavatmel 1:9c5af431a1f1 361 if( ctx->is224 == 0 )
gustavatmel 1:9c5af431a1f1 362 PUT_UINT32_BE( ctx->state[7], output, 28 );
gustavatmel 1:9c5af431a1f1 363
gustavatmel 1:9c5af431a1f1 364 return( 0 );
gustavatmel 1:9c5af431a1f1 365 }
gustavatmel 1:9c5af431a1f1 366
gustavatmel 1:9c5af431a1f1 367 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
gustavatmel 1:9c5af431a1f1 368 void mbedtls_sha256_finish( mbedtls_sha256_context *ctx,
gustavatmel 1:9c5af431a1f1 369 unsigned char output[32] )
gustavatmel 1:9c5af431a1f1 370 {
gustavatmel 1:9c5af431a1f1 371 mbedtls_sha256_finish_ret( ctx, output );
gustavatmel 1:9c5af431a1f1 372 }
gustavatmel 1:9c5af431a1f1 373 #endif
gustavatmel 1:9c5af431a1f1 374
gustavatmel 1:9c5af431a1f1 375 #endif /* !MBEDTLS_SHA256_ALT */
gustavatmel 1:9c5af431a1f1 376
gustavatmel 1:9c5af431a1f1 377 /*
gustavatmel 1:9c5af431a1f1 378 * output = SHA-256( input buffer )
gustavatmel 1:9c5af431a1f1 379 */
gustavatmel 1:9c5af431a1f1 380 int mbedtls_sha256_ret( const unsigned char *input,
gustavatmel 1:9c5af431a1f1 381 size_t ilen,
gustavatmel 1:9c5af431a1f1 382 unsigned char output[32],
gustavatmel 1:9c5af431a1f1 383 int is224 )
gustavatmel 1:9c5af431a1f1 384 {
gustavatmel 1:9c5af431a1f1 385 int ret;
gustavatmel 1:9c5af431a1f1 386 mbedtls_sha256_context ctx;
gustavatmel 1:9c5af431a1f1 387
gustavatmel 1:9c5af431a1f1 388 mbedtls_sha256_init( &ctx );
gustavatmel 1:9c5af431a1f1 389
gustavatmel 1:9c5af431a1f1 390 if( ( ret = mbedtls_sha256_starts_ret( &ctx, is224 ) ) != 0 )
gustavatmel 1:9c5af431a1f1 391 goto exit;
gustavatmel 1:9c5af431a1f1 392
gustavatmel 1:9c5af431a1f1 393 if( ( ret = mbedtls_sha256_update_ret( &ctx, input, ilen ) ) != 0 )
gustavatmel 1:9c5af431a1f1 394 goto exit;
gustavatmel 1:9c5af431a1f1 395
gustavatmel 1:9c5af431a1f1 396 if( ( ret = mbedtls_sha256_finish_ret( &ctx, output ) ) != 0 )
gustavatmel 1:9c5af431a1f1 397 goto exit;
gustavatmel 1:9c5af431a1f1 398
gustavatmel 1:9c5af431a1f1 399 exit:
gustavatmel 1:9c5af431a1f1 400 mbedtls_sha256_free( &ctx );
gustavatmel 1:9c5af431a1f1 401
gustavatmel 1:9c5af431a1f1 402 return( ret );
gustavatmel 1:9c5af431a1f1 403 }
gustavatmel 1:9c5af431a1f1 404
gustavatmel 1:9c5af431a1f1 405 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
gustavatmel 1:9c5af431a1f1 406 void mbedtls_sha256( const unsigned char *input,
gustavatmel 1:9c5af431a1f1 407 size_t ilen,
gustavatmel 1:9c5af431a1f1 408 unsigned char output[32],
gustavatmel 1:9c5af431a1f1 409 int is224 )
gustavatmel 1:9c5af431a1f1 410 {
gustavatmel 1:9c5af431a1f1 411 mbedtls_sha256_ret( input, ilen, output, is224 );
gustavatmel 1:9c5af431a1f1 412 }
gustavatmel 1:9c5af431a1f1 413 #endif
gustavatmel 1:9c5af431a1f1 414
gustavatmel 1:9c5af431a1f1 415 #if defined(MBEDTLS_SELF_TEST)
gustavatmel 1:9c5af431a1f1 416 /*
gustavatmel 1:9c5af431a1f1 417 * FIPS-180-2 test vectors
gustavatmel 1:9c5af431a1f1 418 */
gustavatmel 1:9c5af431a1f1 419 static const unsigned char sha256_test_buf[3][57] =
gustavatmel 1:9c5af431a1f1 420 {
gustavatmel 1:9c5af431a1f1 421 { "abc" },
gustavatmel 1:9c5af431a1f1 422 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
gustavatmel 1:9c5af431a1f1 423 { "" }
gustavatmel 1:9c5af431a1f1 424 };
gustavatmel 1:9c5af431a1f1 425
gustavatmel 1:9c5af431a1f1 426 static const size_t sha256_test_buflen[3] =
gustavatmel 1:9c5af431a1f1 427 {
gustavatmel 1:9c5af431a1f1 428 3, 56, 1000
gustavatmel 1:9c5af431a1f1 429 };
gustavatmel 1:9c5af431a1f1 430
gustavatmel 1:9c5af431a1f1 431 static const unsigned char sha256_test_sum[6][32] =
gustavatmel 1:9c5af431a1f1 432 {
gustavatmel 1:9c5af431a1f1 433 /*
gustavatmel 1:9c5af431a1f1 434 * SHA-224 test vectors
gustavatmel 1:9c5af431a1f1 435 */
gustavatmel 1:9c5af431a1f1 436 { 0x23, 0x09, 0x7D, 0x22, 0x34, 0x05, 0xD8, 0x22,
gustavatmel 1:9c5af431a1f1 437 0x86, 0x42, 0xA4, 0x77, 0xBD, 0xA2, 0x55, 0xB3,
gustavatmel 1:9c5af431a1f1 438 0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0, 0xB3, 0xF7,
gustavatmel 1:9c5af431a1f1 439 0xE3, 0x6C, 0x9D, 0xA7 },
gustavatmel 1:9c5af431a1f1 440 { 0x75, 0x38, 0x8B, 0x16, 0x51, 0x27, 0x76, 0xCC,
gustavatmel 1:9c5af431a1f1 441 0x5D, 0xBA, 0x5D, 0xA1, 0xFD, 0x89, 0x01, 0x50,
gustavatmel 1:9c5af431a1f1 442 0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5, 0x8B, 0x19,
gustavatmel 1:9c5af431a1f1 443 0x52, 0x52, 0x25, 0x25 },
gustavatmel 1:9c5af431a1f1 444 { 0x20, 0x79, 0x46, 0x55, 0x98, 0x0C, 0x91, 0xD8,
gustavatmel 1:9c5af431a1f1 445 0xBB, 0xB4, 0xC1, 0xEA, 0x97, 0x61, 0x8A, 0x4B,
gustavatmel 1:9c5af431a1f1 446 0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48, 0xB2, 0xEE,
gustavatmel 1:9c5af431a1f1 447 0x4E, 0xE7, 0xAD, 0x67 },
gustavatmel 1:9c5af431a1f1 448
gustavatmel 1:9c5af431a1f1 449 /*
gustavatmel 1:9c5af431a1f1 450 * SHA-256 test vectors
gustavatmel 1:9c5af431a1f1 451 */
gustavatmel 1:9c5af431a1f1 452 { 0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA,
gustavatmel 1:9c5af431a1f1 453 0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23,
gustavatmel 1:9c5af431a1f1 454 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C,
gustavatmel 1:9c5af431a1f1 455 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD },
gustavatmel 1:9c5af431a1f1 456 { 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
gustavatmel 1:9c5af431a1f1 457 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
gustavatmel 1:9c5af431a1f1 458 0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
gustavatmel 1:9c5af431a1f1 459 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1 },
gustavatmel 1:9c5af431a1f1 460 { 0xCD, 0xC7, 0x6E, 0x5C, 0x99, 0x14, 0xFB, 0x92,
gustavatmel 1:9c5af431a1f1 461 0x81, 0xA1, 0xC7, 0xE2, 0x84, 0xD7, 0x3E, 0x67,
gustavatmel 1:9c5af431a1f1 462 0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97, 0x20, 0x0E,
gustavatmel 1:9c5af431a1f1 463 0x04, 0x6D, 0x39, 0xCC, 0xC7, 0x11, 0x2C, 0xD0 }
gustavatmel 1:9c5af431a1f1 464 };
gustavatmel 1:9c5af431a1f1 465
gustavatmel 1:9c5af431a1f1 466 /*
gustavatmel 1:9c5af431a1f1 467 * Checkup routine
gustavatmel 1:9c5af431a1f1 468 */
gustavatmel 1:9c5af431a1f1 469 int mbedtls_sha256_self_test( int verbose )
gustavatmel 1:9c5af431a1f1 470 {
gustavatmel 1:9c5af431a1f1 471 int i, j, k, buflen, ret = 0;
gustavatmel 1:9c5af431a1f1 472 unsigned char *buf;
gustavatmel 1:9c5af431a1f1 473 unsigned char sha256sum[32];
gustavatmel 1:9c5af431a1f1 474 mbedtls_sha256_context ctx;
gustavatmel 1:9c5af431a1f1 475
gustavatmel 1:9c5af431a1f1 476 buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
gustavatmel 1:9c5af431a1f1 477 if( NULL == buf )
gustavatmel 1:9c5af431a1f1 478 {
gustavatmel 1:9c5af431a1f1 479 if( verbose != 0 )
gustavatmel 1:9c5af431a1f1 480 mbedtls_printf( "Buffer allocation failed\n" );
gustavatmel 1:9c5af431a1f1 481
gustavatmel 1:9c5af431a1f1 482 return( 1 );
gustavatmel 1:9c5af431a1f1 483 }
gustavatmel 1:9c5af431a1f1 484
gustavatmel 1:9c5af431a1f1 485 mbedtls_sha256_init( &ctx );
gustavatmel 1:9c5af431a1f1 486
gustavatmel 1:9c5af431a1f1 487 for( i = 0; i < 6; i++ )
gustavatmel 1:9c5af431a1f1 488 {
gustavatmel 1:9c5af431a1f1 489 j = i % 3;
gustavatmel 1:9c5af431a1f1 490 k = i < 3;
gustavatmel 1:9c5af431a1f1 491
gustavatmel 1:9c5af431a1f1 492 if( verbose != 0 )
gustavatmel 1:9c5af431a1f1 493 mbedtls_printf( " SHA-%d test #%d: ", 256 - k * 32, j + 1 );
gustavatmel 1:9c5af431a1f1 494
gustavatmel 1:9c5af431a1f1 495 if( ( ret = mbedtls_sha256_starts_ret( &ctx, k ) ) != 0 )
gustavatmel 1:9c5af431a1f1 496 goto fail;
gustavatmel 1:9c5af431a1f1 497
gustavatmel 1:9c5af431a1f1 498 if( j == 2 )
gustavatmel 1:9c5af431a1f1 499 {
gustavatmel 1:9c5af431a1f1 500 memset( buf, 'a', buflen = 1000 );
gustavatmel 1:9c5af431a1f1 501
gustavatmel 1:9c5af431a1f1 502 for( j = 0; j < 1000; j++ )
gustavatmel 1:9c5af431a1f1 503 {
gustavatmel 1:9c5af431a1f1 504 ret = mbedtls_sha256_update_ret( &ctx, buf, buflen );
gustavatmel 1:9c5af431a1f1 505 if( ret != 0 )
gustavatmel 1:9c5af431a1f1 506 goto fail;
gustavatmel 1:9c5af431a1f1 507 }
gustavatmel 1:9c5af431a1f1 508
gustavatmel 1:9c5af431a1f1 509 }
gustavatmel 1:9c5af431a1f1 510 else
gustavatmel 1:9c5af431a1f1 511 {
gustavatmel 1:9c5af431a1f1 512 ret = mbedtls_sha256_update_ret( &ctx, sha256_test_buf[j],
gustavatmel 1:9c5af431a1f1 513 sha256_test_buflen[j] );
gustavatmel 1:9c5af431a1f1 514 if( ret != 0 )
gustavatmel 1:9c5af431a1f1 515 goto fail;
gustavatmel 1:9c5af431a1f1 516 }
gustavatmel 1:9c5af431a1f1 517
gustavatmel 1:9c5af431a1f1 518 if( ( ret = mbedtls_sha256_finish_ret( &ctx, sha256sum ) ) != 0 )
gustavatmel 1:9c5af431a1f1 519 goto fail;
gustavatmel 1:9c5af431a1f1 520
gustavatmel 1:9c5af431a1f1 521
gustavatmel 1:9c5af431a1f1 522 if( memcmp( sha256sum, sha256_test_sum[i], 32 - k * 4 ) != 0 )
gustavatmel 1:9c5af431a1f1 523 {
gustavatmel 1:9c5af431a1f1 524 ret = 1;
gustavatmel 1:9c5af431a1f1 525 goto fail;
gustavatmel 1:9c5af431a1f1 526 }
gustavatmel 1:9c5af431a1f1 527
gustavatmel 1:9c5af431a1f1 528 if( verbose != 0 )
gustavatmel 1:9c5af431a1f1 529 mbedtls_printf( "passed\n" );
gustavatmel 1:9c5af431a1f1 530 }
gustavatmel 1:9c5af431a1f1 531
gustavatmel 1:9c5af431a1f1 532 if( verbose != 0 )
gustavatmel 1:9c5af431a1f1 533 mbedtls_printf( "\n" );
gustavatmel 1:9c5af431a1f1 534
gustavatmel 1:9c5af431a1f1 535 goto exit;
gustavatmel 1:9c5af431a1f1 536
gustavatmel 1:9c5af431a1f1 537 fail:
gustavatmel 1:9c5af431a1f1 538 if( verbose != 0 )
gustavatmel 1:9c5af431a1f1 539 mbedtls_printf( "failed\n" );
gustavatmel 1:9c5af431a1f1 540
gustavatmel 1:9c5af431a1f1 541 exit:
gustavatmel 1:9c5af431a1f1 542 mbedtls_sha256_free( &ctx );
gustavatmel 1:9c5af431a1f1 543 mbedtls_free( buf );
gustavatmel 1:9c5af431a1f1 544
gustavatmel 1:9c5af431a1f1 545 return( ret );
gustavatmel 1:9c5af431a1f1 546 }
gustavatmel 1:9c5af431a1f1 547
gustavatmel 1:9c5af431a1f1 548 #endif /* MBEDTLS_SELF_TEST */
gustavatmel 1:9c5af431a1f1 549
gustavatmel 1:9c5af431a1f1 550 #endif /* MBEDTLS_SHA256_C */