blackbeard420/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf synced 2025-03-09 17:19:09 -04:00
Code Issues Projects Releases Wiki Activity

Merge branch 'fix/sha_port_formatting_and_local_val_types' into 'master'

Browse Source 
fix(mbedtls/sha): Fix formatting and change local variable's types

Closes IDF-12217 and IDF-12218

See merge request espressif/esp-idf!36792
This commit is contained in:
Mahavir Jain 2025-02-12 17:19:03 +08:00
commit 2038851936
4 changed files with 134 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
components/mbedtls/port/sha/core/esp_sha1.c
View File

@ -36,10 +36,10 @@
#include "sha/sha_core.h"
/* Implementation that should never be optimized out by the compiler */
static void mbedtls_zeroize( void *v, size_t n )
static void mbedtls_zeroize(void *v, size_t n)
{
volatile unsigned char *p = (unsigned char *)v;
while ( n-- ) {
while (n--) {
*p++ = 0;
}
}
@ -51,28 +51,28 @@ static void mbedtls_zeroize( void *v, size_t n )
#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) \
{ \
(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
(b)[(i) + 3] = (unsigned char) ( (n) ); \
(b)[(i) ] = (unsigned char) ((n) >> 24); \
(b)[(i) + 1] = (unsigned char) ((n) >> 16); \
(b)[(i) + 2] = (unsigned char) ((n) >> 8); \
(b)[(i) + 3] = (unsigned char) ((n) ); \
}
#endif
void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
void mbedtls_sha1_init(mbedtls_sha1_context *ctx)
{
memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
memset(ctx, 0, sizeof(mbedtls_sha1_context));
}
void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
void mbedtls_sha1_free(mbedtls_sha1_context *ctx)
{
if ( ctx == NULL ) {
if (ctx == NULL) {
return;
}
mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
mbedtls_zeroize(ctx, sizeof(mbedtls_sha1_context));
}
void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
const mbedtls_sha1_context *src )
void mbedtls_sha1_clone(mbedtls_sha1_context *dst,
const mbedtls_sha1_context *src)
{
memcpy(dst, src, sizeof(mbedtls_sha1_context));
}
@ -80,11 +80,11 @@ void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
/*
* SHA-1 context setup
*/
int mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
int mbedtls_sha1_starts(mbedtls_sha1_context *ctx)
{
ctx->total[0] = 0;
ctx->total[1] = 0;
memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
memset(ctx, 0, sizeof(mbedtls_sha1_context));
ctx->mode = SHA1;
return 0;
@ -110,7 +110,7 @@ static void esp_internal_sha1_block_process(mbedtls_sha1_context *ctx, const uin
}
}
int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] )
int mbedtls_internal_sha1_process(mbedtls_sha1_context *ctx, const unsigned char data[64])
{
esp_sha_acquire_hardware();
esp_internal_sha_update_state(ctx);
@ -133,12 +133,12 @@ int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx, const unsigned cha
return 0;
}
int mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen )
int mbedtls_sha1_update(mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen)
{
size_t fill;
uint32_t left, len, local_len = 0;
size_t fill, left, len;
uint32_t local_len = 0;
if ( !ilen || (input == NULL)) {
if (!ilen || (input == NULL)) {
return 0;
}
@ -148,21 +148,21 @@ int mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input,
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if ( ctx->total[0] < (uint32_t) ilen ) {
if (ctx->total[0] < (uint32_t) ilen) {
ctx->total[1]++;
}
if ( left && ilen >= fill ) {
memcpy( (void *) (ctx->buffer + left), input, fill );
if (left && ilen >= fill) {
memcpy((void *) (ctx->buffer + left), input, fill);
input += fill;
ilen -= fill;
left = 0;
local_len = 64;
}
len = (ilen / 64) * 64;
len = SHA_ALIGN_DOWN(ilen , 64);
if ( len || local_len) {
if (len || local_len) {
esp_sha_acquire_hardware();
@ -179,12 +179,12 @@ int mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input,
#endif /* SOC_SHA_SUPPORT_DMA */
{
/* First process buffered block, if any */
if ( local_len ) {
if (local_len) {
esp_internal_sha1_block_process(ctx, ctx->buffer);
}
uint32_t length_processed = 0;
while ( len - length_processed > 0 ) {
while (len - length_processed != 0) {
esp_internal_sha1_block_process(ctx, input + length_processed);
length_processed += 64;
}
@ -196,8 +196,8 @@ int mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input,
}
if ( ilen > 0 ) {
memcpy( (void *) (ctx->buffer + left), input + len, ilen - len );
if (ilen > 0) {
memcpy((void *) (ctx->buffer + left), input + len, ilen - len);
}
return 0;
}
@ -212,28 +212,27 @@ static const unsigned char sha1_padding[64] = {
/*
* SHA-1 final digest
*/
int mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
int mbedtls_sha1_finish(mbedtls_sha1_context *ctx, unsigned char output[20])
{
int ret = -1;
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
high = (ctx->total[0] >> 29)
| (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
PUT_UINT32_BE( high, msglen, 0 );
PUT_UINT32_BE( low, msglen, 4 );
PUT_UINT32_BE(high, msglen, 0);
PUT_UINT32_BE(low, msglen, 4);
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
padn = (last < 56) ? (56 - last) : (120 - last);
if ( ( ret = mbedtls_sha1_update( ctx, sha1_padding, padn ) ) != 0 ) {
if ((ret = mbedtls_sha1_update(ctx, sha1_padding, padn)) != 0) {
return ret;
}
if ( ( ret = mbedtls_sha1_update( ctx, msglen, 8 ) ) != 0 ) {
if ((ret = mbedtls_sha1_update(ctx, msglen, 8)) != 0) {
return ret;
}

93
components/mbedtls/port/sha/core/esp_sha256.c
View File

@ -36,10 +36,10 @@
#include "sha/sha_core.h"
/* Implementation that should never be optimized out by the compiler */
static void mbedtls_zeroize( void *v, size_t n )
static void mbedtls_zeroize(void *v, size_t n)
{
volatile unsigned char *p = v;
while ( n-- ) {
while (n--) {
*p++ = 0;
}
}
@ -50,39 +50,39 @@ static void mbedtls_zeroize( void *v, size_t n )
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i) \
do { \
(n) = ( (uint32_t) (b)[(i) ] << 24 ) \
| ( (uint32_t) (b)[(i) + 1] << 16 ) \
| ( (uint32_t) (b)[(i) + 2] << 8 ) \
| ( (uint32_t) (b)[(i) + 3] ); \
} while( 0 )
(n) = ((uint32_t) (b)[(i) ] << 24) \
| ((uint32_t) (b)[(i) + 1] << 16) \
| ((uint32_t) (b)[(i) + 2] << 8) \
| ((uint32_t) (b)[(i) + 3] ); \
} while(0)
#endif
#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) \
do { \
(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
(b)[(i) + 3] = (unsigned char) ( (n) ); \
} while( 0 )
(b)[(i) ] = (unsigned char) ((n) >> 24); \
(b)[(i) + 1] = (unsigned char) ((n) >> 16); \
(b)[(i) + 2] = (unsigned char) ((n) >> 8); \
(b)[(i) + 3] = (unsigned char) ((n) ); \
} while(0)
#endif
void mbedtls_sha256_init( mbedtls_sha256_context *ctx )
void mbedtls_sha256_init(mbedtls_sha256_context *ctx)
{
memset( ctx, 0, sizeof( mbedtls_sha256_context ) );
memset(ctx, 0, sizeof(mbedtls_sha256_context));
}
void mbedtls_sha256_free( mbedtls_sha256_context *ctx )
void mbedtls_sha256_free(mbedtls_sha256_context *ctx)
{
if ( ctx == NULL ) {
if (ctx == NULL) {
return;
}
mbedtls_zeroize( ctx, sizeof( mbedtls_sha256_context ) );
mbedtls_zeroize(ctx, sizeof(mbedtls_sha256_context));
}
void mbedtls_sha256_clone( mbedtls_sha256_context *dst,
const mbedtls_sha256_context *src )
void mbedtls_sha256_clone(mbedtls_sha256_context *dst,
const mbedtls_sha256_context *src)
{
*dst = *src;
}
@ -90,11 +90,11 @@ void mbedtls_sha256_clone( mbedtls_sha256_context *dst,
/*
* SHA-256 context setup
*/
int mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
int mbedtls_sha256_starts(mbedtls_sha256_context *ctx, int is224)
{
memset( ctx, 0, sizeof( mbedtls_sha256_context ) );
memset(ctx, 0, sizeof(mbedtls_sha256_context));
if ( is224 ) {
if (is224) {
ctx->mode = SHA2_224;
} else {
ctx->mode = SHA2_256;
@ -123,7 +123,7 @@ static void esp_internal_sha256_block_process(mbedtls_sha256_context *ctx, const
}
}
int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx, const unsigned char data[64] )
int mbedtls_internal_sha256_process(mbedtls_sha256_context *ctx, const unsigned char data[64])
{
esp_sha_acquire_hardware();
esp_internal_sha_update_state(ctx);
@ -149,13 +149,13 @@ int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx, const unsigned
/*
* SHA-256 process buffer
*/
int mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *input,
size_t ilen )
int mbedtls_sha256_update(mbedtls_sha256_context *ctx, const unsigned char *input,
size_t ilen)
{
size_t fill;
uint32_t left, len, local_len = 0;
size_t fill, left, len;
uint32_t local_len = 0;
if ( ilen == 0 ) {
if (ilen == 0) {
return 0;
}
@ -165,13 +165,13 @@ int mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *inp
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if ( ctx->total[0] < (uint32_t) ilen ) {
if (ctx->total[0] < (uint32_t) ilen) {
ctx->total[1]++;
}
/* Check if any data pending from previous call to this API */
if ( left && ilen >= fill ) {
memcpy( (void *) (ctx->buffer + left), input, fill );
if (left && ilen >= fill) {
memcpy((void *) (ctx->buffer + left), input, fill);
input += fill;
ilen -= fill;
@ -179,8 +179,9 @@ int mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *inp
local_len = 64;
}
len = (ilen / 64) * 64;
if ( len || local_len) {
len = SHA_ALIGN_DOWN(ilen , 64);
if (len || local_len) {
esp_sha_acquire_hardware();
@ -197,12 +198,12 @@ int mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *inp
#endif /* SOC_SHA_SUPPORT_DMA */
{
/* First process buffered block, if any */
if ( local_len ) {
if (local_len) {
esp_internal_sha256_block_process(ctx, ctx->buffer);
}
uint32_t length_processed = 0;
while ( len - length_processed > 0 ) {
while (len - length_processed != 0) {
esp_internal_sha256_block_process(ctx, input + length_processed);
length_processed += 64;
}
@ -213,8 +214,8 @@ int mbedtls_sha256_update( mbedtls_sha256_context *ctx, const unsigned char *inp
esp_sha_release_hardware();
}
if ( ilen > 0 ) {
memcpy( (void *) (ctx->buffer + left), input + len, ilen - len );
if (ilen > 0) {
memcpy((void *) (ctx->buffer + left), input + len, ilen - len);
}
return 0;
@ -230,28 +231,28 @@ static const unsigned char sha256_padding[64] = {
/*
* SHA-256 final digest
*/
int mbedtls_sha256_finish( mbedtls_sha256_context *ctx, unsigned char *output )
int mbedtls_sha256_finish(mbedtls_sha256_context *ctx, unsigned char *output)
{
int ret = -1;
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
high = (ctx->total[0] >> 29)
| (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
PUT_UINT32_BE( high, msglen, 0 );
PUT_UINT32_BE( low, msglen, 4 );
PUT_UINT32_BE(high, msglen, 0);
PUT_UINT32_BE(low, msglen, 4);
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
padn = (last < 56) ? (56 - last) : (120 - last);
if ( ( ret = mbedtls_sha256_update( ctx, sha256_padding, padn ) ) != 0 ) {
if ((ret = mbedtls_sha256_update(ctx, sha256_padding, padn)) != 0) {
return ret;
}
if ( ( ret = mbedtls_sha256_update( ctx, msglen, 8 ) ) != 0 ) {
if ((ret = mbedtls_sha256_update(ctx, msglen, 8)) != 0) {
return ret;
}

94
components/mbedtls/port/sha/core/esp_sha512.c
View File

@ -42,10 +42,10 @@
#include "sha/sha_core.h"
/* Implementation that should never be optimized out by the compiler */
static void mbedtls_zeroize( void *v, size_t n )
static void mbedtls_zeroize(void *v, size_t n)
{
volatile unsigned char *p = v;
while ( n-- ) {
while (n--) {
*p++ = 0;
}
}
@ -56,14 +56,14 @@ static void mbedtls_zeroize( void *v, size_t n )
#ifndef PUT_UINT64_BE
#define PUT_UINT64_BE(n,b,i) \
{ \
(b)[(i) ] = (unsigned char) ( (n) >> 56 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 48 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 40 ); \
(b)[(i) + 3] = (unsigned char) ( (n) >> 32 ); \
(b)[(i) + 4] = (unsigned char) ( (n) >> 24 ); \
(b)[(i) + 5] = (unsigned char) ( (n) >> 16 ); \
(b)[(i) + 6] = (unsigned char) ( (n) >> 8 ); \
(b)[(i) + 7] = (unsigned char) ( (n) ); \
(b)[(i) ] = (unsigned char) ((n) >> 56); \
(b)[(i) + 1] = (unsigned char) ((n) >> 48); \
(b)[(i) + 2] = (unsigned char) ((n) >> 40); \
(b)[(i) + 3] = (unsigned char) ((n) >> 32); \
(b)[(i) + 4] = (unsigned char) ((n) >> 24); \
(b)[(i) + 5] = (unsigned char) ((n) >> 16); \
(b)[(i) + 6] = (unsigned char) ((n) >> 8); \
(b)[(i) + 7] = (unsigned char) ((n) ); \
}
#endif /* PUT_UINT64_BE */
@ -83,27 +83,27 @@ void esp_sha512_set_mode(mbedtls_sha512_context *ctx, esp_sha_type type)
}
/* For SHA512/t mode the initial hash value will depend on t */
void esp_sha512_set_t( mbedtls_sha512_context *ctx, uint16_t t_val)
void esp_sha512_set_t(mbedtls_sha512_context *ctx, uint16_t t_val)
{
ctx->t_val = t_val;
}
void mbedtls_sha512_init( mbedtls_sha512_context *ctx )
void mbedtls_sha512_init(mbedtls_sha512_context *ctx)
{
memset( ctx, 0, sizeof( mbedtls_sha512_context ) );
memset(ctx, 0, sizeof(mbedtls_sha512_context));
}
void mbedtls_sha512_free( mbedtls_sha512_context *ctx )
void mbedtls_sha512_free(mbedtls_sha512_context *ctx)
{
if ( ctx == NULL ) {
if (ctx == NULL) {
return;
}
mbedtls_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
mbedtls_zeroize(ctx, sizeof(mbedtls_sha512_context));
}
void mbedtls_sha512_clone( mbedtls_sha512_context *dst,
const mbedtls_sha512_context *src )
void mbedtls_sha512_clone(mbedtls_sha512_context *dst,
const mbedtls_sha512_context *src)
{
memcpy(dst, src, sizeof(mbedtls_sha512_context));
}
@ -111,11 +111,11 @@ void mbedtls_sha512_clone( mbedtls_sha512_context *dst,
/*
* SHA-512 context setup
*/
int mbedtls_sha512_starts( mbedtls_sha512_context *ctx, int is384 )
int mbedtls_sha512_starts(mbedtls_sha512_context *ctx, int is384)
{
mbedtls_zeroize( ctx, sizeof( mbedtls_sha512_context ) );
mbedtls_zeroize(ctx, sizeof(mbedtls_sha512_context));
if ( is384 ) {
if (is384) {
ctx->mode = SHA2_384;
} else {
ctx->mode = SHA2_512;
@ -154,7 +154,7 @@ static void esp_internal_sha512_block_process(mbedtls_sha512_context *ctx, const
}
}
int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx, const unsigned char data[128] )
int mbedtls_internal_sha512_process(mbedtls_sha512_context *ctx, const unsigned char data[128])
{
int ret = -1;
@ -187,27 +187,26 @@ int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx, const unsigned
/*
* SHA-512 process buffer
*/
int mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *input,
size_t ilen )
int mbedtls_sha512_update(mbedtls_sha512_context *ctx, const unsigned char *input, size_t ilen)
{
size_t fill;
unsigned int left, len, local_len = 0;
size_t fill, left, len;
uint32_t local_len = 0;
if ( ilen == 0 ) {
if (ilen == 0) {
return 0;
}
left = (unsigned int) (ctx->total[0] & 0x7F);
left = (size_t) (ctx->total[0] & 0x7F);
fill = 128 - left;
ctx->total[0] += (uint64_t) ilen;
if ( ctx->total[0] < (uint64_t) ilen ) {
if (ctx->total[0] < (uint64_t) ilen) {
ctx->total[1]++;
}
if ( left && ilen >= fill ) {
memcpy( (void *) (ctx->buffer + left), input, fill );
if (left && ilen >= fill) {
memcpy((void *) (ctx->buffer + left), input, fill);
input += fill;
ilen -= fill;
@ -215,8 +214,9 @@ int mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *inp
local_len = 128;
}
len = (ilen / 128) * 128;
if ( len || local_len) {
len = SHA_ALIGN_DOWN(ilen , 128);
if (len || local_len) {
esp_sha_acquire_hardware();
@ -238,12 +238,12 @@ int mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *inp
#endif /* SOC_SHA_SUPPORT_DMA */
{
/* First process buffered block, if any */
if ( local_len ) {
if (local_len) {
esp_internal_sha512_block_process(ctx, ctx->buffer);
}
uint32_t length_processed = 0;
while ( len - length_processed > 0 ) {
while (len - length_processed != 0) {
esp_internal_sha512_block_process(ctx, input + length_processed);
length_processed += 128;
}
@ -254,8 +254,8 @@ int mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *inp
esp_sha_release_hardware();
}
if ( ilen > 0 ) {
memcpy( (void *) (ctx->buffer + left), input + len, ilen - len );
if (ilen > 0) {
memcpy((void *) (ctx->buffer + left), input + len, ilen - len);
}
return 0;
@ -275,28 +275,28 @@ static const unsigned char sha512_padding[128] = {
/*
* SHA-512 final digest
*/
int mbedtls_sha512_finish( mbedtls_sha512_context *ctx, unsigned char *output )
int mbedtls_sha512_finish(mbedtls_sha512_context *ctx, unsigned char *output)
{
int ret = -1;
size_t last, padn;
uint64_t high, low;
unsigned char msglen[16];
high = ( ctx->total[0] >> 61 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
high = (ctx->total[0] >> 61)
| (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
PUT_UINT64_BE( high, msglen, 0 );
PUT_UINT64_BE( low, msglen, 8 );
PUT_UINT64_BE(high, msglen, 0);
PUT_UINT64_BE(low, msglen, 8);
last = (size_t)( ctx->total[0] & 0x7F );
padn = ( last < 112 ) ? ( 112 - last ) : ( 240 - last );
last = (size_t)(ctx->total[0] & 0x7F);
padn = (last < 112) ? (112 - last) : (240 - last);
if ( ( ret = mbedtls_sha512_update( ctx, sha512_padding, padn ) ) != 0 ) {
if ((ret = mbedtls_sha512_update(ctx, sha512_padding, padn)) != 0) {
return ret;
}
if ( ( ret = mbedtls_sha512_update( ctx, msglen, 16 ) ) != 0 ) {
if ((ret = mbedtls_sha512_update(ctx, msglen, 16)) != 0) {
return ret;
}

2
components/mbedtls/port/sha/core/include/esp_sha_internal.h
View File

@ -37,6 +37,8 @@ extern "C" {
#endif
#endif /* SOC_SHA_SUPPORT_DMA */
#define SHA_ALIGN_DOWN(num, align) ((num) & ~((align) - 1))
typedef enum {
SHA_BLOCK_MODE,
#if SOC_SHA_SUPPORT_DMA