From fc2bfc1f4911c6b5310d51f3b7b3d0dcaa4f93f5 Mon Sep 17 00:00:00 2001 From: Wu Jian Gang Date: Fri, 2 Sep 2016 11:31:38 +0800 Subject: [PATCH] mbedtls: just format related files method from !46 --- components/esp32/aes.c | 359 ++++++++++--------- components/esp32/esp_crypto.c | 50 +-- components/esp32/include/aes.h | 61 ++-- components/esp32/include/esp_crypto.h | 54 +-- components/esp32/include/sha.h | 10 +- components/esp32/sha.c | 96 ++--- components/mbedtls/port/esp_hardware.c | 38 +- components/mbedtls/port/include/aes_alt.h | 26 +- components/mbedtls/port/include/bignum_alt.h | 90 ++--- components/mbedtls/port/include/sha1_alt.h | 20 +- components/mbedtls/port/include/sha256_alt.h | 20 +- components/mbedtls/port/include/sha512_alt.h | 22 +- components/mbedtls/port/net.c | 296 +++++++-------- 13 files changed, 584 insertions(+), 558 deletions(-) diff --git a/components/esp32/aes.c b/components/esp32/aes.c index bcc4eb2fdb..e22c08a371 100644 --- a/components/esp32/aes.c +++ b/components/esp32/aes.c @@ -39,100 +39,112 @@ void esp_aes_init( AES_CTX *ctx ) AES_LOCK(); AES_TAKE(); - ets_aes_enable(); - AES_UNLOCK(); + ets_aes_enable(); + AES_UNLOCK(); } void esp_aes_free( AES_CTX *ctx ) { - if( ctx == NULL ) + if ( ctx == NULL ) { return; + } bzero( ctx, sizeof( AES_CTX ) ); AES_LOCK(); AES_GIVE(); - if (false == AES_IS_USED()) - ets_aes_disable(); - AES_UNLOCK(); + + if (false == AES_IS_USED()) { + ets_aes_disable(); + } + + AES_UNLOCK(); } /* * AES key schedule (encryption) */ int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key, - unsigned int keybits ) + unsigned int keybits ) { - enum AES_BITS keybit; - uint16_t keybyte = keybits / 8; - switch (keybits){ - case 128: - keybit = AES128; - break; - case 192: - keybit = AES192; - break; - case 256: - keybit = AES256; - break; - default : return( ERR_AES_INVALID_KEY_LENGTH ); - } - if (ctx->enc.keyflag == false){ - ctx->enc.keyflag = true; - ctx->enc.keybits = keybits; - memset(ctx->enc.key, 0, sizeof(ctx->enc.key)); - memcpy(ctx->enc.key, key, keybyte); - } else { - ets_aes_setkey_enc(key, keybit); - } - return 0; + enum AES_BITS keybit; + uint16_t keybyte = keybits / 8; + + switch (keybits) { + case 128: + keybit = AES128; + break; + case 192: + keybit = AES192; + break; + case 256: + keybit = AES256; + break; + default: + return ( ERR_AES_INVALID_KEY_LENGTH ); + } + + if (ctx->enc.keyflag == false) { + ctx->enc.keyflag = true; + ctx->enc.keybits = keybits; + memset(ctx->enc.key, 0, sizeof(ctx->enc.key)); + memcpy(ctx->enc.key, key, keybyte); + } else { + ets_aes_setkey_enc(key, keybit); + } + + return 0; } /* * AES key schedule (decryption) */ int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key, - unsigned int keybits ) + unsigned int keybits ) { - enum AES_BITS keybit; - uint16_t keybyte = keybits / 8; - switch (keybits){ - case 128: - keybit = AES128; - break; - case 192: - keybit = AES192; - break; - case 256: - keybit = AES256; - break; - default : return( ERR_AES_INVALID_KEY_LENGTH ); - } - if (ctx->dec.keyflag == false){ - ctx->dec.keyflag = true; - ctx->dec.keybits = keybits; - memset(ctx->dec.key, 0, sizeof(ctx->dec.key)); - memcpy(ctx->dec.key, key, keybyte); - } else { - ets_aes_setkey_dec(key, keybit); - } - return 0; + enum AES_BITS keybit; + uint16_t keybyte = keybits / 8; + + switch (keybits) { + case 128: + keybit = AES128; + break; + case 192: + keybit = AES192; + break; + case 256: + keybit = AES256; + break; + default: + return ( ERR_AES_INVALID_KEY_LENGTH ); + } + + if (ctx->dec.keyflag == false) { + ctx->dec.keyflag = true; + ctx->dec.keybits = keybits; + memset(ctx->dec.key, 0, sizeof(ctx->dec.key)); + memcpy(ctx->dec.key, key, keybyte); + } else { + ets_aes_setkey_dec(key, keybit); + } + return 0; } static void esp_aes_process_enable(AES_CTX *ctx, int mode) { - if( mode == AES_ENCRYPT ){ - esp_aes_setkey_enc(ctx, ctx->enc.key, ctx->enc.keybits); - }else{ - esp_aes_setkey_dec(ctx, ctx->dec.key, ctx->dec.keybits); - } - return; + if ( mode == AES_ENCRYPT ) { + esp_aes_setkey_enc(ctx, ctx->enc.key, ctx->enc.keybits); + } else { + esp_aes_setkey_dec(ctx, ctx->dec.key, ctx->dec.keybits); + } + + return; } static void esp_aes_process_disable(AES_CTX *ctx, int mode) { - + } /* @@ -140,11 +152,12 @@ static void esp_aes_process_disable(AES_CTX *ctx, int mode) */ void esp_aes_encrypt( AES_CTX *ctx, - const unsigned char input[16], - unsigned char output[16] ) + const unsigned char input[16], + unsigned char output[16] ) { - ets_aes_crypt(input, output); - return ; + ets_aes_crypt(input, output); + + return ; } @@ -153,11 +166,12 @@ void esp_aes_encrypt( AES_CTX *ctx, */ void esp_aes_decrypt( AES_CTX *ctx, - const unsigned char input[16], - unsigned char output[16] ) + const unsigned char input[16], + unsigned char output[16] ) { - ets_aes_crypt(input, output); - return ; + ets_aes_crypt(input, output); + + return ; } @@ -165,24 +179,25 @@ void esp_aes_decrypt( AES_CTX *ctx, * AES-ECB block encryption/decryption */ int esp_aes_crypt_ecb( AES_CTX *ctx, - int mode, - const unsigned char input[16], - unsigned char output[16] ) + int mode, + const unsigned char input[16], + unsigned char output[16] ) { - AES_LOCK(); - - esp_aes_process_enable(ctx, mode); + AES_LOCK(); + + esp_aes_process_enable(ctx, mode); - if( mode == AES_ENCRYPT ) + if ( mode == AES_ENCRYPT ) { esp_aes_encrypt( ctx, input, output ); - else + } else { esp_aes_decrypt( ctx, input, output ); + } + + esp_aes_process_disable(ctx, mode); - esp_aes_process_disable(ctx, mode); - - AES_UNLOCK(); - - return 0; + AES_UNLOCK(); + + return 0; } @@ -190,27 +205,27 @@ int esp_aes_crypt_ecb( AES_CTX *ctx, * AES-CBC buffer encryption/decryption */ int esp_aes_crypt_cbc( AES_CTX *ctx, - int mode, - size_t length, - unsigned char iv[16], - const unsigned char *input, - unsigned char *output ) + int mode, + size_t length, + unsigned char iv[16], + const unsigned char *input, + unsigned char *output ) { - int i; + int i; unsigned char temp[16]; - if( length % 16 ) - return( ERR_AES_INVALID_INPUT_LENGTH ); + if ( length % 16 ) { + return ( ERR_AES_INVALID_INPUT_LENGTH ); + } - if( mode == AES_DECRYPT ) - { - while( length > 0 ) - { + if ( mode == AES_DECRYPT ) { + while ( length > 0 ) { memcpy( temp, input, 16 ); esp_aes_crypt_ecb( ctx, mode, input, output ); - for( i = 0; i < 16; i++ ) + for ( i = 0; i < 16; i++ ) { output[i] = (unsigned char)( output[i] ^ iv[i] ); + } memcpy( iv, temp, 16 ); @@ -218,13 +233,11 @@ int esp_aes_crypt_cbc( AES_CTX *ctx, output += 16; length -= 16; } - } - else - { - while( length > 0 ) - { - for( i = 0; i < 16; i++ ) + } else { + while ( length > 0 ) { + for ( i = 0; i < 16; i++ ) { output[i] = (unsigned char)( input[i] ^ iv[i] ); + } esp_aes_crypt_ecb( ctx, mode, output, output ); memcpy( iv, output, 16 ); @@ -235,85 +248,83 @@ int esp_aes_crypt_cbc( AES_CTX *ctx, } } - return 0; + return 0; } /* * AES-CFB128 buffer encryption/decryption */ int esp_aes_crypt_cfb128( AES_CTX *ctx, - int mode, - size_t length, - size_t *iv_off, - unsigned char iv[16], - const unsigned char *input, - unsigned char *output ) + int mode, + size_t length, + size_t *iv_off, + unsigned char iv[16], + const unsigned char *input, + unsigned char *output ) { - int c; - size_t n = *iv_off; - - if( mode == AES_DECRYPT ) - { - while( length-- ) - { - if( n == 0 ) - esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); - - c = *input++; - *output++ = (unsigned char)( c ^ iv[n] ); - iv[n] = (unsigned char) c; - - n = ( n + 1 ) & 0x0F; - } - } - else - { - while( length-- ) - { - if( n == 0 ) - esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); - - iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ ); - - n = ( n + 1 ) & 0x0F; - } - } - - *iv_off = n; - - return 0; + int c; + size_t n = *iv_off; + + if ( mode == AES_DECRYPT ) { + while ( length-- ) { + if ( n == 0 ) { + esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); + } + + c = *input++; + *output++ = (unsigned char)( c ^ iv[n] ); + iv[n] = (unsigned char) c; + + n = ( n + 1 ) & 0x0F; + } + } else { + while ( length-- ) { + if ( n == 0 ) { + esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); + } + + iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ ); + + n = ( n + 1 ) & 0x0F; + } + } + + *iv_off = n; + + return 0; } /* * AES-CFB8 buffer encryption/decryption */ int esp_aes_crypt_cfb8( AES_CTX *ctx, - int mode, - size_t length, - unsigned char iv[16], - const unsigned char *input, - unsigned char *output ) + int mode, + size_t length, + unsigned char iv[16], + const unsigned char *input, + unsigned char *output ) { - unsigned char c; - unsigned char ov[17]; - - while( length-- ) - { - memcpy( ov, iv, 16 ); - esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); - - if( mode == AES_DECRYPT ) - ov[16] = *input; - - c = *output++ = (unsigned char)( iv[0] ^ *input++ ); - - if( mode == AES_ENCRYPT ) - ov[16] = c; - - memcpy( iv, ov + 1, 16 ); - } - - return 0; + unsigned char c; + unsigned char ov[17]; + + while ( length-- ) { + memcpy( ov, iv, 16 ); + esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); + + if ( mode == AES_DECRYPT ) { + ov[16] = *input; + } + + c = *output++ = (unsigned char)( iv[0] ^ *input++ ); + + if ( mode == AES_ENCRYPT ) { + ov[16] = c; + } + + memcpy( iv, ov + 1, 16 ); + } + + return 0; } /* @@ -326,18 +337,18 @@ int esp_aes_crypt_ctr( AES_CTX *ctx, unsigned char stream_block[16], const unsigned char *input, unsigned char *output ) -{ - int c, i; +{ + int c, i; size_t n = *nc_off; - while( length-- ) - { - if( n == 0 ) { + while ( length-- ) { + if ( n == 0 ) { esp_aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block ); - for( i = 16; i > 0; i-- ) - if( ++nonce_counter[i - 1] != 0 ) + for ( i = 16; i > 0; i-- ) + if ( ++nonce_counter[i - 1] != 0 ) { break; + } } c = *input++; *output++ = (unsigned char)( c ^ stream_block[n] ); @@ -347,6 +358,6 @@ int esp_aes_crypt_ctr( AES_CTX *ctx, *nc_off = n; - return 0; + return 0; } diff --git a/components/esp32/esp_crypto.c b/components/esp32/esp_crypto.c index f0e2cdcb13..0a5cd2f472 100644 --- a/components/esp32/esp_crypto.c +++ b/components/esp32/esp_crypto.c @@ -6,59 +6,61 @@ static SemaphoreHandle_t esp_crypto_mutex[MUTEX_MAX_NUM]; static int esp_crypto_sig[MUTEX_MAX_NUM]; #if 0 - #define ESP_DEBUG ets_printf +#define ESP_DEBUG ets_printf #else - #define ESP_DEBUG(...) +#define ESP_DEBUG(...) #endif int esp_crypto_init(void) { - int i; + int i; - for (i = 0; i < MUTEX_MAX_NUM; i++) { - esp_crypto_mutex[i] = xSemaphoreCreateMutex(); - ESP_DEBUG("init num %d mutex %p\n", i, esp_crypto_mutex[i]); - if (!esp_crypto_mutex[i]) { - goto failed1; - } - esp_crypto_sig[i] = 0; - } + for (i = 0; i < MUTEX_MAX_NUM; i++) { + esp_crypto_mutex[i] = xSemaphoreCreateMutex(); + ESP_DEBUG("init num %d mutex %p\n", i, esp_crypto_mutex[i]); + if (!esp_crypto_mutex[i]) { + goto failed1; + } + esp_crypto_sig[i] = 0; + } - return 0; + return 0; failed1: - ESP_DEBUG("esp_crypto_init failed\n"); - for (i--; i >= 0; i--) - vQueueDelete(esp_crypto_mutex[i]); + ESP_DEBUG("esp_crypto_init failed\n"); + for (i--; i >= 0; i--) { + vQueueDelete(esp_crypto_mutex[i]); + } - return -1; + return -1; } void esp_crypto_lock(unsigned int num) { - ESP_DEBUG("1num %d, mutex %p\n", num, esp_crypto_mutex[num]); - xSemaphoreTake(esp_crypto_mutex[num], portMAX_DELAY); + ESP_DEBUG("1num %d, mutex %p\n", num, esp_crypto_mutex[num]); + xSemaphoreTake(esp_crypto_mutex[num], portMAX_DELAY); } void esp_crypto_unlock(unsigned int num) { - ESP_DEBUG("2num %d, mutex %p\n", num, esp_crypto_mutex[num]); - xSemaphoreGive(esp_crypto_mutex[num]); + ESP_DEBUG("2num %d, mutex %p\n", num, esp_crypto_mutex[num]); + xSemaphoreGive(esp_crypto_mutex[num]); } void esp_crypto_take(unsigned int num) { - esp_crypto_sig[num]++; + esp_crypto_sig[num]++; } void esp_crypto_give(unsigned int num) { - if (esp_crypto_sig[num]) - esp_crypto_sig[num]--; + if (esp_crypto_sig[num]) { + esp_crypto_sig[num]--; + } } bool esp_crypto_is_used(unsigned int num) { - return (esp_crypto_sig[num] != 0) ? true : false; + return (esp_crypto_sig[num] != 0) ? true : false; } diff --git a/components/esp32/include/aes.h b/components/esp32/include/aes.h index c3409cbaf1..76ea47c556 100644 --- a/components/esp32/include/aes.h +++ b/components/esp32/include/aes.h @@ -18,9 +18,9 @@ * See the License for the specific language governing permissions and * limitations under the License. * - * + * */ - + #ifndef ESP_AES_H #define ESP_AES_H @@ -39,11 +39,11 @@ extern "C" { #define ERR_AES_INVALID_KEY_LENGTH -0x0020 /**< Invalid key length. */ #define ERR_AES_INVALID_INPUT_LENGTH -0x0022 /**< Invalid data input length. */ -typedef struct{ - bool keyflag; - uint16_t keybits; +typedef struct { + bool keyflag; + uint16_t keybits; uint8_t key[32]; -}key_context, KEY_CTX; +} key_context, KEY_CTX; /** * \brief AES context structure @@ -53,13 +53,12 @@ typedef struct{ * - to simplify key expansion in the 256-bit case by * generating an extra round key */ -typedef struct -{ +typedef struct { int nr; /*!< number of rounds */ uint32_t *rk; /*!< AES round keys */ - KEY_CTX enc; - KEY_CTX dec; -}aes_context, AES_CTX; + KEY_CTX enc; + KEY_CTX dec; +} aes_context, AES_CTX; /** * \brief Initialize AES context @@ -84,7 +83,7 @@ void esp_aes_free( AES_CTX *ctx ); * * \return 0 if successful, or ERR_AES_INVALID_KEY_LENGTH */ -int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key,unsigned int keybits ); +int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key, unsigned int keybits ); /** * \brief AES key schedule (decryption) @@ -95,7 +94,7 @@ int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key,unsigned int keyb * * \return 0 if successful, or ERR_AES_INVALID_KEY_LENGTH */ -int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key,unsigned int keybits ); +int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key, unsigned int keybits ); /** * \brief AES-ECB block encryption/decryption @@ -107,7 +106,7 @@ int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key,unsigned int keyb * * \return 0 if successful */ -int esp_aes_crypt_ecb( AES_CTX *ctx,int mode,const unsigned char input[16],unsigned char output[16] ); +int esp_aes_crypt_ecb( AES_CTX *ctx, int mode, const unsigned char input[16], unsigned char output[16] ); /** * \brief AES-CBC buffer encryption/decryption @@ -132,11 +131,11 @@ int esp_aes_crypt_ecb( AES_CTX *ctx,int mode,const unsigned char input[16],unsig * \return 0 if successful, or ERR_AES_INVALID_INPUT_LENGTH */ int esp_aes_crypt_cbc( AES_CTX *ctx, - int mode, - size_t length, - unsigned char iv[16], - const unsigned char *input, - unsigned char *output ); + int mode, + size_t length, + unsigned char iv[16], + const unsigned char *input, + unsigned char *output ); /** @@ -165,12 +164,12 @@ int esp_aes_crypt_cbc( AES_CTX *ctx, * \return 0 if successful */ int esp_aes_crypt_cfb128( AES_CTX *ctx, - int mode, - size_t length, - size_t *iv_off, - unsigned char iv[16], - const unsigned char *input, - unsigned char *output ); + int mode, + size_t length, + size_t *iv_off, + unsigned char iv[16], + const unsigned char *input, + unsigned char *output ); /** * \brief AES-CFB8 buffer encryption/decryption. @@ -197,11 +196,11 @@ int esp_aes_crypt_cfb128( AES_CTX *ctx, * \return 0 if successful */ int esp_aes_crypt_cfb8( AES_CTX *ctx, - int mode, - size_t length, - unsigned char iv[16], - const unsigned char *input, - unsigned char *output ); + int mode, + size_t length, + unsigned char iv[16], + const unsigned char *input, + unsigned char *output ); /** * \brief AES-CTR buffer encryption/decryption @@ -243,7 +242,7 @@ int esp_aes_crypt_ctr( AES_CTX *ctx, * \param input Plaintext block * \param output Output (ciphertext) block */ -void esp_aes_encrypt( AES_CTX *ctx, const unsigned char input[16],unsigned char output[16] ); +void esp_aes_encrypt( AES_CTX *ctx, const unsigned char input[16], unsigned char output[16] ); /** * \brief Internal AES block decryption function diff --git a/components/esp32/include/esp_crypto.h b/components/esp32/include/esp_crypto.h index 5accfe8382..bac07ceac0 100644 --- a/components/esp32/include/esp_crypto.h +++ b/components/esp32/include/esp_crypto.h @@ -9,11 +9,11 @@ extern "C" { #endif enum { - AES_MUTEX = 0, - BIGNUM_MUTEX, - SHA_MUTEX, + AES_MUTEX = 0, + BIGNUM_MUTEX, + SHA_MUTEX, - MUTEX_MAX_NUM, + MUTEX_MAX_NUM, }; int esp_crypto_init(void); @@ -25,29 +25,29 @@ void esp_crypto_take(unsigned int num); void esp_crypto_give(unsigned int num); bool esp_crypto_is_used(unsigned int num); -#define MUTEX_LOCK(num) esp_crypto_lock(num) -#define MUTEX_UNLOCK(num) esp_crypto_unlock(num) - -#define SIG_TAKE(num) esp_crypto_take(num) -#define SIG_GIVE(num) esp_crypto_give(num) -#define SIG_IS_USED(num) esp_crypto_is_used(num) - -#define AES_LOCK() MUTEX_LOCK(AES_MUTEX) -#define AES_UNLOCK() MUTEX_UNLOCK(AES_MUTEX) -#define BIGNUM_LOCK() MUTEX_LOCK(BIGNUM_MUTEX) -#define BIGNUM_UNLOCK() MUTEX_UNLOCK(BIGNUM_MUTEX) -#define SHA_LOCK() MUTEX_LOCK(SHA_MUTEX) -#define SHA_UNLOCK() MUTEX_UNLOCK(SHA_MUTEX) - -#define AES_TAKE() SIG_TAKE(AES_MUTEX) -#define AES_GIVE() SIG_GIVE(AES_MUTEX) -#define AES_IS_USED() SIG_IS_USED(AES_MUTEX) -#define BIGNUM_TAKE() SIG_TAKE(BIGNUM_MUTEX) -#define BIGNUM_GIVE() SIG_GIVE(BIGNUM_MUTEX) -#define BIGNUM_IS_USED() SIG_IS_USED(BIGNUM_MUTEX) -#define SHA_TAKE() SIG_TAKE(SHA_MUTEX) -#define SHA_GIVE() SIG_GIVE(SHA_MUTEX) -#define SHA_IS_USED() SIG_IS_USED(SHA_MUTEX) +#define MUTEX_LOCK(num) esp_crypto_lock(num) +#define MUTEX_UNLOCK(num) esp_crypto_unlock(num) + +#define SIG_TAKE(num) esp_crypto_take(num) +#define SIG_GIVE(num) esp_crypto_give(num) +#define SIG_IS_USED(num) esp_crypto_is_used(num) + +#define AES_LOCK() MUTEX_LOCK(AES_MUTEX) +#define AES_UNLOCK() MUTEX_UNLOCK(AES_MUTEX) +#define BIGNUM_LOCK() MUTEX_LOCK(BIGNUM_MUTEX) +#define BIGNUM_UNLOCK() MUTEX_UNLOCK(BIGNUM_MUTEX) +#define SHA_LOCK() MUTEX_LOCK(SHA_MUTEX) +#define SHA_UNLOCK() MUTEX_UNLOCK(SHA_MUTEX) + +#define AES_TAKE() SIG_TAKE(AES_MUTEX) +#define AES_GIVE() SIG_GIVE(AES_MUTEX) +#define AES_IS_USED() SIG_IS_USED(AES_MUTEX) +#define BIGNUM_TAKE() SIG_TAKE(BIGNUM_MUTEX) +#define BIGNUM_GIVE() SIG_GIVE(BIGNUM_MUTEX) +#define BIGNUM_IS_USED() SIG_IS_USED(BIGNUM_MUTEX) +#define SHA_TAKE() SIG_TAKE(SHA_MUTEX) +#define SHA_GIVE() SIG_GIVE(SHA_MUTEX) +#define SHA_IS_USED() SIG_IS_USED(SHA_MUTEX) #ifdef __cplusplus } diff --git a/components/esp32/include/sha.h b/components/esp32/include/sha.h index 93aed46e80..2ee667cf71 100644 --- a/components/esp32/include/sha.h +++ b/components/esp32/include/sha.h @@ -26,9 +26,9 @@ extern "C" { /** * \brief SHA-1 context structure */ -typedef struct{ - SHA_CTX context; - int context_type; +typedef struct { + SHA_CTX context; + int context_type; } sha_context; typedef sha_context SHA1_CTX; @@ -91,8 +91,8 @@ void esp_sha1_finish( SHA1_CTX *ctx, unsigned char output[20] ); void esp_sha1_output( const unsigned char *input, size_t ilen, unsigned char output[20] ); /// -#define SHA256 SHA2_256 -#define SHA224 4 +#define SHA256 SHA2_256 +#define SHA224 4 /** * \brief SHA-256 context structure diff --git a/components/esp32/sha.c b/components/esp32/sha.c index 1a09ab7b56..cc850f0845 100644 --- a/components/esp32/sha.c +++ b/components/esp32/sha.c @@ -38,22 +38,26 @@ void esp_sha1_init( SHA1_CTX *ctx ) SHA_LOCK(); SHA_TAKE(); - ets_sha_enable(); - SHA_UNLOCK(); + ets_sha_enable(); + SHA_UNLOCK(); } void esp_sha1_free( SHA1_CTX *ctx ) { - if( ctx == NULL ) + if ( ctx == NULL ) { return; + } bzero( ctx, sizeof( SHA1_CTX ) ); SHA_LOCK(); SHA_GIVE(); - if (false == SHA_IS_USED()) - ets_sha_disable(); - SHA_UNLOCK(); + + if (false == SHA_IS_USED()) { + ets_sha_disable(); + } + + SHA_UNLOCK(); } void esp_sha1_clone( SHA1_CTX *dst, const SHA1_CTX *src ) @@ -71,10 +75,10 @@ void esp_sha1_process(SHA1_CTX *ctx, const unsigned char data[64]) */ void esp_sha1_start( SHA1_CTX *ctx ) { - SHA_LOCK(); - ets_sha_init(&ctx->context); + SHA_LOCK(); + ets_sha_init(&ctx->context); - ctx->context_type = SHA1; + ctx->context_type = SHA1; } /* @@ -82,7 +86,7 @@ void esp_sha1_start( SHA1_CTX *ctx ) */ void esp_sha1_update( SHA1_CTX *ctx, const unsigned char *input, size_t ilen ) { - ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8); + ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8); } /* @@ -90,8 +94,8 @@ void esp_sha1_update( SHA1_CTX *ctx, const unsigned char *input, size_t ilen ) */ void esp_sha1_finish( SHA1_CTX *ctx, unsigned char output[20] ) { - ets_sha_finish(&ctx->context, ctx->context_type, output); - SHA_UNLOCK(); + ets_sha_finish(&ctx->context, ctx->context_type, output); + SHA_UNLOCK(); } /* @@ -116,8 +120,8 @@ void esp_sha256_init( SHA256_CTX *ctx ) SHA_LOCK(); SHA_TAKE(); - ets_sha_enable(); - SHA_UNLOCK(); + ets_sha_enable(); + SHA_UNLOCK(); } void esp_sha256_process(SHA256_CTX *ctx, const unsigned char data[64]) @@ -127,16 +131,20 @@ void esp_sha256_process(SHA256_CTX *ctx, const unsigned char data[64]) void esp_sha256_free( SHA256_CTX *ctx ) { - if( ctx == NULL ) + if ( ctx == NULL ) { return; + } bzero( ctx, sizeof( SHA256_CTX ) ); SHA_LOCK(); SHA_GIVE(); - if (false == SHA_IS_USED()) - ets_sha_disable(); - SHA_UNLOCK(); + + if (false == SHA_IS_USED()) { + ets_sha_disable(); + } + + SHA_UNLOCK(); } void esp_sha256_clone( SHA256_CTX *dst, const SHA256_CTX *src ) @@ -149,17 +157,16 @@ void esp_sha256_clone( SHA256_CTX *dst, const SHA256_CTX *src ) */ void esp_sha256_start( SHA256_CTX *ctx, int is224 ) { - SHA_LOCK(); + SHA_LOCK(); ets_sha_init(&ctx->context); - if( is224 == 0 ) - { + if ( is224 == 0 ) { /* SHA-256 */ - ctx->context_type = SHA256; - }else{ - /* SHA-224 */ - ctx->context_type = SHA224; - } + ctx->context_type = SHA256; + } else { + /* SHA-224 */ + ctx->context_type = SHA224; + } } /* @@ -167,7 +174,7 @@ void esp_sha256_start( SHA256_CTX *ctx, int is224 ) */ void esp_sha256_update( SHA256_CTX *ctx, const unsigned char *input, size_t ilen ) { - ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8); + ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8); } /* @@ -175,8 +182,8 @@ void esp_sha256_update( SHA256_CTX *ctx, const unsigned char *input, size_t ilen */ void esp_sha256_finish( SHA256_CTX *ctx, unsigned char output[32] ) { - ets_sha_finish(&ctx->context, ctx->context_type, output); - SHA_UNLOCK(); + ets_sha_finish(&ctx->context, ctx->context_type, output); + SHA_UNLOCK(); } /* @@ -201,8 +208,8 @@ void esp_sha512_init( SHA512_CTX *ctx ) SHA_LOCK(); SHA_TAKE(); - ets_sha_enable(); - SHA_UNLOCK(); + ets_sha_enable(); + SHA_UNLOCK(); } void esp_sha512_process( SHA512_CTX *ctx, const unsigned char data[128] ) @@ -212,16 +219,20 @@ void esp_sha512_process( SHA512_CTX *ctx, const unsigned char data[128] ) void esp_sha512_free( SHA512_CTX *ctx ) { - if( ctx == NULL ) + if ( ctx == NULL ) { return; + } bzero( ctx, sizeof( SHA512_CTX ) ); SHA_LOCK(); SHA_GIVE(); - if (false == SHA_IS_USED()) - ets_sha_disable(); - SHA_UNLOCK(); + + if (false == SHA_IS_USED()) { + ets_sha_disable(); + } + + SHA_UNLOCK(); } void esp_sha512_clone( SHA512_CTX *dst, const SHA512_CTX *src ) @@ -234,16 +245,13 @@ void esp_sha512_clone( SHA512_CTX *dst, const SHA512_CTX *src ) */ void esp_sha512_start( SHA512_CTX *ctx, int is384 ) { - SHA_LOCK(); - ets_sha_init(&ctx->context); + SHA_LOCK(); + ets_sha_init(&ctx->context); - if( is384 == 0 ) - { + if ( is384 == 0 ) { /* SHA-512 */ ctx->context_type = SHA2_512; - } - else - { + } else { /* SHA-384 */ ctx->context_type = SHA2_384; } @@ -252,7 +260,7 @@ void esp_sha512_start( SHA512_CTX *ctx, int is384 ) /* * SHA-512 process buffer */ -void esp_sha512_update( SHA512_CTX *ctx, const unsigned char *input,size_t ilen ) +void esp_sha512_update( SHA512_CTX *ctx, const unsigned char *input, size_t ilen ) { ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8); } @@ -269,7 +277,7 @@ void esp_sha512_finish( SHA512_CTX *ctx, unsigned char output[64] ) /* * output = SHA-512( input buffer ) */ -void esp_sha512_output( const unsigned char *input, size_t ilen,unsigned char output[64], int is384 ) +void esp_sha512_output( const unsigned char *input, size_t ilen, unsigned char output[64], int is384 ) { SHA512_CTX ctx; diff --git a/components/mbedtls/port/esp_hardware.c b/components/mbedtls/port/esp_hardware.c index c269a0e3f1..b83c4d7aa9 100644 --- a/components/mbedtls/port/esp_hardware.c +++ b/components/mbedtls/port/esp_hardware.c @@ -7,6 +7,7 @@ #include #include #include + #if defined(MBEDTLS_ENTROPY_HARDWARE_ALT) /** * \brief Entropy poll callback for a hardware source @@ -18,28 +19,31 @@ */ static int os_get_random(unsigned char *buf, size_t len) { - int i, j; - unsigned long tmp; - for (i = 0; i < ((len + 3) & ~3) / 4; i ++){ - tmp = rand(); - for (j = 0; j < 4; j ++){ - if ((i * 4 + j) < len){ - buf[i * 4 + j] = (unsigned char)(tmp >> (j * 8)); - }else{ - break; - } - } - - } - return 0; + int i, j; + unsigned long tmp; + + for (i = 0; i < ((len + 3) & ~3) / 4; i ++) { + tmp = rand(); + for (j = 0; j < 4; j ++) { + if ((i * 4 + j) < len) { + buf[i * 4 + j] = (unsigned char)(tmp >> (j * 8)); + } else { + break; + } + } + + } + + return 0; } int mbedtls_hardware_poll( void *data, unsigned char *output, size_t len, size_t *olen ) { - os_get_random(output, len); - *olen = len; - return 0; + os_get_random(output, len); + *olen = len; + + return 0; } #endif diff --git a/components/mbedtls/port/include/aes_alt.h b/components/mbedtls/port/include/aes_alt.h index 90e659483c..daf30d72b8 100644 --- a/components/mbedtls/port/include/aes_alt.h +++ b/components/mbedtls/port/include/aes_alt.h @@ -18,9 +18,9 @@ * See the License for the specific language governing permissions and * limitations under the License. * - * + * */ - + #ifndef AES_ALT_H #define AES_ALT_H @@ -33,23 +33,23 @@ extern "C" { typedef AES_CTX mbedtls_aes_context; -#define mbedtls_aes_init esp_aes_init -#define mbedtls_aes_free esp_aes_free -#define mbedtls_aes_setkey_enc esp_aes_setkey_enc -#define mbedtls_aes_setkey_dec esp_aes_setkey_dec -#define mbedtls_aes_crypt_ecb esp_aes_crypt_ecb +#define mbedtls_aes_init esp_aes_init +#define mbedtls_aes_free esp_aes_free +#define mbedtls_aes_setkey_enc esp_aes_setkey_enc +#define mbedtls_aes_setkey_dec esp_aes_setkey_dec +#define mbedtls_aes_crypt_ecb esp_aes_crypt_ecb #if defined(MBEDTLS_CIPHER_MODE_CBC) -#define mbedtls_aes_crypt_cbc esp_aes_crypt_cbc +#define mbedtls_aes_crypt_cbc esp_aes_crypt_cbc #endif #if defined(MBEDTLS_CIPHER_MODE_CFB) -#define mbedtls_aes_crypt_cfb128 esp_aes_crypt_cfb128 -#define mbedtls_aes_crypt_cfb8 esp_aes_crypt_cfb8 +#define mbedtls_aes_crypt_cfb128 esp_aes_crypt_cfb128 +#define mbedtls_aes_crypt_cfb8 esp_aes_crypt_cfb8 #endif #if defined(MBEDTLS_CIPHER_MODE_CTR) -#define mbedtls_aes_crypt_ctr esp_aes_crypt_ctr +#define mbedtls_aes_crypt_ctr esp_aes_crypt_ctr #endif -#define mbedtls_aes_encrypt esp_aes_encrypt -#define mbedtls_aes_decrypt esp_aes_decrypt +#define mbedtls_aes_encrypt esp_aes_encrypt +#define mbedtls_aes_decrypt esp_aes_decrypt #endif /* MBEDTLS_AES_ALT */ #ifdef __cplusplus diff --git a/components/mbedtls/port/include/bignum_alt.h b/components/mbedtls/port/include/bignum_alt.h index a4ac0db3ef..f30d7d25cd 100644 --- a/components/mbedtls/port/include/bignum_alt.h +++ b/components/mbedtls/port/include/bignum_alt.h @@ -19,7 +19,7 @@ * limitations under the License. * */ - + #ifndef BIGNUM_ALT_H #define BIGNUM_ALT_H @@ -27,50 +27,50 @@ #if defined(MBEDTLS_BIGNUM_ALT) -typedef MPI_CTX mbedtls_mpi; - -#define mbedtls_mpi_init esp_mpi_init -#define mbedtls_mpi_free esp_mpi_free -#define mbedtls_mpi_grow esp_mpi_grow -#define mbedtls_mpi_shrink esp_mpi_shrink -#define mbedtls_mpi_copy esp_mpi_copy -#define mbedtls_mpi_swap esp_mpi_swap -#define mbedtls_mpi_safe_cond_assign esp_mpi_safe_cond_assign -#define mbedtls_mpi_safe_cond_swap esp_mpi_safe_cond_swap -#define mbedtls_mpi_lset esp_mpi_lset -#define mbedtls_mpi_get_bit esp_mpi_get_bit -#define mbedtls_mpi_set_bit esp_mpi_set_bit -#define mbedtls_mpi_lsb esp_mpi_lsb -#define mbedtls_mpi_bitlen esp_mpi_bitlen -#define mbedtls_mpi_size esp_mpi_size -#define mbedtls_mpi_read_string esp_mpi_read_string -#define mbedtls_mpi_write_string esp_mpi_write_string -#define mbedtls_mpi_read_binary esp_mpi_read_binary -#define mbedtls_mpi_write_binary esp_mpi_write_binary -#define mbedtls_mpi_shift_l esp_mpi_shift_l -#define mbedtls_mpi_shift_r esp_mpi_shift_r -#define mbedtls_mpi_cmp_abs esp_mpi_cmp_abs -#define mbedtls_mpi_cmp_mpi esp_mpi_cmp_mpi -#define mbedtls_mpi_cmp_int esp_mpi_cmp_int -#define mbedtls_mpi_add_abs esp_mpi_add_abs -#define mbedtls_mpi_sub_abs esp_mpi_sub_abs -#define mbedtls_mpi_add_mpi esp_mpi_add_mpi -#define mbedtls_mpi_sub_mpi esp_mpi_sub_mpi -#define mbedtls_mpi_add_int esp_mpi_add_int -#define mbedtls_mpi_sub_int esp_mpi_sub_int -#define mbedtls_mpi_mul_mpi esp_mpi_mul_mpi -#define mbedtls_mpi_mul_int esp_mpi_mul_int -#define mbedtls_mpi_div_mpi esp_mpi_div_mpi -#define mbedtls_mpi_div_int esp_mpi_div_int -#define mbedtls_mpi_mod_mpi esp_mpi_mod_mpi -#define mbedtls_mpi_mod_int esp_mpi_mod_int -#define mbedtls_mpi_exp_mod esp_mpi_exp_mod -#define mbedtls_mpi_fill_random esp_mpi_fill_random -#define mbedtls_mpi_gcd esp_mpi_gcd -#define mbedtls_mpi_inv_mod esp_mpi_inv_mod -#define mbedtls_mpi_is_prime esp_mpi_is_prime -#define mbedtls_mpi_gen_prime esp_mpi_gen_prime - +typedef MPI_CTX mbedtls_mpi; + +#define mbedtls_mpi_init esp_mpi_init +#define mbedtls_mpi_free esp_mpi_free +#define mbedtls_mpi_grow esp_mpi_grow +#define mbedtls_mpi_shrink esp_mpi_shrink +#define mbedtls_mpi_copy esp_mpi_copy +#define mbedtls_mpi_swap esp_mpi_swap +#define mbedtls_mpi_safe_cond_assign esp_mpi_safe_cond_assign +#define mbedtls_mpi_safe_cond_swap esp_mpi_safe_cond_swap +#define mbedtls_mpi_lset esp_mpi_lset +#define mbedtls_mpi_get_bit esp_mpi_get_bit +#define mbedtls_mpi_set_bit esp_mpi_set_bit +#define mbedtls_mpi_lsb esp_mpi_lsb +#define mbedtls_mpi_bitlen esp_mpi_bitlen +#define mbedtls_mpi_size esp_mpi_size +#define mbedtls_mpi_read_string esp_mpi_read_string +#define mbedtls_mpi_write_string esp_mpi_write_string +#define mbedtls_mpi_read_binary esp_mpi_read_binary +#define mbedtls_mpi_write_binary esp_mpi_write_binary +#define mbedtls_mpi_shift_l esp_mpi_shift_l +#define mbedtls_mpi_shift_r esp_mpi_shift_r +#define mbedtls_mpi_cmp_abs esp_mpi_cmp_abs +#define mbedtls_mpi_cmp_mpi esp_mpi_cmp_mpi +#define mbedtls_mpi_cmp_int esp_mpi_cmp_int +#define mbedtls_mpi_add_abs esp_mpi_add_abs +#define mbedtls_mpi_sub_abs esp_mpi_sub_abs +#define mbedtls_mpi_add_mpi esp_mpi_add_mpi +#define mbedtls_mpi_sub_mpi esp_mpi_sub_mpi +#define mbedtls_mpi_add_int esp_mpi_add_int +#define mbedtls_mpi_sub_int esp_mpi_sub_int +#define mbedtls_mpi_mul_mpi esp_mpi_mul_mpi +#define mbedtls_mpi_mul_int esp_mpi_mul_int +#define mbedtls_mpi_div_mpi esp_mpi_div_mpi +#define mbedtls_mpi_div_int esp_mpi_div_int +#define mbedtls_mpi_mod_mpi esp_mpi_mod_mpi +#define mbedtls_mpi_mod_int esp_mpi_mod_int +#define mbedtls_mpi_exp_mod esp_mpi_exp_mod +#define mbedtls_mpi_fill_random esp_mpi_fill_random +#define mbedtls_mpi_gcd esp_mpi_gcd +#define mbedtls_mpi_inv_mod esp_mpi_inv_mod +#define mbedtls_mpi_is_prime esp_mpi_is_prime +#define mbedtls_mpi_gen_prime esp_mpi_gen_prime + #endif #endif diff --git a/components/mbedtls/port/include/sha1_alt.h b/components/mbedtls/port/include/sha1_alt.h index 98cbf5b625..3cf39d2ffb 100644 --- a/components/mbedtls/port/include/sha1_alt.h +++ b/components/mbedtls/port/include/sha1_alt.h @@ -1,6 +1,6 @@ -/* - * copyright (c) 2010 - 2012 Espressif System - * +/* + * copyright (c) 2010 - 2012 Espressif System + * * esf Link List Descriptor */ #ifndef _SHA1_ALT_H_ @@ -16,13 +16,13 @@ extern "C" { typedef SHA1_CTX mbedtls_sha1_context; -#define mbedtls_sha1_init esp_sha1_init -#define mbedtls_sha1_starts esp_sha1_start -#define mbedtls_sha1_clone esp_sha1_clone -#define mbedtls_sha1_update esp_sha1_update -#define mbedtls_sha1_finish esp_sha1_finish -#define mbedtls_sha1_free esp_sha1_free -#define mbedtls_sha1_process esp_sha1_process +#define mbedtls_sha1_init esp_sha1_init +#define mbedtls_sha1_starts esp_sha1_start +#define mbedtls_sha1_clone esp_sha1_clone +#define mbedtls_sha1_update esp_sha1_update +#define mbedtls_sha1_finish esp_sha1_finish +#define mbedtls_sha1_free esp_sha1_free +#define mbedtls_sha1_process esp_sha1_process #endif diff --git a/components/mbedtls/port/include/sha256_alt.h b/components/mbedtls/port/include/sha256_alt.h index e8585e9768..15ea356acb 100644 --- a/components/mbedtls/port/include/sha256_alt.h +++ b/components/mbedtls/port/include/sha256_alt.h @@ -1,6 +1,6 @@ -/* - * copyright (c) 2010 - 2012 Espressif System - * +/* + * copyright (c) 2010 - 2012 Espressif System + * * esf Link List Descriptor */ @@ -17,13 +17,13 @@ extern "C" { typedef SHA256_CTX mbedtls_sha256_context; -#define mbedtls_sha256_init esp_sha256_init -#define mbedtls_sha256_clone esp_sha256_clone -#define mbedtls_sha256_starts esp_sha256_start -#define mbedtls_sha256_update esp_sha256_update -#define mbedtls_sha256_finish esp_sha256_finish -#define mbedtls_sha256_free esp_sha256_free -#define mbedtls_sha256_process esp_sha256_process +#define mbedtls_sha256_init esp_sha256_init +#define mbedtls_sha256_clone esp_sha256_clone +#define mbedtls_sha256_starts esp_sha256_start +#define mbedtls_sha256_update esp_sha256_update +#define mbedtls_sha256_finish esp_sha256_finish +#define mbedtls_sha256_free esp_sha256_free +#define mbedtls_sha256_process esp_sha256_process #endif diff --git a/components/mbedtls/port/include/sha512_alt.h b/components/mbedtls/port/include/sha512_alt.h index 117660dcde..9e337c1b60 100644 --- a/components/mbedtls/port/include/sha512_alt.h +++ b/components/mbedtls/port/include/sha512_alt.h @@ -1,6 +1,6 @@ -/* - * copyright (c) 2010 - 2012 Espressif System - * +/* + * copyright (c) 2010 - 2012 Espressif System + * * esf Link List Descriptor */ @@ -14,15 +14,15 @@ extern "C" { #if defined(MBEDTLS_SHA512_ALT) #include "sha.h" -typedef SHA512_CTX mbedtls_sha512_context; +typedef SHA512_CTX mbedtls_sha512_context; -#define mbedtls_sha512_init esp_sha512_init -#define mbedtls_sha512_process esp_sha512_process -#define mbedtls_sha512_clone esp_sha512_clone -#define mbedtls_sha512_starts esp_sha512_start -#define mbedtls_sha512_update esp_sha512_update -#define mbedtls_sha512_finish esp_sha512_finish -#define mbedtls_sha512_free esp_sha512_free +#define mbedtls_sha512_init esp_sha512_init +#define mbedtls_sha512_process esp_sha512_process +#define mbedtls_sha512_clone esp_sha512_clone +#define mbedtls_sha512_starts esp_sha512_start +#define mbedtls_sha512_update esp_sha512_update +#define mbedtls_sha512_finish esp_sha512_finish +#define mbedtls_sha512_free esp_sha512_free #endif diff --git a/components/mbedtls/port/net.c b/components/mbedtls/port/net.c index 61162a78e2..390513c17e 100644 --- a/components/mbedtls/port/net.c +++ b/components/mbedtls/port/net.c @@ -56,24 +56,26 @@ static int net_prepare( void ) !defined(EFI32) WSADATA wsaData; - if( wsa_init_done == 0 ) - { - if( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 ) - return( MBEDTLS_ERR_NET_SOCKET_FAILED ); + if ( wsa_init_done == 0 ) { + if ( WSAStartup( MAKEWORD(2, 0), &wsaData ) != 0 ) { + return ( MBEDTLS_ERR_NET_SOCKET_FAILED ); + } wsa_init_done = 1; } #else #endif - return( 0 ); + return ( 0 ); } static int mbedtls_net_errno(int fd) { - int sock_errno = 0; - u32_t optlen = sizeof(sock_errno); - getsockopt(fd, SOL_SOCKET, SO_ERROR, &sock_errno, &optlen); - return sock_errno; + int sock_errno = 0; + u32_t optlen = sizeof(sock_errno); + + getsockopt(fd, SOL_SOCKET, SO_ERROR, &sock_errno, &optlen); + + return sock_errno; } /* @@ -92,8 +94,9 @@ int mbedtls_net_connect( mbedtls_net_context *ctx, const char *host, const char int ret; struct addrinfo hints, *addr_list, *cur; - if( ( ret = net_prepare() ) != 0 ) - return( ret ); + if ( ( ret = net_prepare() ) != 0 ) { + return ( ret ); + } /* Do name resolution with both IPv6 and IPv4 */ memset( &hints, 0, sizeof( hints ) ); @@ -101,23 +104,21 @@ int mbedtls_net_connect( mbedtls_net_context *ctx, const char *host, const char hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM; hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP; - if( getaddrinfo( host, port, &hints, &addr_list ) != 0 ) - return( MBEDTLS_ERR_NET_UNKNOWN_HOST ); + if ( getaddrinfo( host, port, &hints, &addr_list ) != 0 ) { + return ( MBEDTLS_ERR_NET_UNKNOWN_HOST ); + } /* Try the sockaddrs until a connection succeeds */ ret = MBEDTLS_ERR_NET_UNKNOWN_HOST; - for( cur = addr_list; cur != NULL; cur = cur->ai_next ) - { + for ( cur = addr_list; cur != NULL; cur = cur->ai_next ) { ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype, - cur->ai_protocol ); - if( ctx->fd < 0 ) - { + cur->ai_protocol ); + if ( ctx->fd < 0 ) { ret = MBEDTLS_ERR_NET_SOCKET_FAILED; continue; } - if( connect( ctx->fd, cur->ai_addr, cur->ai_addrlen ) == 0 ) - { + if ( connect( ctx->fd, cur->ai_addr, cur->ai_addrlen ) == 0 ) { ret = 0; break; } @@ -128,7 +129,7 @@ int mbedtls_net_connect( mbedtls_net_context *ctx, const char *host, const char freeaddrinfo( addr_list ); - return( ret ); + return ( ret ); } /* @@ -139,8 +140,9 @@ int mbedtls_net_bind( mbedtls_net_context *ctx, const char *bind_ip, const char int n, ret; struct addrinfo hints, *addr_list, *cur; - if( ( ret = net_prepare() ) != 0 ) - return( ret ); + if ( ( ret = net_prepare() ) != 0 ) { + return ( ret ); + } /* Bind to IPv6 and/or IPv4, but only in the desired protocol */ memset( &hints, 0, sizeof( hints ) ); @@ -148,48 +150,43 @@ int mbedtls_net_bind( mbedtls_net_context *ctx, const char *bind_ip, const char hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM; hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP; - if( getaddrinfo( bind_ip, port, &hints, &addr_list ) != 0 ) - return( MBEDTLS_ERR_NET_UNKNOWN_HOST ); + if ( getaddrinfo( bind_ip, port, &hints, &addr_list ) != 0 ) { + return ( MBEDTLS_ERR_NET_UNKNOWN_HOST ); + } /* Try the sockaddrs until a binding succeeds */ ret = MBEDTLS_ERR_NET_UNKNOWN_HOST; - for( cur = addr_list; cur != NULL; cur = cur->ai_next ) - { + for ( cur = addr_list; cur != NULL; cur = cur->ai_next ) { ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype, - cur->ai_protocol ); - if( ctx->fd < 0 ) - { + cur->ai_protocol ); + if ( ctx->fd < 0 ) { ret = MBEDTLS_ERR_NET_SOCKET_FAILED; continue; } - /*SO_REUSEADDR option dafault is disable in source code(lwip)*/ + /*SO_REUSEADDR option dafault is disable in source code(lwip)*/ #if SO_REUSE n = 1; - if( setsockopt( ctx->fd, SOL_SOCKET, SO_REUSEADDR, - (const char *) &n, sizeof( n ) ) != 0 ) - { + if ( setsockopt( ctx->fd, SOL_SOCKET, SO_REUSEADDR, + (const char *) &n, sizeof( n ) ) != 0 ) { close( ctx->fd ); ret = MBEDTLS_ERR_NET_SOCKET_FAILED; continue; } #endif - /*bind interface dafault don't process the addr is 0xffffffff for TCP Protocol*/ - struct sockaddr_in *serv_addr = NULL; - serv_addr = (struct sockaddr_in *)cur->ai_addr; - serv_addr->sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */ - if( bind( ctx->fd, (struct sockaddr *)serv_addr, cur->ai_addrlen ) != 0 ) - { + /*bind interface dafault don't process the addr is 0xffffffff for TCP Protocol*/ + struct sockaddr_in *serv_addr = NULL; + serv_addr = (struct sockaddr_in *)cur->ai_addr; + serv_addr->sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */ + if ( bind( ctx->fd, (struct sockaddr *)serv_addr, cur->ai_addrlen ) != 0 ) { close( ctx->fd ); ret = MBEDTLS_ERR_NET_BIND_FAILED; continue; } /* Listen only makes sense for TCP */ - if( proto == MBEDTLS_NET_PROTO_TCP ) - { - if( listen( ctx->fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 ) - { + if ( proto == MBEDTLS_NET_PROTO_TCP ) { + if ( listen( ctx->fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 ) { close( ctx->fd ); ret = MBEDTLS_ERR_NET_LISTEN_FAILED; continue; @@ -203,7 +200,7 @@ int mbedtls_net_bind( mbedtls_net_context *ctx, const char *bind_ip, const char freeaddrinfo( addr_list ); - return( ret ); + return ( ret ); } @@ -216,7 +213,7 @@ int mbedtls_net_bind( mbedtls_net_context *ctx, const char *bind_ip, const char static int net_would_block( const mbedtls_net_context *ctx ) { ((void) ctx); - return( WSAGetLastError() == WSAEWOULDBLOCK ); + return ( WSAGetLastError() == WSAEWOULDBLOCK ); } #else /* @@ -230,22 +227,22 @@ static int net_would_block( const mbedtls_net_context *ctx ) /* * Never return 'WOULD BLOCK' on a non-blocking socket */ - if( ( fcntl( ctx->fd, F_GETFL, 0) & O_NONBLOCK ) != O_NONBLOCK ) - return( 0 ); + if ( ( fcntl( ctx->fd, F_GETFL, 0) & O_NONBLOCK ) != O_NONBLOCK ) { + return ( 0 ); + } - int error = mbedtls_net_errno(ctx->fd); - - switch( error ) - { + int error = mbedtls_net_errno(ctx->fd); + + switch ( error ) { #if defined EAGAIN - case EAGAIN: + case EAGAIN: #endif #if defined EWOULDBLOCK && EWOULDBLOCK != EAGAIN - case EWOULDBLOCK: + case EWOULDBLOCK: #endif - return( 1 ); + return ( 1 ); } - return( 0 ); + return ( 0 ); } #endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */ @@ -265,21 +262,17 @@ int mbedtls_net_accept( mbedtls_net_context *bind_ctx, socklen_t type_len = (socklen_t) sizeof( type ); /* Is this a TCP or UDP socket? */ - if( getsockopt( bind_ctx->fd, SOL_SOCKET, SO_TYPE, - (void *) &type, (socklen_t *) &type_len ) != 0 || - ( type != SOCK_STREAM && type != SOCK_DGRAM ) ) - { - return( MBEDTLS_ERR_NET_ACCEPT_FAILED ); + if ( getsockopt( bind_ctx->fd, SOL_SOCKET, SO_TYPE, + (void *) &type, (socklen_t *) &type_len ) != 0 || + ( type != SOCK_STREAM && type != SOCK_DGRAM ) ) { + return ( MBEDTLS_ERR_NET_ACCEPT_FAILED ); } - if( type == SOCK_STREAM ) - { + if ( type == SOCK_STREAM ) { /* TCP: actual accept() */ ret = client_ctx->fd = (int) accept( bind_ctx->fd, (struct sockaddr *) &client_addr, &n ); - } - else - { + } else { /* UDP: wait for a message, but keep it in the queue */ char buf[1] = { 0 }; @@ -287,65 +280,62 @@ int mbedtls_net_accept( mbedtls_net_context *bind_ctx, (struct sockaddr *) &client_addr, &n ); #if defined(_WIN32) - if( ret == SOCKET_ERROR && - WSAGetLastError() == WSAEMSGSIZE ) - { + if ( ret == SOCKET_ERROR && + WSAGetLastError() == WSAEMSGSIZE ) { /* We know buf is too small, thanks, just peeking here */ ret = 0; } #endif } - if( ret < 0 ) - { - if( net_would_block( bind_ctx ) != 0 ) - return( MBEDTLS_ERR_SSL_WANT_READ ); + if ( ret < 0 ) { + if ( net_would_block( bind_ctx ) != 0 ) { + return ( MBEDTLS_ERR_SSL_WANT_READ ); + } - return( MBEDTLS_ERR_NET_ACCEPT_FAILED ); + return ( MBEDTLS_ERR_NET_ACCEPT_FAILED ); } /* UDP: hijack the listening socket to communicate with the client, * then bind a new socket to accept new connections */ - if( type != SOCK_STREAM ) - { + if ( type != SOCK_STREAM ) { struct sockaddr_in local_addr; int one = 1; - if( connect( bind_ctx->fd, (struct sockaddr *) &client_addr, n ) != 0 ) - return( MBEDTLS_ERR_NET_ACCEPT_FAILED ); + if ( connect( bind_ctx->fd, (struct sockaddr *) &client_addr, n ) != 0 ) { + return ( MBEDTLS_ERR_NET_ACCEPT_FAILED ); + } client_ctx->fd = bind_ctx->fd; bind_ctx->fd = -1; /* In case we exit early */ n = sizeof( struct sockaddr_in ); - if( getsockname( client_ctx->fd, - (struct sockaddr *) &local_addr, &n ) != 0 || - ( bind_ctx->fd = (int) socket( AF_INET, - SOCK_DGRAM, IPPROTO_UDP ) ) < 0 || - setsockopt( bind_ctx->fd, SOL_SOCKET, SO_REUSEADDR, - (const char *) &one, sizeof( one ) ) != 0 ) - { - return( MBEDTLS_ERR_NET_SOCKET_FAILED ); + if ( getsockname( client_ctx->fd, + (struct sockaddr *) &local_addr, &n ) != 0 || + ( bind_ctx->fd = (int) socket( AF_INET, + SOCK_DGRAM, IPPROTO_UDP ) ) < 0 || + setsockopt( bind_ctx->fd, SOL_SOCKET, SO_REUSEADDR, + (const char *) &one, sizeof( one ) ) != 0 ) { + return ( MBEDTLS_ERR_NET_SOCKET_FAILED ); } - if( bind( bind_ctx->fd, (struct sockaddr *) &local_addr, n ) != 0 ) - { - return( MBEDTLS_ERR_NET_BIND_FAILED ); + if ( bind( bind_ctx->fd, (struct sockaddr *) &local_addr, n ) != 0 ) { + return ( MBEDTLS_ERR_NET_BIND_FAILED ); } } - if( client_ip != NULL ) - { - struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr; - *ip_len = sizeof( addr4->sin_addr.s_addr ); + if ( client_ip != NULL ) { + struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr; + *ip_len = sizeof( addr4->sin_addr.s_addr ); - if( buf_size < *ip_len ) - return( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL ); + if ( buf_size < *ip_len ) { + return ( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL ); + } - memcpy( client_ip, &addr4->sin_addr.s_addr, *ip_len ); + memcpy( client_ip, &addr4->sin_addr.s_addr, *ip_len ); } - return( 0 ); + return ( 0 ); } /* @@ -356,9 +346,9 @@ int mbedtls_net_set_block( mbedtls_net_context *ctx ) #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) u_long n = 0; - return( ioctlsocket( ctx->fd, FIONBIO, &n ) ); + return ( ioctlsocket( ctx->fd, FIONBIO, &n ) ); #else - return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) & ~O_NONBLOCK ) ); + return ( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) & ~O_NONBLOCK ) ); #endif } @@ -367,9 +357,9 @@ int mbedtls_net_set_nonblock( mbedtls_net_context *ctx ) #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) u_long n = 1; - return( ioctlsocket( ctx->fd, FIONBIO, &n ) ); + return ( ioctlsocket( ctx->fd, FIONBIO, &n ) ); #else - return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) | O_NONBLOCK ) ); + return ( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) | O_NONBLOCK ) ); #endif } @@ -401,49 +391,54 @@ int mbedtls_net_recv( void *ctx, unsigned char *buf, size_t len ) int ret; int fd = ((mbedtls_net_context *) ctx)->fd; int error = 0; - - if( fd < 0 ) - return( MBEDTLS_ERR_NET_INVALID_CONTEXT ); + + if ( fd < 0 ) { + return ( MBEDTLS_ERR_NET_INVALID_CONTEXT ); + } ret = (int) read( fd, buf, len ); - if( ret < 0 ) - { - if( net_would_block( ctx ) != 0 ) - return( MBEDTLS_ERR_SSL_WANT_READ ); + if ( ret < 0 ) { + if ( net_would_block( ctx ) != 0 ) { + return ( MBEDTLS_ERR_SSL_WANT_READ ); + } - error = mbedtls_net_errno(fd); + error = mbedtls_net_errno(fd); #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) - if( WSAGetLastError() == WSAECONNRESET ) - return( MBEDTLS_ERR_NET_CONN_RESET ); + if ( WSAGetLastError() == WSAECONNRESET ) { + return ( MBEDTLS_ERR_NET_CONN_RESET ); + } #else - if( error == EPIPE || error == ECONNRESET ) - return( MBEDTLS_ERR_NET_CONN_RESET ); + if ( error == EPIPE || error == ECONNRESET ) { + return ( MBEDTLS_ERR_NET_CONN_RESET ); + } - if( error == EINTR ) - return( MBEDTLS_ERR_SSL_WANT_READ ); + if ( error == EINTR ) { + return ( MBEDTLS_ERR_SSL_WANT_READ ); + } #endif - return( MBEDTLS_ERR_NET_RECV_FAILED ); + return ( MBEDTLS_ERR_NET_RECV_FAILED ); } - return( ret ); + return ( ret ); } /* * Read at most 'len' characters, blocking for at most 'timeout' ms */ int mbedtls_net_recv_timeout( void *ctx, unsigned char *buf, size_t len, - uint32_t timeout ) + uint32_t timeout ) { int ret; struct timeval tv; fd_set read_fds; int fd = ((mbedtls_net_context *) ctx)->fd; - if( fd < 0 ) - return( MBEDTLS_ERR_NET_INVALID_CONTEXT ); + if ( fd < 0 ) { + return ( MBEDTLS_ERR_NET_INVALID_CONTEXT ); + } FD_ZERO( &read_fds ); FD_SET( fd, &read_fds ); @@ -454,25 +449,27 @@ int mbedtls_net_recv_timeout( void *ctx, unsigned char *buf, size_t len, ret = select( fd + 1, &read_fds, NULL, NULL, timeout == 0 ? NULL : &tv ); /* Zero fds ready means we timed out */ - if( ret == 0 ) - return( MBEDTLS_ERR_SSL_TIMEOUT ); + if ( ret == 0 ) { + return ( MBEDTLS_ERR_SSL_TIMEOUT ); + } - if( ret < 0 ) - { + if ( ret < 0 ) { #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) - if( WSAGetLastError() == WSAEINTR ) - return( MBEDTLS_ERR_SSL_WANT_READ ); + if ( WSAGetLastError() == WSAEINTR ) { + return ( MBEDTLS_ERR_SSL_WANT_READ ); + } #else - if( errno == EINTR ) - return( MBEDTLS_ERR_SSL_WANT_READ ); + if ( errno == EINTR ) { + return ( MBEDTLS_ERR_SSL_WANT_READ ); + } #endif - return( MBEDTLS_ERR_NET_RECV_FAILED ); + return ( MBEDTLS_ERR_NET_RECV_FAILED ); } /* This call will not block */ - return( mbedtls_net_recv( ctx, buf, len ) ); + return ( mbedtls_net_recv( ctx, buf, len ) ); } /* @@ -483,35 +480,39 @@ int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len ) int ret; int fd = ((mbedtls_net_context *) ctx)->fd; - int error = 0; + int error = 0; - if( fd < 0 ) - return( MBEDTLS_ERR_NET_INVALID_CONTEXT ); + if ( fd < 0 ) { + return ( MBEDTLS_ERR_NET_INVALID_CONTEXT ); + } ret = (int) write( fd, buf, len ); - if( ret < 0 ) - { - if( net_would_block( ctx ) != 0 ) - return( MBEDTLS_ERR_SSL_WANT_WRITE ); + if ( ret < 0 ) { + if ( net_would_block( ctx ) != 0 ) { + return ( MBEDTLS_ERR_SSL_WANT_WRITE ); + } - error = mbedtls_net_errno(fd); + error = mbedtls_net_errno(fd); #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) - if( WSAGetLastError() == WSAECONNRESET ) - return( MBEDTLS_ERR_NET_CONN_RESET ); + if ( WSAGetLastError() == WSAECONNRESET ) { + return ( MBEDTLS_ERR_NET_CONN_RESET ); + } #else - if( error == EPIPE || error == ECONNRESET ) - return( MBEDTLS_ERR_NET_CONN_RESET ); + if ( error == EPIPE || error == ECONNRESET ) { + return ( MBEDTLS_ERR_NET_CONN_RESET ); + } - if( error == EINTR ) - return( MBEDTLS_ERR_SSL_WANT_WRITE ); + if ( error == EINTR ) { + return ( MBEDTLS_ERR_SSL_WANT_WRITE ); + } #endif - return( MBEDTLS_ERR_NET_SEND_FAILED ); + return ( MBEDTLS_ERR_NET_SEND_FAILED ); } - return( ret ); + return ( ret ); } /* @@ -519,8 +520,9 @@ int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len ) */ void mbedtls_net_free( mbedtls_net_context *ctx ) { - if( ctx->fd == -1 ) + if ( ctx->fd == -1 ) { return; + } shutdown( ctx->fd, 2 ); close( ctx->fd ); -- 2.40.0