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 */ |
172 | |