mirrors
/
wolfssl
mirror of https://github.com/wolfSSL/wolfssl
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fusion RTOS porting round 3

This commit is contained in:
kaleb-himes 2021-02-08 18:05:22 -07:00
parent dda4c3b3c4
commit 6d23728a56
16 changed files with 1187 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
IDE/VisualDSP++/include.am Normal file
View File

@ -0,0 +1,6 @@
# vim:ft=automake
# included from Top Level Makefile.am
# All paths should be given relative to the root
EXTRA_DIST+= IDE/VisualDSP++/user_settings.h
EXTRA_DIST+= IDE/VisualDSP++/wolf-tasks.c

752
IDE/VisualDSP++/user_settings.h Normal file
View File

@ -0,0 +1,752 @@
/* user_settings.h
*
* Copyright (C) 2006-2021 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
/* Custom wolfSSL user settings for FIPS VALIDATION START */
#ifndef WOLFSSL_USER_SETTINGS_H
#define WOLFSSL_USER_SETTINGS_H
#ifdef __cplusplus
extern "C" {
#endif
#include "fusioncfg.h"
/* ------------------------------------------------------------------------- */
/* Platform */
/* ------------------------------------------------------------------------- */
#undef WOLFSSL_GENERAL_ALIGNMENT
#define WOLFSSL_GENERAL_ALIGNMENT 4
#undef SINGLE_THREADED
#define SINGLE_THREADED
#undef WOLFSSL_SMALL_STACK
//#define WOLFSSL_SMALL_STACK
#undef WOLFSSL_USER_IO
// #define WOLFSSL_USER_IO
#define HAVE_PKCS8
/* ------------------------------------------------------------------------- */
/* Math Configuration */
/* ------------------------------------------------------------------------- */
#undef SIZEOF_LONG_LONG
#define SIZEOF_LONG_LONG 8
#undef USE_FAST_MATH
#if 1
#define USE_FAST_MATH
#undef TFM_TIMING_RESISTANT
#define TFM_TIMING_RESISTANT
/* Optimizations */
//#define TFM_ARM
#endif
/* Wolf Single Precision Math */
#undef WOLFSSL_SP
#if 0
#define WOLFSSL_SP
//#define WOLFSSL_SP_SMALL /* use smaller version of code */
#define WOLFSSL_HAVE_SP_RSA
#define WOLFSSL_HAVE_SP_DH
#define WOLFSSL_HAVE_SP_ECC
#define WOLFSSL_SP_CACHE_RESISTANT
//#define WOLFSSL_SP_MATH /* only SP math - eliminates fast math code */
/* 64 or 32 bit version */
//#define WOLFSSL_SP_ASM /* required if using the ASM versions */
//#define WOLFSSL_SP_ARM32_ASM
//#define WOLFSSL_SP_ARM64_ASM
#endif
/* ------------------------------------------------------------------------- */
/* FIPS - Requires eval or license from wolfSSL */
/* ------------------------------------------------------------------------- */
#undef HAVE_FIPS
#if 1
#define HAVE_FIPS
#undef HAVE_FIPS_VERSION
#define HAVE_FIPS_VERSION 2
#ifdef SINGLE_THREADED
#undef NO_THREAD_LS
#define NO_THREAD_LS
#endif
#endif
/* ------------------------------------------------------------------------- */
/* Crypto */
/* ------------------------------------------------------------------------- */
/* RSA */
#undef NO_RSA
#if 1
#ifdef USE_FAST_MATH
/* Maximum math bits (Max RSA key bits * 2) */
#undef FP_MAX_BITS
#define FP_MAX_BITS 8192
#endif
/* half as much memory but twice as slow */
#undef RSA_LOW_MEM
//#define RSA_LOW_MEM
/* Enables blinding mode, to prevent timing attacks */
#if 1
#undef WC_RSA_BLINDING
#define WC_RSA_BLINDING
#else
#undef WC_NO_HARDEN
#define WC_NO_HARDEN
#endif
/* RSA PSS Support */
#if 1
#define WC_RSA_PSS
#endif
#if 1
#define WC_RSA_NO_PADDING
#endif
#else
#define NO_RSA
#endif
/* ECC */
#undef HAVE_ECC
#if 1
#define HAVE_ECC
/* Manually define enabled curves */
#undef ECC_USER_CURVES
//#define ECC_USER_CURVES
#ifdef ECC_USER_CURVES
/* Manual Curve Selection */
//#define HAVE_ECC192
//#define HAVE_ECC224
#undef NO_ECC256
//#define HAVE_ECC384
//#define HAVE_ECC521
#endif
/* Fixed point cache (speeds repeated operations against same private key) */
#undef FP_ECC
//#define FP_ECC
#ifdef FP_ECC
/* Bits / Entries */
#undef FP_ENTRIES
#define FP_ENTRIES 2
#undef FP_LUT
#define FP_LUT 4
#endif
/* Optional ECC calculation method */
/* Note: doubles heap usage, but slightly faster */
#undef ECC_SHAMIR
#define ECC_SHAMIR
/* Reduces heap usage, but slower */
#undef ECC_TIMING_RESISTANT
#define ECC_TIMING_RESISTANT
/* Enable cofactor support */
#ifdef HAVE_FIPS
#undef HAVE_ECC_CDH
#define HAVE_ECC_CDH
#define NO_STRICT_ECDSA_LEN
#endif
/* Validate import */
#ifdef HAVE_FIPS
#undef WOLFSSL_VALIDATE_ECC_IMPORT
#define WOLFSSL_VALIDATE_ECC_IMPORT
#endif
/* Compressed Key Support */
#undef HAVE_COMP_KEY
//#define HAVE_COMP_KEY
/* Use alternate ECC size for ECC math */
#ifdef USE_FAST_MATH
#ifdef NO_RSA
/* Custom fastmath size if not using RSA */
/* MAX = ROUND32(ECC BITS 256) + SIZE_OF_MP_DIGIT(32) */
#undef FP_MAX_BITS
#define FP_MAX_BITS (256 + 32)
#else
#undef ALT_ECC_SIZE
#define ALT_ECC_SIZE
#endif
/* Speedups specific to curve */
#ifndef NO_ECC256
#undef TFM_ECC256
#define TFM_ECC256
#endif
#endif
#endif
/* DH */
#undef NO_DH
#if 1
/* Use table for DH instead of -lm (math) lib dependency */
#if 0
#define WOLFSSL_DH_CONST
#define HAVE_FFDHE_2048
#define HAVE_FFDHE_4096
#define HAVE_DH_DEFAULT_PARAMS
//#define HAVE_FFDHE_6144
//#define HAVE_FFDHE_8192
#endif
#ifdef HAVE_FIPS
#define WOLFSSL_VALIDATE_FFC_IMPORT
#define HAVE_FFDHE_Q
#endif
#else
#define NO_DH
#endif
/* AES */
#undef NO_AES
#if 1
#undef HAVE_AES_CBC
#define HAVE_AES_CBC
#undef HAVE_AESGCM
#define HAVE_AESGCM
/* GCM Method: GCM_SMALL, GCM_WORD32 or GCM_TABLE */
#define GCM_SMALL
#undef WOLFSSL_AES_DIRECT
#define WOLFSSL_AES_DIRECT
#undef HAVE_AES_ECB
#define HAVE_AES_ECB
#undef WOLFSSL_AES_COUNTER
#define WOLFSSL_AES_COUNTER
#undef HAVE_AESCCM
#define HAVE_AESCCM
#else
#define NO_AES
#endif
/* DES3 */
#undef NO_DES3
#if 1
#else
#define NO_DES3
#endif
/* ChaCha20 / Poly1305 */
#undef HAVE_CHACHA
#undef HAVE_POLY1305
#if 0
#define HAVE_CHACHA
#define HAVE_POLY1305
/* Needed for Poly1305 */
#undef HAVE_ONE_TIME_AUTH
#define HAVE_ONE_TIME_AUTH
#endif
/* Ed25519 / Curve25519 */
#undef HAVE_CURVE25519
#undef HAVE_ED25519
#if 0
#define HAVE_CURVE25519
#define HAVE_ED25519 /* ED25519 Requires SHA512 */
/* Optionally use small math (less flash usage, but much slower) */
#if 1
#define CURVED25519_SMALL
#endif
#endif
/* ------------------------------------------------------------------------- */
/* Hashing */
/* ------------------------------------------------------------------------- */
/* Sha */
#undef NO_SHA
#if 1
/* 1k smaller, but 25% slower */
//#define USE_SLOW_SHA
#else
#define NO_SHA
#endif
/* Sha256 */
#undef NO_SHA256
#if 1
/* not unrolled - ~2k smaller and ~25% slower */
//#define USE_SLOW_SHA256
/* Sha224 */
#if 1
#define WOLFSSL_SHA224
#endif
#else
#define NO_SHA256
#endif
/* Sha512 */
#undef WOLFSSL_SHA512
#if 1
#define WOLFSSL_SHA512
/* Sha384 */
#undef WOLFSSL_SHA384
#if 1
#define WOLFSSL_SHA384
#endif
/* over twice as small, but 50% slower */
//#define USE_SLOW_SHA512
#endif
/* Sha3 */
#undef WOLFSSL_SHA3
#if 1
#define WOLFSSL_SHA3
#ifdef HAVE_FIPS
#define WOLFSSL_NO_SHAKE256
#endif
#endif
/* MD5 */
#undef NO_MD5
#if 1
#else
#define NO_MD5
#endif
/* HKDF */
#undef HAVE_HKDF
#if 1
#define HAVE_HKDF
#endif
/* CMAC */
#undef WOLFSSL_CMAC
#if 1
#define WOLFSSL_CMAC
#endif
/* ------------------------------------------------------------------------- */
/* Benchmark / Test */
/* ------------------------------------------------------------------------- */
/* Use reduced benchmark / test sizes */
#undef BENCH_EMBEDDED
#define BENCH_EMBEDDED
#undef USE_CERT_BUFFERS_2048
//#define USE_CERT_BUFFERS_2048
//#undef USE_CERT_BUFFERS_1024
//#define USE_CERT_BUFFERS_1024
#undef USE_CERT_BUFFERS_256
//#define USE_CERT_BUFFERS_256
/* ------------------------------------------------------------------------- */
/* Debugging */
/* ------------------------------------------------------------------------- */
#undef DEBUG_WOLFSSL
#undef NO_ERROR_STRINGS
#if 1 //for debug wolfssl_init.
#define DEBUG_WOLFSSL
#else
#if 0
#define NO_ERROR_STRINGS
#endif
#endif
/* ------------------------------------------------------------------------- */
/* Memory */
/* ------------------------------------------------------------------------- */
/* Override Memory API's */
#if 1
#undef XMALLOC_OVERRIDE
#define XMALLOC_OVERRIDE
#include <fclstdlib.h>
#define XMALLOC(n, h, t) FCL_MALLOC(n)
#define XFREE(p, h, t) FCL_FREE(p)
#define XREALLOC(p, n, h, t) FCL_REALLOC(p, n)
#define XATOI(s) FCL_ATOI(s)
#endif
#if 0
/* Static memory requires fast math */
#define WOLFSSL_STATIC_MEMORY
/* Disable fallback malloc/free */
#define WOLFSSL_NO_MALLOC
#if 0
#define WOLFSSL_MALLOC_CHECK /* trap malloc failure */
#endif
#endif
/* Memory callbacks */
#if 0
#undef USE_WOLFSSL_MEMORY
#define USE_WOLFSSL_MEMORY
/* Use this to measure / print heap usage */
#if 0
#undef WOLFSSL_TRACK_MEMORY
#define WOLFSSL_TRACK_MEMORY
#undef WOLFSSL_DEBUG_MEMORY
#define WOLFSSL_DEBUG_MEMORY
#endif
#else
#ifndef WOLFSSL_STATIC_MEMORY
#define NO_WOLFSSL_MEMORY
/* Otherwise we will use stdlib malloc, free and realloc */
#endif
#endif
/* ------------------------------------------------------------------------- */
/* Port */
/* ------------------------------------------------------------------------- */
/* Override Current Time */
/* Allows custom "custom_time()" function to be used for benchmark */
//#define WOLFSSL_USER_CURRTIME
//#define WOLFSSL_GMTIME
//#define USER_TICKS
//extern unsigned long my_time(unsigned long* timer);
//#define XTIME my_time
#if 1
#include "fcltime.h"
#define time_t fclTime_t
#define USER_TIME
time_t fclTime( time_t* tod );
#define XTIME fclTime
#define XCTIME fclCtime
#define HAVE_TIME_T_TYPE
#endif
/* ------------------------------------------------------------------------- */
/* RNG */
/* ------------------------------------------------------------------------- */
/* Seed Source */
/* Size of returned HW RNG value */
#if 0
#define CUSTOM_RAND_TYPE unsigned int
extern unsigned int my_rng_seed_gen(void);
#undef CUSTOM_RAND_GENERATE
#define CUSTOM_RAND_GENERATE my_rng_seed_gen
#endif
/* Choose RNG method */
#if 1
/* Use built-in P-RNG (SHA256 based) with HW RNG */
/* P-RNG + HW RNG (P-RNG is ~8K) */
#undef HAVE_HASHDRBG
#define HAVE_HASHDRBG
#else
#undef WC_NO_HASHDRBG
#define WC_NO_HASHDRBG
/* Bypass P-RNG and use only HW RNG */
extern int my_rng_gen_block(unsigned char* output, unsigned int sz);
#undef CUSTOM_RAND_GENERATE_BLOCK
#define CUSTOM_RAND_GENERATE_BLOCK my_rng_gen_block
#endif
/* ------------------------------------------------------------------------- */
/* Custom Standard Lib */
/* ------------------------------------------------------------------------- */
/* Allows override of all standard library functions */
#undef STRING_USER
#if 1
#define STRING_USER
#include <fclstring.h>
#undef USE_WOLF_STRSEP
#define USE_WOLF_STRSEP
#define XSTRSEP(s1,d) wc_strsep((s1),(d))
#undef USE_WOLF_STRTOK
#define USE_WOLF_STRTOK
#define XSTRTOK(s1,d,ptr) wc_strtok((s1),(d),(ptr))
// TBD drowe: add a new FCL_STRNSTR and implement the new fclStrnstr code in common/clib/string/fclstrstr.c
// For now use the unsafe version
#define XSTRNSTR(s1,s2,n) FCL_STRSTR((s1),(s2))
#define XMEMCPY(d,s,l) FCL_MEMCPY((d),(s),(l))
#define XMEMSET(b,c,l) FCL_MEMSET((b),(c),(l))
#define XMEMCMP(s1,s2,n) FCL_MEMCMP((s1),(s2),(n))
#define XMEMMOVE(d,s,l) FCL_MEMMOVE((d),(s),(l))
#define XSTRLEN(s1) FCL_STRLEN((s1))
#define XSTRNCPY(s1,s2,n) FCL_STRNCPY((s1),(s2),(n))
#define XSTRSTR(s1,s2) FCL_STRSTR((s1),(s2))
#define XSTRNCMP(s1,s2,n) FCL_STRNCMP((s1),(s2),(n))
#define XSTRNCAT(s1,s2,n) FCL_STRNCAT((s1),(s2),(n))
#define XSTRNCASECMP(s1,s2,n) FCL_STRNCASECMP((s1),(s2),(n))
#define XSNPRINTF FCL_SNPRINTF
#endif
/* ------------------------------------------------------------------------- */
/* Enable Features */
/* ------------------------------------------------------------------------- */
#undef WOLFSSL_TLS13
#if 0
#define WOLFSSL_TLS13
#endif
#undef WOLFSSL_KEY_GEN
#if 1
#define WOLFSSL_KEY_GEN
#endif
#if defined(HAVE_FIPS) && !defined(WOLFSSL_KEY_GEN)
#define WOLFSSL_OLD_PRIME_CHECK
#endif
#undef KEEP_PEER_CERT
//#define KEEP_PEER_CERT
#undef HAVE_COMP_KEY
//#define HAVE_COMP_KEY
#undef HAVE_TLS_EXTENSIONS
//#define HAVE_TLS_EXTENSIONS
#undef HAVE_SUPPORTED_CURVES
#define HAVE_SUPPORTED_CURVES
#undef WOLFSSL_BASE64_ENCODE
#define WOLFSSL_BASE64_ENCODE
/* TLS Session Cache */
#if 0
#define SMALL_SESSION_CACHE
#else
// #define NO_SESSION_CACHE
#endif
#undef WOLFSSL_ALLOW_SSLV3
#define WOLFSSL_ALLOW_SSLV3
#undef WOLFSSL_ALLOW_TLSV10
#define WOLFSSL_ALLOW_TLSV10
/* ------------------------------------------------------------------------- */
/* Disable Features */
/* ------------------------------------------------------------------------- */
#undef NO_WOLFSSL_SERVER
//#define NO_WOLFSSL_SERVER
#undef NO_WOLFSSL_CLIENT
//#define NO_WOLFSSL_CLIENT
#undef NO_CRYPT_TEST
//#define NO_CRYPT_TEST
#undef NO_CRYPT_BENCHMARK
//#define NO_CRYPT_BENCHMARK
#undef WOLFCRYPT_ONLY
//#define WOLFCRYPT_ONLY
/* In-lining of misc.c functions */
/* If defined, must include wolfcrypt/src/misc.c in build */
/* Slower, but about 1k smaller */
#undef NO_INLINE
//#define NO_INLINE
#undef NO_FILESYSTEM
//#define NO_FILESYSTEM
#undef NO_WRITEV
#define NO_WRITEV
#undef NO_MAIN_DRIVER
#define NO_MAIN_DRIVER
#undef NO_DEV_RANDOM
//#define NO_DEV_RANDOM
#undef NO_DSA
//#define NO_DSA
#undef NO_RC4
#define NO_RC4
#undef NO_OLD_TLS
//#define NO_OLD_TLS
#undef NO_HC128
#define NO_HC128
#undef NO_RABBIT
#define NO_RABBIT
#undef NO_PSK
#define NO_PSK
#undef NO_MD4
#define NO_MD4
#undef NO_PWDBASED
//#define NO_PWDBASED
#undef NO_CODING
//#define NO_CODING
#undef NO_ASN_TIME
//#define NO_ASN_TIME
#undef NO_CERTS
//#define NO_CERTS
#undef NO_SIG_WRAPPER
//#define NO_SIG_WRAPPER
#undef NO_MAIN_DRIVER
#define NO_MAIN_DRIVER
#undef BLACKFIN_BUILD
#define BLACKFIN_BUILD
#ifdef BLACKFIN_BUILD
#include <builtins.h>
#undef WOLFSSL_HAVE_MAX
#define WOLFSSL_HAVE_MAX
#undef WOLFSSL_HAVE_MIN
#define WOLFSSL_HAVE_MIN
#include <fss_telnet_shell.h>
#define XMALLOC_OVERRIDE /* Need to use FCL stdlib instead of stdlib.h */
extern void * fclMalloc (unsigned int size);
extern void fclFree (void * memoryPointer);
extern void * fclRealloc (void * memoryPointer, unsigned int size);
#define XMALLOC(a, b, c) fclMalloc(a)
#define XFREE(a, b, c) fclFree(a)
#define XREALLOC(a, b, c, d) fclRealloc(a, b)
/*************************************************************
* wolfSSL testing
*/
typedef struct wolfArgs {
int argc;
char** argv;
int return_code;
struct fssShellInfo* info;
} wolfArgs;
#define printf FCL_PRINTF
/* CAVP TESTING */
#define NO_WOLFCAVP_MAIN_DRIVER
#define WOLFSSL_BASE16
#define USE_UART_READ_LINE
#define USE_NORMAL_PRINTF
#define VERIFY_GENERATED_PSS_SIGS
#define NO_ATTRIBUTE_CONSTRUCTOR
extern int aes_test_for_fips_hash(void);
int wolfcrypt_test_taskEnter(void *args);
int wolfcrypt_harness_taskEnter(void *args);
int wolf_task_start(void* voidinfo, char* argline);
int wolf_task_results(void* voidinfo, char* argline);
void wolfFIPS_Module_start(void);
/* For op testing */
#define USE_CERT_BUFFERS_2048
#define USE_CERT_BUFFERS_256
//#define NO_FILESYSTEM
// #define HAVE_FORCE_FIPS_FAILURE
#define OPENSSL_EXTRA //to test if iprgw project need it. AES_xxx wolfSSL_AES_xxx Aes_EncryptDirect
#define OPENSSL_ALL
#define HAVE_EX_DATA
#define WOLFSSL_EVP_DECRYPT_LEGACY
/* TLS 1.3 support */
#define WOLFSSL_TLS13
#define HAVE_TLS_EXTENSIONS
#define HAVE_SUPPORTED_CURVES
#define HAVE_ECC
#define HAVE_HKDF
#define HAVE_FFDHE_4096
#define WC_RSA_PSS
/* for static ciphers */
#define WOLFSSL_STATIC_RSA
#define WOLFSSL_STATIC_PSK
#define WOLFSSL_STATIC_EPHEMERAL
#define WOLFSSL_SNIFFER
/* TEMPORARY */
#define USING_JTAG
#endif /* BLACKFIN_BUILD */
#ifdef __cplusplus
}
#endif
#endif /* WOLFSSL_USER_SETTINGS_H */

