diff --git a/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/crypto/init.c b/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/crypto/init.c index 8f6129fa..19391fec 100644 --- a/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/crypto/init.c +++ b/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/crypto/init.c @@ -708,6 +708,8 @@ int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) if (!CRYPTO_atomic_or(&optsdone, opts, &tmp, optsdone_lock)) return 0; + RAND_set_rand_method(RAND_OpenSSL()); + return 1; } @@ -820,9 +822,7 @@ int ipcrypto_init_internal(SEM_ID semId) { init = 1; -#ifndef _WRS_CONFIG_OPENSSL_FIPSMODULE - RAND_set_rand_method(vxRandLibMeth()); -#endif + OpenSSL_add_all_algorithms(); diff --git a/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/interrupt_entropy.c b/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/interrupt_entropy.c new file mode 100644 index 00000000..1e468742 --- /dev/null +++ b/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/interrupt_entropy.c @@ -0,0 +1,228 @@ +#include +#include +#include +#include +#include +#include +#include "sysLib.h" + +#define ENTROPY_SAMPLE_COUNT 64 /* Number of interrupt samples to collect */ +#define ENTROPY_BUFFER_SIZE 32 /* Output entropy buffer size in bytes */ + +/* Structure to hold entropy collection state */ +typedef struct { + UINT32 samples[ENTROPY_SAMPLE_COUNT]; + int sample_index; + UINT32 last_tick; + WDOG_ID watchdog; + UINT8 entropy_pool[ENTROPY_BUFFER_SIZE]; + int pool_filled; +} EntropyCollector; + +/* Forward declarations */ +static void entropyWatchdogCallback(void *arg); + +/******************************************************************************* +* entropyWatchdogCallback - Callback function invoked at interrupt context +* +* This function runs in interrupt context (system tick interrupt). It samples +* the current system tick count and computes jitter as the delta between +* consecutive interrupts. VxWorks watchdogs execute in interrupt context, +* so this function must NOT: +* - Call any blocking functions +* - Use printf() +* - Use C++ objects with constructors/destructors +* - Use memory allocation (malloc/new) +* +* See: VxWorks Programmer's Guide - C++ limitations in interrupt context [citation:1][citation:2] +*******************************************************************************/ +static void entropyWatchdogCallback(void *arg) { + EntropyCollector *collector = (EntropyCollector*)arg; + UINT32 current_tick; + UINT32 jitter; + + if (collector == NULL) { + return; + } + + /* Get current system tick count - high resolution timing source */ + current_tick = sysTimestamp(); + + /* Calculate jitter as timing delta between successive interrupts */ + if (collector->last_tick != 0) { + jitter = current_tick - collector->last_tick; + + /* Store jitter sample if we haven't collected enough */ + if (collector->sample_index < ENTROPY_SAMPLE_COUNT) { + collector->samples[collector->sample_index++] = jitter; + } + } + + /* Update last tick for next measurement */ + collector->last_tick = current_tick; + + /* + * Reschedule watchdog for next interrupt (non-periodic to avoid + * predictable patterns - this actually increases entropy) + */ + if (collector->sample_index < ENTROPY_SAMPLE_COUNT) { + /* Randomize next delay using existing entropy for better jitter */ + int next_delay = 1 + (collector->samples[collector->sample_index - 1] % 10); + wdStart(collector->watchdog, next_delay, + (FUNCPTR)entropyWatchdogCallback, (_Vx_usr_arg_t)collector); + } +} + +/******************************************************************************* +* mixEntropyIntoPool - Mix collected jitter samples into entropy pool using +* a simple hash function (Jenkins one-at-a-time) +* +* This function runs in task context, NOT interrupt context. +*******************************************************************************/ +static void mixEntropyIntoPool(EntropyCollector *collector) { + UINT32 hash = 0; + int i, j; + UINT8 *pool = collector->entropy_pool; + + /* Mix all jitter samples into the entropy pool */ + for (i = 0; i < ENTROPY_SAMPLE_COUNT && i < collector->sample_index; i++) { + UINT32 sample = collector->samples[i]; + + /* Jenkins one-at-a-time hash mixing */ + for (j = 0; j < sizeof(UINT32); j++) { + hash += (sample >> (j * 8)) & 0xFF; + hash += (hash << 10); + hash ^= (hash >> 6); + } + + /* XOR sample into pool at rotating position */ + pool[i % ENTROPY_BUFFER_SIZE] ^= (sample & 0xFF); + pool[(i + 1) % ENTROPY_BUFFER_SIZE] ^= ((sample >> 8) & 0xFF); + pool[(i + 2) % ENTROPY_BUFFER_SIZE] ^= ((sample >> 16) & 0xFF); + pool[(i + 3) % ENTROPY_BUFFER_SIZE] ^= ((sample >> 24) & 0xFF); + } + + /* Final mixing pass */ + for (i = 0; i < ENTROPY_BUFFER_SIZE; i++) { + hash += pool[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + pool[i] ^= (hash & 0xFF); + } + + /* Second mixing pass for avalanche effect */ + for (i = ENTROPY_BUFFER_SIZE - 1; i >= 0; i--) { + hash += pool[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + pool[i] ^= (hash & 0xFF); + } + + collector->pool_filled = 1; +} + +/******************************************************************************* +* collectEntropyFromInterruptJitter - Main function to collect entropy +* +* This function creates a watchdog timer that samples interrupt jitter +* by exploiting timing variations in the system tick interrupt handler. +* +* Returns: Pointer to entropy buffer (32 bytes) on success, NULL on failure +* +* Usage example: +* UINT8 *entropy = collectEntropyFromInterruptJitter(); +* if (entropy) { +* RAND_add(entropy, 32, 32.0); // Seed OpenSSL with 32 bytes of entropy +* free(entropy); +* } +* +* IMPORTANT: This function MUST be called from task context, NOT interrupt context. +* The watchdog callback runs in interrupt context, but the collection and mixing +* happen in the calling task's context. +*******************************************************************************/ +UINT8* collectEntropyFromInterruptJitter(void) { + EntropyCollector *collector; + UINT8 *result = NULL; + + +/*neelimaps*/ + sysTimestampEnable(); + UINT32 tick; + unsigned long freq; + + /* 2. Get the timestamp value */ + tick = sysTimestamp(); + + /* 3. Print it - Note: %u for unsigned int */ + printf("sysTimestamp = %u ticks in %s\n", tick, __func__); +/*neelimaps*/ + + /* Allocate collector structure (in task context - OK to use malloc) */ + collector = (EntropyCollector*)malloc(sizeof(EntropyCollector)); + if (collector == NULL) { + return NULL; + } + + /* Initialize collector */ + memset(collector, 0, sizeof(EntropyCollector)); + collector->last_tick = 0; + collector->sample_index = 0; + collector->pool_filled = 0; + + /* Create watchdog timer */ + collector->watchdog = wdCreate(); + if (collector->watchdog == NULL) { + free(collector); + return NULL; + } + + /* Start the first watchdog - initial delay of 1 tick */ + if (wdStart(collector->watchdog, 1, + (FUNCPTR)entropyWatchdogCallback, + (_Vx_usr_arg_t)collector) != OK) { + wdDelete(collector->watchdog); + free(collector); + return NULL; + } + + /* + * Wait for entropy collection to complete. + * In a real implementation, you'd want to add a timeout. + */ + while (collector->sample_index < ENTROPY_SAMPLE_COUNT) { + taskDelay(1); /* Yield to let watchdog callbacks run */ + } + + /* Stop and delete watchdog */ + wdCancel(collector->watchdog); + wdDelete(collector->watchdog); + + /* Mix collected samples into entropy pool */ + mixEntropyIntoPool(collector); + + /* Allocate and copy result */ + result = (UINT8*)malloc(ENTROPY_BUFFER_SIZE); + if (result) { + memcpy(result, collector->entropy_pool, ENTROPY_BUFFER_SIZE); + } + + /* Cleanup */ + free(collector); + + return result; +} + +void seedOpenSSLWithJitterEntropy(void) { + sysTimestampEnable(); + UINT8 *entropy = collectEntropyFromInterruptJitter(); + + if (entropy) { + /* Add 32 bytes of entropy with estimated 256 bits of randomness */ + RAND_add(entropy, ENTROPY_BUFFER_SIZE, ENTROPY_BUFFER_SIZE * 8.0); + free(entropy); + + printf("OpenSSL RNG seeded with interrupt jitter entropy\n"); + } else { + printf("Failed to collect entropy from interrupt jitter\n"); + } +} diff --git a/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/rand_vxworks.c b/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/rand_vxworks.c index 4a1fee7a..420f4158 100644 --- a/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/rand_vxworks.c +++ b/vxworks-6.9/target/src/openssl/OPENSSL/openssl-3.5.0/providers/implementations/rands/seeding/rand_vxworks.c @@ -16,6 +16,9 @@ #include "prov/seeding.h" #include #include +#include "sysLib.h" + +extern unsigned char *collectEntropyFromInterruptJitter(void); #if defined(OPENSSL_RAND_SEED_NONE) /* none means none */ @@ -36,7 +39,7 @@ int randSecure (void) { - return OK; + return 1; } STATUS randUBytes (unsigned char * randBuf, int numOfBytes) @@ -121,6 +124,50 @@ int ossl_pool_add_nonce_data(RAND_POOL *pool) size_t ossl_pool_acquire_entropy(RAND_POOL *pool) { +#ifdef VX69_TIMESTAMP_ENTROPY_SUPPORT + +#if defined(OPENSSL_SYS_VXWORKS) + /* vxRandLib based entropy method */ + size_t bytes_needed; + unsigned char *original_buffer; + + bytes_needed = ossl_rand_pool_bytes_needed(pool, 1 /*entropy_factor*/); + + if (bytes_needed > 0) { + int retryCount = 0; + STATUS result = ERROR; + unsigned char *buffer; + + buffer = ossl_rand_pool_add_begin(pool, bytes_needed); + original_buffer = buffer; + size_t needed; + needed = bytes_needed; + while (needed) { + if (needed < 32) { + memcpy(buffer,collectEntropyFromInterruptJitter(),needed); + needed = 0; + } + else { + memcpy(buffer, collectEntropyFromInterruptJitter(),32); + needed -= 32; + buffer += 32; + } + } + } + + ossl_rand_pool_add_end(pool, bytes_needed, 8 * bytes_needed); + return ossl_rand_pool_entropy_available(pool); +#else + /* + * SEED_NONE means none, without randlib we dont have entropy and + * rely on it being added externally + */ + return ossl_rand_pool_entropy_available(pool); +#endif /* defined(RAND_SEED_VXRANDLIB) */ + + +#else + #if defined(OPENSSL_SYS_VXWORKS) /* vxRandLib based entropy method */ size_t bytes_needed; @@ -165,4 +212,6 @@ size_t ossl_pool_acquire_entropy(RAND_POOL *pool) */ return ossl_rand_pool_entropy_available(pool); #endif /* defined(RAND_SEED_VXRANDLIB) */ + +#endif }