Validate legacy_version
[openssl.git] / test / drbg_cavs_test.c
1 /*
2  * Copyright 2017-2018 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 <string.h>
11 #include "internal/nelem.h"
12 #include <openssl/crypto.h>
13 #include <openssl/err.h>
14 #include <openssl/rand.h>
15 #include <openssl/obj_mac.h>
16 #include <openssl/evp.h>
17 #include <openssl/aes.h>
18 #include "../crypto/rand/rand_lcl.h"
19
20 #include "testutil.h"
21 #include "drbg_cavs_data.h"
22
23 static int app_data_index;
24
25 typedef struct test_ctx_st {
26     const unsigned char *entropy;
27     size_t entropylen;
28     int entropycnt;
29     const unsigned char *nonce;
30     size_t noncelen;
31     int noncecnt;
32 } TEST_CTX;
33
34 static size_t kat_entropy(RAND_DRBG *drbg, unsigned char **pout,
35                           int entropy, size_t min_len, size_t max_len,
36                           int prediction_resistance)
37 {
38     TEST_CTX *t = (TEST_CTX *)RAND_DRBG_get_ex_data(drbg, app_data_index);
39
40     t->entropycnt++;
41     *pout = (unsigned char *)t->entropy;
42     return t->entropylen;
43 }
44
45 static size_t kat_nonce(RAND_DRBG *drbg, unsigned char **pout,
46                         int entropy, size_t min_len, size_t max_len)
47 {
48     TEST_CTX *t = (TEST_CTX *)RAND_DRBG_get_ex_data(drbg, app_data_index);
49
50     t->noncecnt++;
51     *pout = (unsigned char *)t->nonce;
52     return t->noncelen;
53 }
54
55 /*
56  * Do a single NO_RESEED KAT:
57  *
58  * Instantiate
59  * Generate Random Bits (pr=false)
60  * Generate Random Bits (pr=false)
61  * Uninstantiate
62  *
63  * Return 0 on failure.
64  */
65 static int single_kat_no_reseed(const struct drbg_kat *td)
66 {
67     struct drbg_kat_no_reseed *data = (struct drbg_kat_no_reseed *)td->t;
68     RAND_DRBG *drbg = NULL;
69     unsigned char *buff = NULL;
70     unsigned int flags = 0;
71     int failures = 0;
72     TEST_CTX t;
73
74     if (td->df != USE_DF)
75         flags |= RAND_DRBG_FLAG_CTR_NO_DF;
76
77     if (!TEST_ptr(drbg = RAND_DRBG_new(td->nid, flags, NULL)))
78         return 0;
79
80     if (!TEST_true(RAND_DRBG_set_callbacks(drbg, kat_entropy, NULL,
81                                            kat_nonce, NULL))) {
82         failures++;
83         goto err;
84     }
85     memset(&t, 0, sizeof(t));
86     t.entropy = data->entropyin;
87     t.entropylen = td->entropyinlen;
88     t.nonce = data->nonce;
89     t.noncelen = td->noncelen;
90     RAND_DRBG_set_ex_data(drbg, app_data_index, &t);
91
92     buff = OPENSSL_malloc(td->retbyteslen);
93     if (buff == NULL)
94         goto err;
95
96     if (!TEST_true(RAND_DRBG_instantiate(drbg, data->persstr, td->persstrlen))
97         || !TEST_true(RAND_DRBG_generate(drbg, buff, td->retbyteslen, 0,
98                                          data->addin1, td->addinlen))
99         || !TEST_true(RAND_DRBG_generate(drbg, buff, td->retbyteslen, 0,
100                                          data->addin2, td->addinlen))
101         || !TEST_true(RAND_DRBG_uninstantiate(drbg))
102         || !TEST_mem_eq(data->retbytes, td->retbyteslen, buff,
103                         td->retbyteslen))
104         failures++;
105
106 err:
107     if (buff != NULL)
108         OPENSSL_free(buff);
109     if (drbg != NULL) {
110         RAND_DRBG_uninstantiate(drbg);
111         RAND_DRBG_free(drbg);
112     }
113     return failures == 0;
114 }
115
116 /*-
117  * Do a single PR_FALSE KAT:
118  *
119  * Instantiate
120  * Reseed
121  * Generate Random Bits (pr=false)
122  * Generate Random Bits (pr=false)
123  * Uninstantiate
124  *
125  * Return 0 on failure.
126  */
127 static int single_kat_pr_false(const struct drbg_kat *td)
128 {
129     struct drbg_kat_pr_false *data = (struct drbg_kat_pr_false *)td->t;
130     RAND_DRBG *drbg = NULL;
131     unsigned char *buff = NULL;
132     unsigned int flags = 0;
133     int failures = 0;
134     TEST_CTX t;
135
136     if (td->df != USE_DF)
137         flags |= RAND_DRBG_FLAG_CTR_NO_DF;
138
139     if (!TEST_ptr(drbg = RAND_DRBG_new(td->nid, flags, NULL)))
140         return 0;
141
142     if (!TEST_true(RAND_DRBG_set_callbacks(drbg, kat_entropy, NULL,
143                                            kat_nonce, NULL))) {
144         failures++;
145         goto err;
146     }
147     memset(&t, 0, sizeof(t));
148     t.entropy = data->entropyin;
149     t.entropylen = td->entropyinlen;
150     t.nonce = data->nonce;
151     t.noncelen = td->noncelen;
152     RAND_DRBG_set_ex_data(drbg, app_data_index, &t);
153
154     buff = OPENSSL_malloc(td->retbyteslen);
155     if (buff == NULL)
156         goto err;
157
158     if (!TEST_true(RAND_DRBG_instantiate(drbg, data->persstr, td->persstrlen)))
159         failures++;
160
161     t.entropy = data->entropyinreseed;
162     t.entropylen = td->entropyinlen;
163
164     if (!TEST_true(RAND_DRBG_reseed(drbg, data->addinreseed, td->addinlen, 0))
165         || !TEST_true(RAND_DRBG_generate(drbg, buff, td->retbyteslen, 0,
166                                          data->addin1, td->addinlen))
167         || !TEST_true(RAND_DRBG_generate(drbg, buff, td->retbyteslen, 0,
168                                          data->addin2, td->addinlen))
169         || !TEST_true(RAND_DRBG_uninstantiate(drbg))
170         || !TEST_mem_eq(data->retbytes, td->retbyteslen, buff,
171                         td->retbyteslen))
172         failures++;
173
174 err:
175     if (buff != NULL)
176         OPENSSL_free(buff);
177     if (drbg != NULL) {
178         RAND_DRBG_uninstantiate(drbg);
179         RAND_DRBG_free(drbg);
180     }
181     return failures == 0;
182 }
183
184 /*-
185  * Do a single PR_TRUE KAT:
186  *
187  * Instantiate
188  * Generate Random Bits (pr=true)
189  * Generate Random Bits (pr=true)
190  * Uninstantiate
191  *
192  * Return 0 on failure.
193  */
194 static int single_kat_pr_true(const struct drbg_kat *td)
195 {
196     struct drbg_kat_pr_true *data = (struct drbg_kat_pr_true *)td->t;
197     RAND_DRBG *drbg = NULL;
198     unsigned char *buff = NULL;
199     unsigned int flags = 0;
200     int failures = 0;
201     TEST_CTX t;
202
203     if (td->df != USE_DF)
204         flags |= RAND_DRBG_FLAG_CTR_NO_DF;
205
206     if (!TEST_ptr(drbg = RAND_DRBG_new(td->nid, flags, NULL)))
207         return 0;
208
209     if (!TEST_true(RAND_DRBG_set_callbacks(drbg, kat_entropy, NULL,
210                                            kat_nonce, NULL))) {
211         failures++;
212         goto err;
213     }
214     memset(&t, 0, sizeof(t));
215     t.nonce = data->nonce;
216     t.noncelen = td->noncelen;
217     t.entropy = data->entropyin;
218     t.entropylen = td->entropyinlen;
219     RAND_DRBG_set_ex_data(drbg, app_data_index, &t);
220
221     buff = OPENSSL_malloc(td->retbyteslen);
222     if (buff == NULL)
223         goto err;
224
225     if (!TEST_true(RAND_DRBG_instantiate(drbg, data->persstr, td->persstrlen)))
226         failures++;
227
228     t.entropy = data->entropyinpr1;
229     t.entropylen = td->entropyinlen;
230
231     if (!TEST_true(RAND_DRBG_generate(drbg, buff, td->retbyteslen, 1,
232                                       data->addin1, td->addinlen)))
233         failures++;
234
235     t.entropy = data->entropyinpr2;
236     t.entropylen = td->entropyinlen;
237
238     if (!TEST_true(RAND_DRBG_generate(drbg, buff, td->retbyteslen, 1,
239                                       data->addin2, td->addinlen))
240         || !TEST_true(RAND_DRBG_uninstantiate(drbg))
241         || !TEST_mem_eq(data->retbytes, td->retbyteslen, buff,
242                         td->retbyteslen))
243         failures++;
244
245 err:
246     if (buff != NULL)
247         OPENSSL_free(buff);
248     if (drbg != NULL) {
249         RAND_DRBG_uninstantiate(drbg);
250         RAND_DRBG_free(drbg);
251     }
252     return failures == 0;
253 }
254
255 static int test_cavs_kats(int i)
256 {
257     const struct drbg_kat *td = drbg_test[i];
258     int rv = 0;
259
260     switch (td->type) {
261     case NO_RESEED:
262         if (!single_kat_no_reseed(td))
263             goto err;
264         break;
265     case PR_FALSE:
266         if (!single_kat_pr_false(td))
267             goto err;
268         break;
269     case PR_TRUE:
270         if (!single_kat_pr_true(td))
271             goto err;
272         break;
273     default:    /* cant happen */
274         goto err;
275     }
276     rv = 1;
277 err:
278     return rv;
279 }
280
281 int setup_tests(void)
282 {
283     app_data_index = RAND_DRBG_get_ex_new_index(0L, NULL, NULL, NULL, NULL);
284
285     ADD_ALL_TESTS(test_cavs_kats, drbg_test_nelem);
286     return 1;
287 }