117
IDE/VisualDSP++/wolf-tasks.c Normal file
View File

@ -0,0 +1,117 @@
/* wolf-tasks.c
*
* Copyright (C) 2006-2021 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#include <wolfssl/wolfcrypt/settings.h>
#include <wolfcrypt/test/test.h>
#include <wolfssl/wolfcrypt/error-crypt.h>
#include <wolfssl/wolfcrypt/fips_test.h>
#ifdef FUSION_RTOS
#include <fcl_os.h>
#define RESULT_BUF_SIZE 1024
typedef struct {
int isRunning;
u8 buf[RESULT_BUF_SIZE];
int len;
} wolf_result_t;
static wolf_result_t _result = {0};
static void myFipsCb(int ok, int err, const char* hash);
static void myFipsCb(int ok, int err, const char* hash)
{
FCL_PRINTF("in my Fips callback, ok = %d, err = %d\n", ok, err);
FCL_PRINTF("message = %s\n", wc_GetErrorString(err));
FCL_PRINTF("hash = %s\n", hash);
if (err == IN_CORE_FIPS_E) {
FCL_PRINTF("In core integrity hash check failure, copy above hash\n");
FCL_PRINTF("into verifyCore[] in fips_test.c and rebuild\n");
}
}
static fclThreadHandle _task = NULL;
#define WOLF_TASK_STACK_SIZE (1024 * 100)
fclThreadPriority WOLF_TASK_PRIORITY = (fclThreadPriority) (FCL_THREAD_PRIORITY_TIME_CRITICAL+1);
int wolfcrypt_test_taskEnter(void *args)
{
int ret;
wolfCrypt_SetCb_fips(myFipsCb);
ret = wolfcrypt_test(args);
printf("Result of test was %d\n", ret);
_result.isRunning = 0;
fosTaskDelete(_task);
return 0;
}
/* Was only needed for CAVP testing purposes, not required for release.
int wolfcrypt_harness_taskEnter(void *args)
{
wolfCrypt_SetCb_fips(myFipsCb);
wolfcrypt_harness(args);
_result.isRunning = 0;
fosTaskDelete(_task);
return 0;
}
*/
int wolf_task_start(void* voidinfo, char* argline)
{
char optionA[] = "wolfcrypt_test";
fssShellInfo *info = (fssShellInfo*)voidinfo;
struct wolfArgs args;
if (_result.isRunning) {
fssShellPuts(info, "previous task still running\r\n");
return 1;
}
_result.isRunning = 1;
if (FCL_STRNCMP(argline, optionA, FCL_STRLEN(optionA)) == 0) {
_task = fclThreadCreate(wolfcrypt_test_taskEnter,
&args,
WOLF_TASK_STACK_SIZE,
WOLF_TASK_PRIORITY);
} else if (FCL_STRNCMP(argline, optionB, FCL_STRLEN(optionB)) == 0) {
_task = fclThreadCreate(wolfcrypt_harness_taskEnter,
&args,
WOLF_TASK_STACK_SIZE,
WOLF_TASK_PRIORITY);
} else {
printf("Invalid input: %s\n", argline);
printf("Please try with either wolfcrypt_test or wolfcrypt_harness\n");
return -1;
}
FCL_ASSERT(_task != FCL_THREAD_HANDLE_INVALID);
return 0;
}
#endif /* FUSION_RTOS */

