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/dh.c

    r457 r464  
    931931    key->heap = heap; /* for XMALLOC/XFREE in future */
    932932
    933 #if !defined(WOLFSSL_QT) && !defined(OPENSSL_ALL)
     933#ifdef WOLFSSL_DH_EXTRA
     934    if (mp_init_multi(&key->p, &key->g, &key->q, &key->pub, &key->priv, NULL) != MP_OKAY)
     935#else
    934936    if (mp_init_multi(&key->p, &key->g, &key->q, NULL, NULL, NULL) != MP_OKAY)
    935 #else
    936     if (mp_init_multi(&key->p,&key->g,&key->q,&key->pub,&key->priv,NULL) != MP_OKAY)
    937937#endif
    938938        return MEMORY_E;
    … …  
    961961        mp_clear(&key->g);
    962962        mp_clear(&key->q);
     963    #ifdef WOLFSSL_DH_EXTRA
     964        mp_clear(&key->pub);
     965        mp_forcezero(&key->priv);
     966    #endif
    963967
    964968    #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_DH)
    … …  
    11491153
    11501154    mp_forcezero(tmpX);
    1151     mp_clear(tmpX);
    11521155    mp_clear(tmpQ);
    11531156#ifdef WOLFSSL_SMALL_STACK
    … …  
    12071210        }
    12081211
    1209         ret = wc_RNG_GenerateBlock(rng, priv, sz);
     1212        if (sz > *privSz)
     1213            ret = WC_KEY_SIZE_E;
     1214
     1215        if (ret == 0)
     1216            ret = wc_RNG_GenerateBlock(rng, priv, sz);
    12101217
    12111218        if (ret == 0) {
    … …  
    12311238    int ret = 0;
    12321239#ifndef WOLFSSL_SP_MATH
     1240    word32 binSz = 0;
    12331241#ifdef WOLFSSL_SMALL_STACK
    12341242    mp_int* x;
    … …  
    12551263#endif
    12561264
    1257 #ifndef WOLFSSL_SP_MATH
     1265#if !defined(WOLFSSL_SP_MATH)
    12581266#ifdef WOLFSSL_SMALL_STACK
    12591267    x = (mp_int*)XMALLOC(sizeof(mp_int), key->heap, DYNAMIC_TYPE_DH);
    … …  
    12801288        ret = MP_EXPTMOD_E;
    12811289
     1290    if (ret == 0) {
     1291        binSz = mp_unsigned_bin_size(y);
     1292        if (binSz > *pubSz) {
     1293            ret = WC_KEY_SIZE_E;
     1294        }
     1295    }
     1296
    12821297    if (ret == 0 && mp_to_unsigned_bin(y, pub) != MP_OKAY)
    12831298        ret = MP_TO_E;
    12841299
    12851300    if (ret == 0)
    1286         *pubSz = mp_unsigned_bin_size(y);
     1301        *pubSz = binSz;
    12871302
    12881303    mp_clear(y);
    … …  
    14681483    }
    14691484
     1485    /* SP 800-56Ar3, section 5.6.2.3.1, process step 2 */
    14701486    if (ret == 0 && prime != NULL) {
    14711487#ifdef WOLFSSL_HAVE_SP_DH
    … …  
    14861502        else
    14871503#endif
    1488 #ifdef WOLFSSL_SP_NO_4096
     1504#ifdef WOLFSSL_SP_4096
    14891505        if (mp_count_bits(&key->p) == 4096) {
    14901506            ret = sp_ModExp_4096(y, q, p, y);
    … …  
    14971513
    14981514        {
    1499     /* SP 800-56Ar3, section 5.6.2.3.1, process step 2 */
    1500 #ifndef WOLFSSL_SP_MATH
     1515#if !defined(WOLFSSL_SP_MATH)
    15011516            /* calculate (y^q) mod(p), store back into y */
    15021517            if (mp_exptmod(y, q, p, y) != MP_OKAY)
    … …  
    17831798#endif
    17841799        {
    1785 #ifndef WOLFSSL_SP_MATH
     1800#if !defined(WOLFSSL_SP_MATH)
    17861801            if (mp_exptmod(&key->g, privateKey, &key->p, checkKey) != MP_OKAY)
    17871802                ret = MP_EXPTMOD_E;
    … …  
    17991814
    18001815    mp_forcezero(privateKey);
    1801     mp_clear(privateKey);
    18021816    mp_clear(publicKey);
    18031817    mp_clear(checkKey);
    … …  
    18351849}
    18361850
    1837 
    18381851static int wc_DhAgree_Sync(DhKey* key, byte* agree, word32* agreeSz,
    18391852    const byte* priv, word32 privSz, const byte* otherPub, word32 pubSz)
    … …  
    18411854    int ret = 0;
    18421855#ifdef WOLFSSL_SMALL_STACK
    1843     mp_int* y;
    1844 #ifndef WOLFSSL_SP_MATH
    1845     mp_int* x;
    1846     mp_int* z;
     1856    mp_int* y = NULL;
     1857#if !defined(WOLFSSL_SP_MATH)
     1858    mp_int* x = NULL;
     1859    mp_int* z = NULL;
    18471860#endif
    18481861#else
    18491862    mp_int y[1];
    1850 #ifndef WOLFSSL_SP_MATH
     1863#if !defined(WOLFSSL_SP_MATH)
    18511864    mp_int x[1];
    18521865    mp_int z[1];
    … …  
    18701883    if (y == NULL)
    18711884        return MEMORY_E;
    1872 #ifndef WOLFSSL_SP_MATH
     1885#if !defined(WOLFSSL_SP_MATH)
    18731886    x = (mp_int*)XMALLOC(sizeof(mp_int), key->heap, DYNAMIC_TYPE_DH);
    18741887    if (x == NULL) {
    … …  
    18991912        mp_clear(y);
    19001913    #ifdef WOLFSSL_SMALL_STACK
    1901     #ifndef WOLFSSL_SP_MATH
     1914    #if !defined(WOLFSSL_SP_MATH)
    19021915        XFREE(z, key->heap, DYNAMIC_TYPE_DH);
    19031916        XFREE(x, key->heap, DYNAMIC_TYPE_DH);
    … …  
    19211934        mp_clear(y);
    19221935    #ifdef WOLFSSL_SMALL_STACK
    1923     #ifndef WOLFSSL_SP_MATH
     1936    #if !defined(WOLFSSL_SP_MATH)
    19241937        XFREE(z, key->heap, DYNAMIC_TYPE_DH);
    19251938        XFREE(x, key->heap, DYNAMIC_TYPE_DH);
    … …  
    19431956        mp_clear(y);
    19441957    #ifdef WOLFSSL_SMALL_STACK
    1945     #ifndef WOLFSSL_SP_MATH
     1958    #if !defined(WOLFSSL_SP_MATH)
    19461959        XFREE(z, key->heap, DYNAMIC_TYPE_DH);
    19471960        XFREE(x, key->heap, DYNAMIC_TYPE_DH);
    … …  
    19541967#endif
    19551968
    1956 #ifndef WOLFSSL_SP_MATH
     1969#if !defined(WOLFSSL_SP_MATH)
    19571970    if (mp_init_multi(x, y, z, 0, 0, 0) != MP_OKAY) {
    19581971    #ifdef WOLFSSL_SMALL_STACK
    … …  
    19861999    mp_clear(y);
    19872000    mp_forcezero(x);
     2001#else
     2002    ret = WC_KEY_SIZE_E;
    19882003#endif
    19892004
    19902005#ifdef WOLFSSL_SMALL_STACK
    1991 #ifndef WOLFSSL_SP_MATH
     2006#if !defined(WOLFSSL_SP_MATH)
    19922007    XFREE(z, key->heap, DYNAMIC_TYPE_DH);
    19932008    XFREE(x, key->heap, DYNAMIC_TYPE_DH);
    … …  
    20662081}
    20672082
    2068 #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL)
     2083#ifdef WOLFSSL_DH_EXTRA
     2084WOLFSSL_LOCAL int wc_DhKeyCopy(DhKey* src, DhKey* dst)
     2085{
     2086    int ret;
     2087
     2088    if (!src || !dst || src == dst) {
     2089        WOLFSSL_MSG("Parameters not provided or are the same");
     2090        return BAD_FUNC_ARG;
     2091    }
     2092
     2093    if ((ret = mp_copy(&src->p, &dst->p)) != MP_OKAY) {
     2094        WOLFSSL_MSG("mp_copy error");
     2095        return ret;
     2096    }
     2097
     2098    if ((ret = mp_copy(&src->g, &dst->g)) != MP_OKAY) {
     2099        WOLFSSL_MSG("mp_copy error");
     2100        return ret;
     2101    }
     2102
     2103    if ((ret = mp_copy(&src->q, &dst->q)) != MP_OKAY) {
     2104        WOLFSSL_MSG("mp_copy error");
     2105        return ret;
     2106    }
     2107
     2108    if ((ret = mp_copy(&src->pub, &dst->pub)) != MP_OKAY) {
     2109        WOLFSSL_MSG("mp_copy error");
     2110        return ret;
     2111    }
     2112
     2113    if ((ret = mp_copy(&src->priv, &dst->priv)) != MP_OKAY) {
     2114        WOLFSSL_MSG("mp_copy error");
     2115        return ret;
     2116    }
     2117
     2118    dst->heap = src->heap;
     2119
     2120    return MP_OKAY;
     2121}
     2122
    20692123/* Sets private and public key in DhKey if both are available, otherwise sets
    2070     either private or public key, depending on which is available.
    2071     Returns WOLFSSL_SUCCESS if at least one of the keys was set. */
    2072 WOLFSSL_LOCAL int wc_DhSetFullKeys(DhKey* key,const byte* priv_key,word32 privSz,
    2073                                    const byte* pub_key, word32 pubSz)
    2074 {
    2075     byte havePriv = 0;
    2076     byte havePub = 0;
    2077     mp_int* keyPriv = NULL;
    2078     mp_int* keyPub  = NULL;
     2124    either private or public key, depending on which is available. */
     2125int wc_DhImportKeyPair(DhKey* key, const byte* priv, word32 privSz,
     2126                       const byte* pub, word32 pubSz)
     2127{
     2128    byte havePriv, havePub;
     2129    mp_int *keyPriv = NULL, *keyPub  = NULL;
    20792130
    20802131    if (key == NULL) {
    … …  
    20822133    }
    20832134
    2084     havePriv = ( (priv_key != NULL) && (privSz > 0) );
    2085     havePub  = ( (pub_key  != NULL) && (pubSz  > 0) );
     2135    havePriv = ( (priv != NULL) && (privSz > 0) );
     2136    havePub  = ( (pub  != NULL) && (pubSz  > 0) );
    20862137
    20872138    if (!havePub && !havePriv) {
    … …  
    20892140        return BAD_FUNC_ARG;
    20902141    }
     2142
    20912143    /* Set Private Key */
    2092     if (havePriv == TRUE) {
     2144    if (havePriv) {
    20932145        /* may have leading 0 */
    2094         if (priv_key[0] == 0) {
    2095             privSz--; priv_key++;
     2146        if (priv[0] == 0) {
     2147            privSz--; priv++;
    20962148        }
    20972149        if (mp_init(&key->priv) != MP_OKAY)
    2098             havePriv = FALSE;
    2099     }
    2100 
    2101     if (havePriv == TRUE) {
    2102         if (mp_read_unsigned_bin(&key->priv, priv_key, privSz) != MP_OKAY) {
    2103             havePriv = FALSE;
     2150            havePriv = 0;
     2151    }
     2152    if (havePriv) {
     2153        if (mp_read_unsigned_bin(&key->priv, priv, privSz) != MP_OKAY) {
     2154            mp_clear(&key->priv);
     2155            havePriv = 0;
    21042156        } else {
    21052157            keyPriv = &key->priv;
    2106             WOLFSSL_MSG("DH Private Key Set.");
     2158            WOLFSSL_MSG("DH Private Key Set");
    21072159        }
    21082160    }
    21092161
    21102162    /* Set Public Key */
    2111     if (havePub == TRUE) {
     2163    if (havePub) {
    21122164        /* may have leading 0 */
    2113         if (pub_key[0] == 0) {
    2114             pubSz--; pub_key++;
     2165        if (pub[0] == 0) {
     2166            pubSz--; pub++;
    21152167        }
    21162168        if (mp_init(&key->pub) != MP_OKAY)
    2117             havePub = FALSE;
    2118     }
    2119 
    2120     if (havePub == TRUE) {
    2121         if (mp_read_unsigned_bin(&key->pub, pub_key, pubSz) != MP_OKAY) {
    2122             havePub = FALSE;
     2169            havePub = 0;
     2170    }
     2171    if (havePub) {
     2172        if (mp_read_unsigned_bin(&key->pub, pub, pubSz) != MP_OKAY) {
     2173            mp_clear(&key->pub);
     2174            havePub = 0;
    21232175        } else {
    21242176            keyPub = &key->pub;
    2125             WOLFSSL_MSG("DH Public Key Set.");
    2126         }
    2127     }
    2128     /* Free Memory if error occured */
    2129     if (havePriv == FALSE && keyPriv != NULL)
     2177            WOLFSSL_MSG("DH Public Key Set");
     2178        }
     2179    }
     2180    /* Free Memory if error occurred */
     2181    if (havePriv == 0 && keyPriv != NULL)
    21302182        mp_clear(keyPriv);
    2131     if (havePub == FALSE && keyPub != NULL)
     2183    if (havePub == 0 && keyPub != NULL)
    21322184        mp_clear(keyPub);
    21332185
    2134     /* WOLFSSL_SUCCESS if private or public was set else WOLFSSL_FAILURE */
    2135     return havePriv || havePub;
    2136 }
    2137 #endif
     2186    if (havePriv == 0 && havePub == 0) {
     2187        return MEMORY_E;
     2188    }
     2189
     2190    return 0;
     2191}
     2192
     2193/* Can be used with WOLFSSL_DH_EXTRA when key is loaded with
     2194    wc_DhKeyDecode or wc_DhImportKeyPair */
     2195int wc_DhExportKeyPair(DhKey* key, byte* priv, word32* pPrivSz,
     2196    byte* pub, word32* pPubSz)
     2197{
     2198    int ret = 0;
     2199    word32 pubSz, privSz;
     2200
     2201    if (key == NULL || (priv && pPrivSz == NULL) || (pub && pPubSz == NULL)) {
     2202        return BAD_FUNC_ARG;
     2203    }
     2204
     2205    if (priv) {
     2206        privSz = mp_unsigned_bin_size(&key->priv);
     2207        if (privSz > *pPrivSz) {
     2208            return BUFFER_E;
     2209        }
     2210        *pPrivSz = privSz;
     2211        ret |= mp_to_unsigned_bin(&key->priv, priv);
     2212    }
     2213
     2214    if (pub) {
     2215        pubSz = mp_unsigned_bin_size(&key->pub);
     2216        if (pubSz > *pPubSz) {
     2217            return BUFFER_E;
     2218        }
     2219        *pPubSz = pubSz;
     2220        ret |= mp_to_unsigned_bin(&key->pub,  pub);
     2221    }
     2222
     2223    if (ret != 0)
     2224        ret = ASN_DH_KEY_E;
     2225    return ret;
     2226}
     2227
     2228#endif /* WOLFSSL_DH_EXTRA */
    21382229
    21392230static int _DhSetKey(DhKey* key, const byte* p, word32 pSz, const byte* g,
    … …  
    23682459    if (ret == 0) {
    23692460        /* at this point tmp generates a group of order q mod p */
     2461#ifndef USE_FAST_MATH
     2462        /* Exchanging is quick when the data pointer can be copied. */
    23702463        mp_exch(&tmp, &dh->g);
     2464#else
     2465        mp_copy(&tmp, &dh->g);
     2466#endif
    23712467    }
    23722468
Note: See TracChangeset for help on using the changeset viewer.