providers/implementations/rands/seeding/rand_vxworks.c

   1 /*
   2  * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/opensslconf.h>
  11
  12 #include <openssl/rand.h>
  13 #include "crypto/rand_pool.h"
  14 #include "crypto/rand.h"
  15 #include "internal/cryptlib.h"
  16 #include "prov/seeding.h"
  17 #include <version.h>
  18 #include <taskLib.h>
  19
  20 #if defined(OPENSSL_RAND_SEED_NONE)
  21 /* none means none */
  22 # undef OPENSSL_RAND_SEED_OS
  23 #endif
  24
  25 #if defined(OPENSSL_RAND_SEED_OS)
  26 # if _WRS_VXWORKS_MAJOR >= 7
  27 #   define RAND_SEED_VXRANDLIB
  28 # else
  29 #   error "VxWorks <7 only support RAND_SEED_NONE"
  30 # endif
  31 #endif
  32
  33 #if defined(RAND_SEED_VXRANDLIB)
  34 # include <randomNumGen.h>
  35 #endif
  36
  37 /* Macro to convert two thirty two bit values into a sixty four bit one */
  38 #define TWO32TO64(a, b) ((((uint64_t)(a)) << 32) + (b))
  39
  40 static uint64_t get_time_stamp(void)
  41 {
  42     struct timespec ts;
  43
  44     if (clock_gettime(CLOCK_REALTIME, &ts) == 0)
  45         return TWO32TO64(ts.tv_sec, ts.tv_nsec);
  46     return time(NULL);
  47 }
  48
  49 static uint64_t get_timer_bits(void)
  50 {
  51     uint64_t res = OPENSSL_rdtsc();
  52     struct timespec ts;
  53
  54     if (res != 0)
  55         return res;
  56
  57     if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
  58         return TWO32TO64(ts.tv_sec, ts.tv_nsec);
  59     return time(NULL);
  60 }
  61
  62 /*
  63  * empty implementation
  64  * vxworks does not need to init/cleanup or keep open the random lib
  65  */
  66 int rand_pool_init(void)
  67 {
  68     return 1;
  69 }
  70
  71 void rand_pool_cleanup(void)
  72 {
  73 }
  74
  75 void rand_pool_keep_random_devices_open(int keep)
  76 {
  77 }
  78
  79 int rand_pool_add_additional_data(RAND_POOL *pool)
  80 {
  81     struct {
  82         CRYPTO_THREAD_ID tid;
  83         uint64_t time;
  84     } data;
  85
  86     memset(&data, 0, sizeof(data));
  87
  88     /*
  89      * Add some noise from the thread id and a high resolution timer.
  90      * The thread id adds a little randomness if the drbg is accessed
  91      * concurrently (which is the case for the <master> drbg).
  92      */
  93     data.tid = CRYPTO_THREAD_get_current_id();
  94     data.time = get_timer_bits();
  95
  96     return rand_pool_add(pool, (unsigned char *)&data, sizeof(data), 0);
  97 }
  98
  99 int ossl_pool_add_nonce_data(RAND_POOL *pool)
 100 {
 101     struct {
 102         pid_t pid;
 103         CRYPTO_THREAD_ID tid;
 104         uint64_t time;
 105     } data;
 106
 107     memset(&data, 0, sizeof(data));
 108
 109     /*
 110      * Add process id, thread id, and a high resolution timestamp to
 111      * ensure that the nonce is unique with high probability for
 112      * different process instances.
 113      */
 114     data.pid = getpid();
 115     data.tid = CRYPTO_THREAD_get_current_id();
 116     data.time = get_time_stamp();
 117
 118     return rand_pool_add(pool, (unsigned char *)&data, sizeof(data), 0);
 119 }
 120
 121 size_t ossl_pool_acquire_entropy(RAND_POOL *pool)
 122 {
 123 #if defined(RAND_SEED_VXRANDLIB)
 124     /* vxRandLib based entropy method */
 125     size_t bytes_needed;
 126
 127     bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
 128     if (bytes_needed > 0)
 129     {
 130         int retryCount = 0;
 131         STATUS result = ERROR;
 132         unsigned char *buffer;
 133
 134         buffer = rand_pool_add_begin(pool, bytes_needed);
 135         while ((result != OK) && (retryCount < 10)) {
 136             RANDOM_NUM_GEN_STATUS status = randStatus();
 137
 138             if ((status == RANDOM_NUM_GEN_ENOUGH_ENTROPY)
 139                     || (status == RANDOM_NUM_GEN_MAX_ENTROPY) ) {
 140                 result = randBytes(buffer, bytes_needed);
 141                 if (result == OK)
 142                     rand_pool_add_end(pool, bytes_needed, 8 * bytes_needed);
 143                 /*
 144                  * no else here: randStatus said ok, if randBytes failed
 145                  * it will result in another loop or no entropy
 146                  */
 147             } else {
 148                 /*
 149                  * give a minimum delay here to allow OS to collect more
 150                  * entropy. taskDelay duration will depend on the system tick,
 151                  * this is by design as the sw-random lib uses interrupts
 152                  * which will at least happen during ticks
 153                  */
 154                 taskDelay(5);
 155             }
 156             retryCount++;
 157         }
 158     }
 159     return rand_pool_entropy_available(pool);
 160 #else
 161     /*
 162      * SEED_NONE means none, without randlib we dont have entropy and
 163      * rely on it being added externally
 164      */
 165     return rand_pool_entropy_available(pool);
 166 #endif /* defined(RAND_SEED_VXRANDLIB) */
 167 }