1
IDE/include.am
View File

@ -35,6 +35,7 @@ include IDE/M68K/include.am
include IDE/HEXAGON/include.am
include IDE/RISCV/include.am
include IDE/XilinxSDK/include.am
include IDE/VisualDSP++/include.am
EXTRA_DIST+= IDE/IAR-EWARM IDE/MDK-ARM IDE/MDK5-ARM IDE/MYSQL IDE/LPCXPRESSO IDE/HEXIWEAR IDE/Espressif IDE/zephyr
EXTRA_DIST+= IDE/OPENSTM32/README.md

5
src/internal.c
View File

@ -77,8 +77,13 @@
#if defined(DEBUG_WOLFSSL) || defined(SHOW_SECRETS) || \
defined(CHACHA_AEAD_TEST) || defined(WOLFSSL_SESSION_EXPORT_DEBUG)
#ifndef NO_STDIO_FILESYSTEM
#ifndef FUSION_RTOS
#include <stdio.h>
#endif
#ifdef FUSION_RTOS
#include <fclstdio.h>
#endif
#endif
#endif
#ifdef __sun

136
src/sniffer.c
View File

@ -25,6 +25,38 @@
#endif
#include <wolfssl/wolfcrypt/settings.h>
#include <wolfssl/wolfcrypt/wc_port.h>
/* xctime - should it move to wc_port.h? */
#ifndef XCTIME
#define XCTIME ctime
#endif
/* should next ifdef move to wc_port.h? */
#ifdef FUSION_RTOS
#include <fcl_network.h>
#define XINET_NTOA FNS_INET_NTOA
#define XINET_ATON FNS_INET_ATON
#define XINET_PTON(a,b,c,d) FNS_INET_PTON((a),(b),(c),(d),NULL)
#define XINET_NTOP(a,b,c,d) FNS_INET_NTOP((a),(b),(c),(d),NULL)
#define XINET_ADDR FNS_INET_ADDR
#define XHTONS FNS_HTONS
#define XNTOHS FNS_NTOHS
#define XHTONL FNS_HTONL
#define XNTOHL FNS_NTOHL
#define XINADDR_NONE FNS_INADDR_NONE
#else
#define XINET_NTOA inet_ntoa
#define XINET_ATON inet_aton
#define XINET_PTON(a,b,c) inet_pton((a),(b),(c))
#define XINET_NTOP inet_ntop
#define XINET_ADDR inet_addr
#define XHTONS htons
#define XNTOHS ntohs
#define XHTONL htonl
#define XNTOHL ntohl
#define XINADDR_NONE INADDR_NONE
#endif
#if !defined(WOLFCRYPT_ONLY) && !defined(NO_FILESYSTEM)
#ifdef WOLFSSL_SNIFFER
@ -32,10 +64,17 @@
#include <assert.h>
#include <time.h>
#ifndef _WIN32
#include <arpa/inet.h>
#ifdef FUSION_RTOS
#include <fns_inet.h>
#ifdef TCP_PROTOCOL
#undef TCP_PROTOCOL
#endif
#else
#include <WS2tcpip.h>
#ifndef _WIN32
#include <arpa/inet.h>
#else
#include <WS2tcpip.h>
#endif
#endif
#ifdef _WIN32
@ -95,7 +134,7 @@ enum {
EXT_TYPE_SZ = 2, /* Extension type length */
MAX_INPUT_SZ = MAX_RECORD_SIZE + COMP_EXTRA + MAX_MSG_EXTRA +
MTU_EXTRA, /* Max input sz of reassembly */
/* TLS Extensions */
EXT_SERVER_NAME = 0x0000, /* a.k.a. SNI */
EXT_MAX_FRAGMENT_LENGTH = 0x0001,
@ -160,7 +199,7 @@ BOOL APIENTRY DllMain( HMODULE hModule,
static WOLFSSL_GLOBAL int TraceOn = 0; /* Trace is off by default */
static WOLFSSL_GLOBAL FILE* TraceFile = 0;
static WOLFSSL_GLOBAL XFILE TraceFile = 0;
/* windows uses .rc table for this */
@ -716,7 +755,7 @@ void ssl_FreeSniffer(void)
if (TraceFile) {
TraceOn = 0;
fclose(TraceFile);
XFCLOSE(TraceFile);
TraceFile = NULL;
}
@ -955,9 +994,9 @@ static void Trace(int idx)
if (TraceOn) {
char myBuffer[MAX_ERROR_LEN];
GetError(idx, myBuffer);
fprintf(TraceFile, "\t%s\n", myBuffer);
XFPRINTF(TraceFile, "\t%s\n", myBuffer);
#ifdef DEBUG_SNIFFER
fprintf(stderr, "\t%s\n", myBuffer);
XFPRINTF(stderr, "\t%s\n", myBuffer);
#endif
}
}
@ -967,8 +1006,8 @@ static void Trace(int idx)
static void TraceHeader(void)
{
if (TraceOn) {
time_t ticks = time(NULL);
fprintf(TraceFile, "\n%s", ctime(&ticks));
time_t ticks = XTIME(NULL);
XFPRINTF(TraceFile, "\n%s", XCTIME(&ticks));
}
}
@ -977,8 +1016,8 @@ static void TraceHeader(void)
static void TraceSetServer(const char* srv, int port, const char* keyFile)
{
if (TraceOn) {
fprintf(TraceFile, "\tTrying to install a new Sniffer Server with\n");
fprintf(TraceFile, "\tserver: %s, port: %d, keyFile: %s\n", srv, port,
XFPRINTF(TraceFile, "\tTrying to install a new Sniffer Server with\n");
XFPRINTF(TraceFile, "\tserver: %s, port: %d, keyFile: %s\n", srv, port,
keyFile);
}
}
@ -991,8 +1030,8 @@ static void TraceSetNamedServer(const char* name,
const char* srv, int port, const char* keyFile)
{
if (TraceOn) {
fprintf(TraceFile, "\tTrying to install a new Sniffer Server with\n");
fprintf(TraceFile, "\tname: %s, server: %s, port: %d, keyFile: %s\n",
XFPRINTF(TraceFile, "\tTrying to install a new Sniffer Server with\n");
XFPRINTF(TraceFile, "\tname: %s, server: %s, port: %d, keyFile: %s\n",
name ? name : "",
srv ? srv : "",
port,
@ -1008,7 +1047,7 @@ static void TracePacket(void)
{
if (TraceOn) {
static word32 packetNumber = 0;
fprintf(TraceFile, "\tGot a Packet to decode, packet %u\n",
XFPRINTF(TraceFile, "\tGot a Packet to decode, packet %u\n",
++packetNumber);
}
}
@ -1017,7 +1056,7 @@ static void TracePacket(void)
/* Convert network byte order address into human readable */
static const char* IpToS(int version, void* src, char* dst)
{
return inet_ntop(version, src, dst, TRACE_MSG_SZ);
return XINET_NTOP(version, src, dst, TRACE_MSG_SZ);
}
@ -1027,7 +1066,7 @@ static void TraceIP(IpHdr* iphdr)
if (TraceOn) {
char src[TRACE_MSG_SZ];
char dst[TRACE_MSG_SZ];
fprintf(TraceFile, "\tdst:%s src:%s\n",
XFPRINTF(TraceFile, "\tdst:%s src:%s\n",
IpToS(AF_INET, &iphdr->dst, dst),
IpToS(AF_INET, &iphdr->src, src));
}
@ -1040,7 +1079,7 @@ static void TraceIP6(Ip6Hdr* iphdr)
if (TraceOn) {
char src[TRACE_MSG_SZ];
char dst[TRACE_MSG_SZ];
fprintf(TraceFile, "\tdst: %s src: %s\n",
XFPRINTF(TraceFile, "\tdst: %s src: %s\n",
IpToS(AF_INET6, iphdr->dst, dst),
IpToS(AF_INET6, iphdr->src, src));
}
@ -1051,8 +1090,8 @@ static void TraceIP6(Ip6Hdr* iphdr)
static void TraceTcp(TcpHdr* tcphdr)
{
if (TraceOn) {
fprintf(TraceFile, "\tdstPort:%u srcPort:%u\n", ntohs(tcphdr->dstPort),
ntohs(tcphdr->srcPort));
XFPRINTF(TraceFile, "\tdstPort:%u srcPort:%u\n", XNTOHS(tcphdr->dstPort),
XNTOHS(tcphdr->srcPort));
}
}
@ -1061,7 +1100,7 @@ static void TraceTcp(TcpHdr* tcphdr)
static void TraceSequence(word32 seq, int len)
{
if (TraceOn) {
fprintf(TraceFile, "\tSequence:%u, payload length:%d\n", seq, len);
XFPRINTF(TraceFile, "\tSequence:%u, payload length:%d\n", seq, len);
}
}
@ -1070,7 +1109,7 @@ static void TraceSequence(word32 seq, int len)
static void TraceAck(word32 ack, word32 expected)
{
if (TraceOn) {
fprintf(TraceFile, "\tAck:%u Expected:%u\n", ack, expected);
XFPRINTF(TraceFile, "\tAck:%u Expected:%u\n", ack, expected);
}
}
@ -1079,7 +1118,7 @@ static void TraceAck(word32 ack, word32 expected)
static void TraceRelativeSequence(word32 expected, word32 got)
{
if (TraceOn) {
fprintf(TraceFile, "\tExpected sequence:%u, received sequence:%u\n",
XFPRINTF(TraceFile, "\tExpected sequence:%u, received sequence:%u\n",
expected, got);
}
}
@ -1089,7 +1128,7 @@ static void TraceRelativeSequence(word32 expected, word32 got)
static void TraceServerSyn(word32 seq)
{
if (TraceOn) {
fprintf(TraceFile, "\tServer SYN, Sequence Start:%u\n", seq);
XFPRINTF(TraceFile, "\tServer SYN, Sequence Start:%u\n", seq);
}
}
@ -1098,7 +1137,7 @@ static void TraceServerSyn(word32 seq)
static void TraceClientSyn(word32 seq)
{
if (TraceOn) {
fprintf(TraceFile, "\tClient SYN, Sequence Start:%u\n", seq);
XFPRINTF(TraceFile, "\tClient SYN, Sequence Start:%u\n", seq);
}
}
@ -1107,7 +1146,7 @@ static void TraceClientSyn(word32 seq)
static void TraceClientFin(word32 finSeq, word32 relSeq)
{
if (TraceOn) {
fprintf(TraceFile, "\tClient FIN capture:%u, current SEQ:%u\n",
XFPRINTF(TraceFile, "\tClient FIN capture:%u, current SEQ:%u\n",
finSeq, relSeq);
}
}
@ -1117,7 +1156,7 @@ static void TraceClientFin(word32 finSeq, word32 relSeq)
static void TraceServerFin(word32 finSeq, word32 relSeq)
{
if (TraceOn) {
fprintf(TraceFile, "\tServer FIN capture:%u, current SEQ:%u\n",
XFPRINTF(TraceFile, "\tServer FIN capture:%u, current SEQ:%u\n",
finSeq, relSeq);
}
}
@ -1127,7 +1166,7 @@ static void TraceServerFin(word32 finSeq, word32 relSeq)
static void TraceGotData(int bytes)
{
if (TraceOn) {
fprintf(TraceFile, "\t%d bytes of SSL App data processed\n", bytes);
XFPRINTF(TraceFile, "\t%d bytes of SSL App data processed\n", bytes);
}
}
@ -1136,7 +1175,7 @@ static void TraceGotData(int bytes)
static void TraceAddedData(int newBytes, int existingBytes)
{
if (TraceOn) {
fprintf(TraceFile,
XFPRINTF(TraceFile,
"\t%d bytes added to %d existing bytes in User Buffer\n",
newBytes, existingBytes);
}
@ -1147,7 +1186,7 @@ static void TraceAddedData(int newBytes, int existingBytes)
static void TraceStaleSession(void)
{
if (TraceOn) {
fprintf(TraceFile, "\tFound a stale session\n");
XFPRINTF(TraceFile, "\tFound a stale session\n");
}
}
@ -1156,7 +1195,7 @@ static void TraceStaleSession(void)
static void TraceFindingStale(void)
{
if (TraceOn) {
fprintf(TraceFile, "\tTrying to find Stale Sessions\n");
XFPRINTF(TraceFile, "\tTrying to find Stale Sessions\n");
}
}
@ -1165,7 +1204,7 @@ static void TraceFindingStale(void)
static void TraceRemovedSession(void)
{
if (TraceOn) {
fprintf(TraceFile, "\tRemoved it\n");
XFPRINTF(TraceFile, "\tRemoved it\n");
}
}
@ -1175,7 +1214,7 @@ static void TraceSessionInfo(SSLInfo* sslInfo)
{
if (TraceOn) {
if (sslInfo != NULL && sslInfo->isValid) {
fprintf(TraceFile,
XFPRINTF(TraceFile,
"\tver:(%u %u) suiteId:(%02x %02x) suiteName:(%s) "
#ifdef HAVE_SNI
"sni:(%s) "
@ -1201,7 +1240,7 @@ static void TraceSessionInfo(SSLInfo* sslInfo)
static void TraceStat(const char* name, int add)
{
if (TraceOn) {
fprintf(TraceFile, "\tAdding %d to %s\n", add, name);
XFPRINTF(TraceFile, "\tAdding %d to %s\n", add, name);
}
}
@ -1368,7 +1407,7 @@ static word32 SessionHash(IpInfo* ipInfo, TcpInfo* tcpInfo)
static SnifferSession* GetSnifferSession(IpInfo* ipInfo, TcpInfo* tcpInfo)
{
SnifferSession* session;
time_t currTime = time(NULL);
time_t currTime = XTIME(NULL);
word32 row = SessionHash(ipInfo, tcpInfo);
assert(row <= HASH_SIZE);
@ -1581,9 +1620,14 @@ static int SetNamedPrivateKey(const char* name, const char* address, int port,
#endif
serverIp.version = IPV4;
serverIp.ip4 = inet_addr(address);
if (serverIp.ip4 == INADDR_NONE) {
if (inet_pton(AF_INET6, address, serverIp.ip6) == 1) {
serverIp.ip4 = XINET_ADDR(address);
if (serverIp.ip4 == XINADDR_NONE) {
#ifdef FUSION_RTOS
if (XINET_PTON(AF_INET6, address, serverIp.ip6,
sizeof(serverIp.ip4)) == 1) {
#else
if (XINET_PTON(AF_INET6, address, serverIp.ip6) == 1) {
#endif
serverIp.version = IPV6;
}
}
@ -1896,7 +1940,7 @@ static int CheckIp6Hdr(Ip6Hdr* iphdr, IpInfo* info, int length, char* error)
#endif
info->length = exthdrsz;
info->total = ntohs(iphdr->length) + info->length;
info->total = XNTOHS(iphdr->length) + info->length;
/* IPv6 doesn't include its own header size in the length like v4. */
info->src.version = IPV6;
XMEMCPY(info->src.ip6, iphdr->src, sizeof(info->src.ip6));
@ -1938,7 +1982,7 @@ static int CheckIpHdr(IpHdr* iphdr, IpInfo* info, int length, char* error)
#endif
info->length = IP_HL(iphdr);
info->total = ntohs(iphdr->length);
info->total = XNTOHS(iphdr->length);
info->src.version = IPV4;
info->src.ip4 = iphdr->src;
info->dst.version = IPV4;
@ -1957,16 +2001,16 @@ static int CheckTcpHdr(TcpHdr* tcphdr, TcpInfo* info, char* error)
{
TraceTcp(tcphdr);
Trace(TCP_CHECK_STR);
info->srcPort = ntohs(tcphdr->srcPort);
info->dstPort = ntohs(tcphdr->dstPort);
info->srcPort = XNTOHS(tcphdr->srcPort);
info->dstPort = XNTOHS(tcphdr->dstPort);
info->length = TCP_LEN(tcphdr);
info->sequence = ntohl(tcphdr->sequence);
info->sequence = XNTOHL(tcphdr->sequence);
info->fin = tcphdr->flags & TCP_FIN;
info->rst = tcphdr->flags & TCP_RST;
info->syn = tcphdr->flags & TCP_SYN;
info->ack = tcphdr->flags & TCP_ACK;
if (info->ack)
info->ackNumber = ntohl(tcphdr->ack);
info->ackNumber = XNTOHL(tcphdr->ack);
#ifndef WOLFSSL_SNIFFER_WATCH
if (!IsPortRegistered(info->srcPort) && !IsPortRegistered(info->dstPort)) {
@ -4010,7 +4054,7 @@ static void RemoveStaleSessions(void)
session = SessionTable[i];
while (session) {
SnifferSession* next = session->next;
if (time(NULL) >= session->lastUsed + WOLFSSL_SNIFFER_TIMEOUT) {
if (XTIME(NULL) >= session->lastUsed + WOLFSSL_SNIFFER_TIMEOUT) {
TraceStaleSession();
RemoveSession(session, NULL, NULL, i);
}
@ -4059,7 +4103,7 @@ static SnifferSession* CreateSession(IpInfo* ipInfo, TcpInfo* tcpInfo,
session->cliPort = (word16)tcpInfo->srcPort;
session->cliSeqStart = tcpInfo->sequence;
session->cliExpected = 1; /* relative */
session->lastUsed= time(NULL);
session->lastUsed= XTIME(NULL);
session->keySz = 0;
#ifdef HAVE_SNI
session->sni = NULL;

51
src/ssl.c
View File

@ -29,6 +29,7 @@
/* turn on GNU extensions for XVASPRINTF with wolfSSL_BIO_printf */
#undef _GNU_SOURCE
#define _GNU_SOURCE
#include <stdarg.h>
#endif
#if !defined(WOLFCRYPT_ONLY) || defined(OPENSSL_EXTRA) || \
@ -547,7 +548,7 @@ WOLFSSL* wolfSSL_new(WOLFSSL_CTX* ctx)
ssl = (WOLFSSL*) XMALLOC(sizeof(WOLFSSL), ctx->heap, DYNAMIC_TYPE_SSL);
if (ssl)
if (InitSSL(ssl, ctx, 0) < 0) {
if ( (ret = InitSSL(ssl, ctx, 0)) < 0) {
FreeSSL(ssl, ctx->heap);
ssl = 0;
}
@ -3967,7 +3968,7 @@ void wolfSSL_ERR_print_errors_fp(XFILE fp, int err)
WOLFSSL_ENTER("wolfSSL_ERR_print_errors_fp");
SetErrorString(err, data);
fprintf(fp, "%s", data);
XFPRINTF(fp, "%s", data);
}
#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
@ -5103,7 +5104,7 @@ static int ProcessBufferTryDecode(WOLFSSL_CTX* ctx, WOLFSSL* ssl, DerBuffer* der
if (key == NULL)
return MEMORY_E;
#endif
ret = wc_InitRsaKey_ex(key, heap, devId);
if (ret == 0) {
*idx = 0;
@ -15669,6 +15670,7 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
WOLFSSL_ENTER("BIO_set_write_buffer_size");
WOLFSSL_STUB("BIO_set_write_buffer_size");
(void)bio;
/* return 1 if the buffer was successfully resized or 0 for failure. */
return size;
}
#endif
@ -15977,8 +15979,15 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
wolfSSL_free((WOLFSSL*)bio->ptr);
#ifdef CloseSocket
if (bio->type == WOLFSSL_BIO_SOCKET && bio->num)
{
#ifdef FUSION_RTOS
int err;
CloseSocket(bio->num, &err);
#else
CloseSocket(bio->num);
#endif
#endif
}
#endif
}
#ifndef NO_FILESYSTEM
@ -29095,7 +29104,7 @@ int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args)
va_end(args);
return -1;
}
ret = vfprintf((XFILE)bio->ptr, format, args);
ret = XVFPRINTF((XFILE)bio->ptr, format, args);
break;
case WOLFSSL_BIO_MEMORY:
@ -29109,15 +29118,20 @@ int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args)
char* pt = NULL;
va_list copy;
va_copy(copy, args);
count = vsnprintf(NULL, 0, format, args);
#ifdef FUSION_RTOS
copy = args; /* hack, depends on internal implementation
* of va_list in VisualDSP++ */
#else
va_copy(copy, args);
#endif
count = XVSNPRINTF(NULL, 0, format, args);
if (count >= 0)
{
pt = (char*)XMALLOC(count + 1, bio->heap,
DYNAMIC_TYPE_TMP_BUFFER);
if (pt != NULL)
{
count = vsnprintf(pt, count + 1, format, copy);
count = XVSNPRINTF(pt, count + 1, format, copy);
if (count >= 0)
{
ret = wolfSSL_BIO_write(bio, pt, count);
@ -29173,24 +29187,24 @@ int wolfSSL_BIO_dump(WOLFSSL_BIO *bio, const char *buf, int length)
char line[80];
if (!buf) {
return fputs("\tNULL", (XFILE)bio->ptr);
return XFPUTS("\tNULL", (XFILE)bio->ptr);
}
sprintf(line, "\t");
XSPRINTF(line, "\t");
for (i = 0; i < LINE_LEN; i++) {
if (i < length)
sprintf(line + 1 + i * 3,"%02x ", buf[i]);
XSPRINTF(line + 1 + i * 3,"%02x ", buf[i]);
else
sprintf(line + 1 + i * 3, " ");
XSPRINTF(line + 1 + i * 3, " ");
}
sprintf(line + 1 + LINE_LEN * 3, "| ");
XSPRINTF(line + 1 + LINE_LEN * 3, "| ");
for (i = 0; i < LINE_LEN; i++) {
if (i < length) {
sprintf(line + 3 + LINE_LEN * 3 + i,
XSPRINTF(line + 3 + LINE_LEN * 3 + i,
"%c", 31 < buf[i] && buf[i] < 127 ? buf[i] : '.');
}
}
ret += fputs(line, (XFILE)bio->ptr);
ret += XFPUTS(line, (XFILE)bio->ptr);
if (length > LINE_LEN)
ret += wolfSSL_BIO_dump(bio, buf + LINE_LEN, length - LINE_LEN);
@ -31486,7 +31500,8 @@ int SetDhInternal(WOLFSSL_DH* dh)
return ret;
}
#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL) || defined(WOLFSSL_OPENSSH))
#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL) \
|| defined(WOLFSSL_OPENSSH))
#ifdef WOLFSSL_DH_EXTRA
WOLFSSL_DH* wolfSSL_DH_dup(WOLFSSL_DH* dh)
@ -36090,6 +36105,7 @@ WOLFSSL_BIGNUM *wolfSSL_EC_POINT_point2bn(const WOLFSSL_EC_GROUP *group,
return ret;
}
#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
#ifdef USE_ECC_B_PARAM
int wolfSSL_EC_POINT_is_on_curve(const WOLFSSL_EC_GROUP *group,
@ -36113,7 +36129,6 @@ int wolfSSL_EC_POINT_is_on_curve(const WOLFSSL_EC_GROUP *group,
== MP_OKAY ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
}
#endif /* USE_ECC_B_PARAM */
#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
WOLFSSL_EC_POINT *wolfSSL_EC_POINT_new(const WOLFSSL_EC_GROUP *group)
{
@ -49917,7 +49932,7 @@ int wolfSSL_BN_print_fp(XFILE fp, const WOLFSSL_BIGNUM *bn)
return WOLFSSL_FAILURE;
}
fprintf(fp, "%s", buf);
XFPRINTF(fp, "%s", buf);
XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL);
return WOLFSSL_SUCCESS;

9
src/tls13.c
View File

@ -1371,9 +1371,14 @@ end:
word32 TimeNowInMilliseconds(void)
{
struct timeval now;
#ifdef FUSION_RTOS
if (FCL_GETTIMEOFDAY(&now, 0) < 0)
return (word32)GETTIME_ERROR;
//TODO research why negative error code returns as word32
#else
if (gettimeofday(&now, 0) < 0)
return GETTIME_ERROR;
return (word32)GETTIME_ERROR;
#endif
/* Convert to milliseconds number. */
return (word32)(now.tv_sec * 1000 + now.tv_usec / 1000);
}

46
src/wolfio.c
View File

@ -98,6 +98,9 @@ static WC_INLINE int wolfSSL_LastError(int err)
return xn_getlasterror();
#elif defined(WOLFSSL_LINUXKM)
return err; /* Return provided error value */
#elif defined(FUSION_RTOS)
#include <fclerrno.h>
return FCL_GET_ERRNO;
#else
return errno;
#endif
@ -694,7 +697,24 @@ int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags)
{
int recvd;
#ifdef FUSION_RTOS
int err;
retry:
recvd = (int)RECV_FUNCTION(sd, buf, sz, rdFlags, &err);
if(recvd < 0) {
if(err==63)
{
UARTF("FUSION IO RETRY %d\r\n", err);
fclThreadSleep(10);
goto retry;
}
UARTF("FUSION IO ERROR %d\r\n", err);
}
//TODO handle return value in err
#else
recvd = (int)RECV_FUNCTION(sd, buf, sz, rdFlags);
#endif
recvd = TranslateReturnCode(recvd, sd);
return recvd;
@ -703,8 +723,22 @@ int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags)
int wolfIO_Send(SOCKET_T sd, char *buf, int sz, int wrFlags)
{
int sent;
#ifdef FUSION_RTOS
int err;
retry:
sent = (int)SEND_FUNCTION(sd, buf, sz, wrFlags, &err);
if(sent < 0) {
if(err==63)
{
UARTF("FUSION IO SEND RETRY %d\r\n", err);
fclThreadSleep(10);
goto retry;
}
UARTF("FUSION IO SEND ERROR %d\r\n", err);
}
#else
sent = (int)SEND_FUNCTION(sd, buf, sz, wrFlags);
#endif
sent = TranslateReturnCode(sent, sd);
return sent;
@ -785,6 +819,8 @@ int wolfIO_Send(SOCKET_T sd, char *buf, int sz, int wrFlags)
}
}
}
WOLFSSL_MSG("Select error");
return SOCKET_ERROR_E;
}
#endif /* HAVE_IO_TIMEOUT */
@ -1462,8 +1498,14 @@ int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
ret = wolfIO_HttpProcessResponseOcsp(sfd, ocspRespBuf, httpBuf,
HTTP_SCRATCH_BUFFER_SIZE, ctx);
}
if (sfd != SOCKET_INVALID)
if (sfd != SOCKET_INVALID) {
#ifdef FUSION_RTOS
int err;
CloseSocket(sfd, &err);
#else
CloseSocket(sfd);
#endif
}
XFREE(httpBuf, ctx, DYNAMIC_TYPE_OCSP);
}
}

1
wolfcrypt/src/evp.c
View File

@ -41,7 +41,6 @@
#include <wolfssl/wolfcrypt/aes.h>
#endif
#include <wolfssl/openssl/ecdsa.h>
#include <wolfssl/openssl/evp.h>

8
wolfcrypt/src/logging.c
View File

@ -266,8 +266,12 @@ void WOLFSSL_TIME(int count)
#include "xil_printf.h"
#elif defined(WOLFSSL_LINUXKM)
/* the requisite linux/kernel.h is included in wc_port.h, with incompatible warnings masked out. */
#elif defined(FUSION_RTOS)
#include <fclstdio.h>
#include <wolfssl/wolfcrypt/wc_port.h>
#define fprintf FCL_FPRINTF
#else
#include <stdio.h> /* for default printf stuff */
#include <stdio.h>/* for default printf stuff */
#endif
#if defined(THREADX) && !defined(THREADX_NO_DC_PRINTF)
@ -856,7 +860,7 @@ void wc_ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
while (current != NULL)
{
next = current->next;
cb(current->error, strlen(current->error), u);
cb(current->error, XSTRLEN(current->error), u);
XFREE(current, current->heap, DYNAMIC_TYPE_LOG);
current = next;
}

6
wolfssl/internal.h
View File

@ -199,7 +199,11 @@
#endif
#endif
#if defined(OPENSSL_EXTRA) && !defined(NO_FILESYSTEM)
#include <unistd.h> /* for close of BIO */
#ifdef FUSION_RTOS
#include <fclunistd.h>
#else
#include <unistd.h> /* for close of BIO */
#endif
#endif
#endif

6
wolfssl/ssl.h
View File

@ -1852,7 +1852,11 @@ enum {
#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
/* wolfSSL extension, provide last error from SSL_get_error
since not using thread storage error queue */
#include <stdio.h>
#ifdef FUSION_RTOS
#include <fclstdio.h>
#else
#include <stdio.h>
#endif
WOLFSSL_API void wolfSSL_ERR_print_errors_fp(XFILE, int err);
#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
WOLFSSL_API void wolfSSL_ERR_dump_errors_fp(XFILE fp);

9
wolfssl/test.h
View File

@ -3,8 +3,13 @@
#ifndef wolfSSL_TEST_H
#define wolfSSL_TEST_H
#include <stdio.h>
#include <stdlib.h>
#ifdef FUSION_RTOS
#include <fclstdio.h>
#include <fclstdlib.h>
#else
#include <stdio.h>
#include <stdlib.h>
#endif
#include <assert.h>
#include <ctype.h>
#include <wolfssl/wolfcrypt/types.h>

93
wolfssl/wolfcrypt/wc_port.h
View File

@ -323,7 +323,11 @@
#endif
#if (defined(OPENSSL_EXTRA) || defined(GOAHEAD_WS)) && \
!defined(NO_FILESYSTEM)
#include <unistd.h> /* for close of BIO */
#ifdef FUSION_RTOS
#include <fclunistd.h>
#else
#include <unistd.h> /* for close of BIO */
#endif
#endif
#endif
@ -487,6 +491,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END VSEEK_END
#define XBADFILE -1
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(LSR_FS)
#include <fs.h>
#define XFILE struct fs_file*
@ -499,7 +508,12 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XFCLOSE fs_close
#define XSEEK_END 0
#define XBADFILE NULL
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX)
#define XFILE MQX_FILE_PTR
#define XFOPEN fopen
@ -512,10 +526,19 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END IO_SEEK_END
#define XBADFILE NULL
#define XFGETS fgets
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(WOLFSSL_DEOS)
#define NO_FILESYSTEM
#warning "TODO - DDC-I Certifiable Fast File System for Deos is not integrated"
//#define XFILE bfd *
/* #define XFILE bfd * */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(MICRIUM)
#include <fs_api.h>
@ -530,6 +553,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END FS_SEEK_END
#define XBADFILE NULL
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(WOLFSSL_NUCLEUS_1_2)
#include "fal/inc/fal.h"
#define XFILE FILE*
@ -542,6 +570,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XFCLOSE fclose
#define XSEEK_END PSEEK_END
#define XBADFILE NULL
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(WOLFSSL_APACHE_MYNEWT)
#include <fs/fs.h>
#define XFILE struct fs_file*
@ -556,6 +589,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END 2
#define XBADFILE NULL
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(WOLFSSL_ZEPHYR)
#include <fs.h>
@ -576,6 +614,10 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END FS_SEEK_END
#define XBADFILE NULL
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(WOLFSSL_TELIT_M2MB)
#define XFILE INT32
@ -589,6 +631,10 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END M2MB_SEEK_END
#define XBADFILE -1
#define XFGETS(b,s,f) -2 /* Not ported yet */
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined (WOLFSSL_XILINX)
#include "xsdps.h"
@ -606,6 +652,42 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END 0
#define XBADFILE NULL
#define XFGETS(b,s,f) f_gets((b), (s), (f))
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#elif defined(FUSION_RTOS)
#include <fclstdio.h>
#include <fclunistd.h>
#include <fcldirent.h>
#include <sys/fclstat.h>
#include <fclstring.h>
#include <fcl_os.h>
#define XFILE FCL_FILE*
#define XFOPEN FCL_FOPEN
#define XFSEEK FCL_FSEEK
#define XFTELL FCL_FTELL
#define XREWIND FCL_REWIND
#define XFREAD FCL_FREAD
#define XFWRITE FCL_FWRITE
#define XFCLOSE FCL_FCLOSE
#define XSEEK_END SEEK_END
#define XBADFILE NULL
#define XFGETS FCL_FGETS
#define XFPUTS FCL_FPUTS
#define XFPRINTF FCL_FPRINTF
#define XVFPRINTF FCL_VFPRINTF
#define XVSNPRINTF FCL_VSNPRINTF
#define XSNPRINTF FCL_SNPRINTF
#define XSPRINTF FCL_SPRINTF
#define DIR FCL_DIR
#define stat FCL_STAT
#define opendir FCL_OPENDIR
#define closedir FCL_CLOSEDIR
#define readdir FCL_READDIR
#define dirent fclDirent
#define strncasecmp FCL_STRNCASECMP
#elif defined(WOLFSSL_USER_FILESYSTEM)
/* To be defined in user_settings.h */
@ -629,6 +711,11 @@ WOLFSSL_API int wolfCrypt_Cleanup(void);
#define XSEEK_END SEEK_END
#define XBADFILE NULL
#define XFGETS fgets
#define XFPRINTF fprintf
#define XVFPRINTF vfprintf
#define XVSNPRINTF vsnprintf
#define XFPUTS fputs
#define XSPRINTF sprintf
#if !defined(USE_WINDOWS_API) && !defined(NO_WOLFSSL_DIR)\
&& !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)

19
wolfssl/wolfio.h
View File

@ -133,6 +133,10 @@
#elif defined(HAVE_NETX)
#include "nx_api.h"
#include "errno.h"
#elif defined(FUSION_RTOS)
#include <sys/fcltypes.h>
#include <fclerrno.h>
#include <fclfcntl.h>
#elif !defined(WOLFSSL_NO_SOCK)
#include <sys/types.h>
#include <errno.h>
@ -259,6 +263,14 @@
#define SOCKET_EPIPE NX_NOT_CONNECTED
#define SOCKET_ECONNREFUSED NX_NOT_CONNECTED
#define SOCKET_ECONNABORTED NX_NOT_CONNECTED
#elif defined(FUSION_RTOS)
#define SOCKET_EWOULDBLOCK FCL_EWOULDBLOCK
#define SOCKET_EAGAIN FCL_EAGAIN
#define SOCKET_ECONNRESET FNS_ECONNRESET
#define SOCKET_EINTR FCL_EINTR
#define SOCKET_EPIPE FCL_EPIPE
#define SOCKET_ECONNREFUSED FCL_ECONNREFUSED
#define SOCKET_ECONNABORTED FNS_ECONNABORTED
#else
#define SOCKET_EWOULDBLOCK EWOULDBLOCK
#define SOCKET_EAGAIN EAGAIN
@ -290,6 +302,9 @@
#elif defined(WOLFSSL_NUCLEUS_1_2)
#define SEND_FUNCTION NU_Send
#define RECV_FUNCTION NU_Recv
#elif defined(FUSION_RTOS)
#define SEND_FUNCTION FNS_SEND
#define RECV_FUNCTION FNS_RECV
#elif defined(WOLFSSL_ZEPHYR)
#ifndef WOLFSSL_MAX_SEND_SZ
#define WOLFSSL_MAX_SEND_SZ 256
@ -372,6 +387,10 @@ WOLFSSL_API int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags);
#define CloseSocket(s) closesocket(s)
#endif
#define StartTCP()
#elif defined(FUSION_RTOS)
#ifndef CloseSocket
#define CloseSocket FNS_CLOSE
#endif
#else
#ifndef CloseSocket
#define CloseSocket(s) close(s)