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