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