Ignore:
Timestamp:
Jun 22, 2021, 9:00:19 PM (3 years ago)
Author:
coas-nagasima
Message:

WolfSSLとAzure IoT SDKを更新

Location:
azure_iot_hub_f767zi/trunk/wolfssl-4.7.0
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • azure_iot_hub_f767zi/trunk/wolfssl-4.7.0/wolfcrypt/src/blake2b.c

    r457 r464  
    4444#include <wolfssl/wolfcrypt/blake2.h>
    4545#include <wolfssl/wolfcrypt/blake2-impl.h>
     46#include <wolfssl/wolfcrypt/error-crypt.h>
    4647
    4748
     
    125126  blake2b_param P[1];
    126127
    127   if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
     128  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return BAD_FUNC_ARG;
    128129
    129130#ifdef WOLFSSL_BLAKE2B_INIT_EACH_FIELD
     
    154155  blake2b_param P[1];
    155156
    156   if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
    157 
    158   if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;
     157  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return BAD_FUNC_ARG;
     158
     159  if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return BAD_FUNC_ARG;
    159160
    160161#ifdef WOLFSSL_BLAKE2B_INIT_EACH_FIELD
     
    178179#endif
    179180
    180   if( blake2b_init_param( S, P ) < 0 ) return -1;
     181  {
     182    int ret = blake2b_init_param( S, P );
     183    if ( ret < 0 ) return ret;
     184  }
    181185
    182186  {
     
    186190    block = (byte*)XMALLOC(BLAKE2B_BLOCKBYTES, NULL, DYNAMIC_TYPE_TMP_BUFFER);
    187191
    188     if ( block == NULL ) return -1;
     192    if ( block == NULL ) return MEMORY_E;
    189193#else
    190194    byte block[BLAKE2B_BLOCKBYTES];
     
    204208}
    205209
    206 static int blake2b_compress( blake2b_state *S,
    207                              const byte block[BLAKE2B_BLOCKBYTES] )
     210static WC_INLINE int blake2b_compress(
     211    blake2b_state *S,
     212    const byte block[BLAKE2B_BLOCKBYTES],
     213    word64* m,
     214    word64* v)
    208215{
    209216  int i;
    210 
    211 #ifdef WOLFSSL_SMALL_STACK
    212   word64* m;
    213   word64* v;
    214 
    215   m = (word64*)XMALLOC(sizeof(word64) * 16, NULL, DYNAMIC_TYPE_TMP_BUFFER);
    216 
    217   if ( m == NULL ) return -1;
    218 
    219   v = (word64*)XMALLOC(sizeof(word64) * 16, NULL, DYNAMIC_TYPE_TMP_BUFFER);
    220 
    221   if ( v == NULL )
    222   {
    223     XFREE(m, NULL, DYNAMIC_TYPE_TMP_BUFFER);
    224     return -1;
    225   }
    226 #else
    227   word64 m[16];
    228   word64 v[16];
    229 #endif
    230217
    231218  for( i = 0; i < 16; ++i )
     
    284271#undef ROUND
    285272
    286 #ifdef WOLFSSL_SMALL_STACK
    287   XFREE(m, NULL, DYNAMIC_TYPE_TMP_BUFFER);
    288   XFREE(v, NULL, DYNAMIC_TYPE_TMP_BUFFER);
    289 #endif
    290 
    291273  return 0;
    292274}
     
    295277int blake2b_update( blake2b_state *S, const byte *in, word64 inlen )
    296278{
     279  int ret = 0;
     280#ifdef WOLFSSL_SMALL_STACK
     281  word64* m;
     282  word64* v;
     283
     284  m = (word64*)XMALLOC(sizeof(word64) * 32, NULL, DYNAMIC_TYPE_TMP_BUFFER);
     285
     286  if ( m == NULL ) return MEMORY_E;
     287
     288  v = &m[16];
     289#else
     290  word64 m[16];
     291  word64 v[16];
     292#endif
     293
    297294  while( inlen > 0 )
    298295  {
     
    306303      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
    307304
    308       if ( blake2b_compress( S, S->buf ) < 0 ) return -1; /* Compress */
     305      {
     306        ret = blake2b_compress( S, S->buf, m, v );
     307        if (ret < 0) break;
     308      }
    309309
    310310      XMEMCPY( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES );
     
    322322  }
    323323
    324   return 0;
     324#ifdef WOLFSSL_SMALL_STACK
     325  XFREE(m, NULL, DYNAMIC_TYPE_TMP_BUFFER);
     326#endif
     327
     328  return ret;
    325329}
    326330
     
    328332int blake2b_final( blake2b_state *S, byte *out, byte outlen )
    329333{
     334  int ret = 0;
    330335  byte buffer[BLAKE2B_OUTBYTES];
    331336  int     i;
     337#ifdef WOLFSSL_SMALL_STACK
     338  word64* m;
     339  word64* v;
     340
     341  m = (word64*)XMALLOC(sizeof(word64) * 32, NULL, DYNAMIC_TYPE_TMP_BUFFER);
     342
     343  if ( m == NULL ) return MEMORY_E;
     344
     345  v = &m[16];
     346#else
     347  word64 m[16];
     348  word64 v[16];
     349#endif
    332350
    333351  if( S->buflen > BLAKE2B_BLOCKBYTES )
     
    335353    blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
    336354
    337     if ( blake2b_compress( S, S->buf ) < 0 ) return -1;
     355    {
     356      ret = blake2b_compress( S, S->buf, m, v );
     357      if (ret < 0) goto out;
     358    }
    338359
    339360    S->buflen -= BLAKE2B_BLOCKBYTES;
     
    345366  XMEMSET( S->buf + S->buflen, 0, (wolfssl_word)(2 * BLAKE2B_BLOCKBYTES - S->buflen) );
    346367         /* Padding */
    347   if ( blake2b_compress( S, S->buf ) < 0 ) return -1;
     368  {
     369    ret = blake2b_compress( S, S->buf, m, v );
     370    if (ret < 0) goto out;
     371  }
    348372
    349373  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
     
    351375
    352376  XMEMCPY( out, buffer, outlen );
    353   return 0;
     377
     378 out:
     379
     380#ifdef WOLFSSL_SMALL_STACK
     381  XFREE(m, NULL, DYNAMIC_TYPE_TMP_BUFFER);
     382#endif
     383
     384  return ret;
    354385}
    355386
     
    361392
    362393  /* Verify parameters */
    363   if ( NULL == in ) return -1;
    364 
    365   if ( NULL == out ) return -1;
     394  if ( NULL == in ) return BAD_FUNC_ARG;
     395
     396  if ( NULL == out ) return BAD_FUNC_ARG;
    366397
    367398  if( NULL == key ) keylen = 0;
     
    369400  if( keylen > 0 )
    370401  {
    371     if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
     402    int ret = blake2b_init_key( S, outlen, key, keylen );
     403    if (ret < 0) return ret;
    372404  }
    373405  else
    374406  {
    375     if( blake2b_init( S, outlen ) < 0 ) return -1;
    376   }
    377 
    378   if ( blake2b_update( S, ( byte * )in, inlen ) < 0) return -1;
     407    int ret = blake2b_init( S, outlen );
     408    if (ret < 0) return ret;
     409  }
     410
     411  {
     412    int ret = blake2b_update( S, ( byte * )in, inlen );
     413    if (ret < 0) return ret;
     414  }
    379415
    380416  return blake2b_final( S, out, outlen );
     
    423459{
    424460    if (b2b == NULL){
    425         return -1;
     461        return BAD_FUNC_ARG;
    426462    }
    427463    b2b->digestSz = digestSz;
     
    430466}
    431467
     468/* Init Blake2b digest with key, track size in case final doesn't want to "remember" */
     469int wc_InitBlake2b_WithKey(Blake2b* b2b, word32 digestSz, const byte *key, word32 keylen)
     470{
     471    if (b2b == NULL){
     472        return BAD_FUNC_ARG;
     473    }
     474    b2b->digestSz = digestSz;
     475
     476    if (keylen >= 256)
     477        return BAD_FUNC_ARG;
     478
     479    if (key)
     480        return blake2b_init_key(b2b->S, (byte)digestSz, key, (byte)keylen);
     481    else
     482        return blake2b_init(b2b->S, (byte)digestSz);
     483}
    432484
    433485/* Blake2b Update */
Note: See TracChangeset for help on using the changeset viewer.