VirtualBox

source: vbox/trunk/src/libs/openssl-3.1.0/test/asn1_time_test.c@ 100111

Last change on this file since 100111 was 99366, checked in by vboxsync, 21 months ago

openssl-3.1.0: Applied and adjusted our OpenSSL changes to 3.0.7. bugref:10418
File size: 17.7 KB
Line 
1/*
2 * Copyright 1999-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/* Time tests for the asn1 module */
11
12#include <stdio.h>
13#include <string.h>
14
15#include <openssl/asn1.h>
16#include <openssl/evp.h>
17#include <openssl/objects.h>
18#include "testutil.h"
19#include "internal/nelem.h"
20
21struct testdata {
22 char *data; /* TIME string value */
23 int type; /* GENERALIZED OR UTC */
24 int expected_type; /* expected type after set/set_string_gmt */
25 int check_result; /* check result */
26 time_t t; /* expected time_t*/
27 int cmp_result; /* comparison to baseline result */
28 int convert_result; /* conversion result */
29};
30
31static struct testdata tbl_testdata_pos[] = {
32 { "0", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, }, /* Bad time */
33 { "ABCD", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
34 { "0ABCD", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
35 { "1-700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
36 { "`9700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
37 { "19700101000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
38 { "A00101000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
39 { "A9700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
40 { "1A700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
41 { "19A00101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
42 { "197A0101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
43 { "1970A101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
44 { "19700A01000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
45 { "197001A1000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
46 { "1970010A000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
47 { "19700101A00000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
48 { "197001010A0000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
49 { "1970010100A000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
50 { "19700101000A00Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
51 { "197001010000A0Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
52 { "1970010100000AZ", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
53 { "700101000000X", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
54 { "19700101000000X", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
55 { "19700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 0, -1, 1, }, /* Epoch begins */
56 { "700101000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 0, -1, 1, }, /* ditto */
57 { "20380119031407Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 0x7FFFFFFF, 1, 1, }, /* Max 32bit time_t */
58 { "380119031407Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 0x7FFFFFFF, 1, 1, },
59 { "20371231235959Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 2145916799, 1, 1, }, /* Just before 2038 */
60 { "20371231235959Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 1, }, /* Bad UTC time */
61 { "371231235959Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 2145916799, 1, 1, },
62 { "19701006121456Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 24063296, -1, 1, },
63 { "701006121456Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 24063296, -1, 1, },
64 { "19991231000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, }, /* Match baseline */
65 { "199912310000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, }, /* In various flavors */
66 { "991231000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
67 { "9912310000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
68 { "9912310000+0000", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
69 { "199912310000+0000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
70 { "9912310000-0000", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
71 { "199912310000-0000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
72 { "199912310100+0100", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
73 { "199912302300-0100", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
74 { "199912302300-A000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 0, 946598400, 0, 1, },
75 { "199912302300-0A00", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 0, 946598400, 0, 1, },
76 { "9912310100+0100", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
77 { "9912302300-0100", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
78};
79
80/* ASSUMES SIGNED TIME_T */
81static struct testdata tbl_testdata_neg[] = {
82 { "19011213204552Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, INT_MIN, -1, 0, },
83 { "691006121456Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, -7472704, -1, 1, },
84 { "19691006121456Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, -7472704, -1, 1, },
85};
86
87/* explicit casts to time_t short warnings on systems with 32-bit time_t */
88static struct testdata tbl_testdata_pos_64bit[] = {
89 { "20380119031408Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, (time_t)0x80000000, 1, 1, },
90 { "20380119031409Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, (time_t)0x80000001, 1, 1, },
91 { "380119031408Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, (time_t)0x80000000, 1, 1, },
92 { "20500101120000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)0x967b1ec0, 1, 0, },
93};
94
95/* ASSUMES SIGNED TIME_T */
96static struct testdata tbl_testdata_neg_64bit[] = {
97 { "19011213204551Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)-2147483649LL, -1, 0, },
98 { "19000101120000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)-2208945600LL, -1, 0, },
99};
100
101/* A baseline time to compare to */
102static ASN1_TIME gtime = {
103 15,
104 V_ASN1_GENERALIZEDTIME,
105 (unsigned char*)"19991231000000Z",
106 0
107};
108static time_t gtime_t = 946598400;
109
110static int test_table(struct testdata *tbl, int idx)
111{
112 int error = 0;
113 ASN1_TIME atime;
114 ASN1_TIME *ptime;
115 struct testdata *td = &tbl[idx];
116 int day, sec;
117
118 atime.data = (unsigned char*)td->data;
119 atime.length = strlen((char*)atime.data);
120 atime.type = td->type;
121 atime.flags = 0;
122
123 if (!TEST_int_eq(ASN1_TIME_check(&atime), td->check_result)) {
124 TEST_info("ASN1_TIME_check(%s) unexpected result", atime.data);
125 error = 1;
126 }
127 if (td->check_result == 0)
128 return 1;
129
130 if (!TEST_int_eq(ASN1_TIME_cmp_time_t(&atime, td->t), 0)) {
131 TEST_info("ASN1_TIME_cmp_time_t(%s vs %ld) compare failed", atime.data, (long)td->t);
132 error = 1;
133 }
134
135 if (!TEST_true(ASN1_TIME_diff(&day, &sec, &atime, &atime))) {
136 TEST_info("ASN1_TIME_diff(%s) to self failed", atime.data);
137 error = 1;
138 }
139 if (!TEST_int_eq(day, 0) || !TEST_int_eq(sec, 0)) {
140 TEST_info("ASN1_TIME_diff(%s) to self not equal", atime.data);
141 error = 1;
142 }
143
144 if (!TEST_true(ASN1_TIME_diff(&day, &sec, &gtime, &atime))) {
145 TEST_info("ASN1_TIME_diff(%s) to baseline failed", atime.data);
146 error = 1;
147 } else if (!((td->cmp_result == 0 && TEST_true((day == 0 && sec == 0))) ||
148 (td->cmp_result == -1 && TEST_true((day < 0 || sec < 0))) ||
149 (td->cmp_result == 1 && TEST_true((day > 0 || sec > 0))))) {
150 TEST_info("ASN1_TIME_diff(%s) to baseline bad comparison", atime.data);
151 error = 1;
152 }
153
154 if (!TEST_int_eq(ASN1_TIME_cmp_time_t(&atime, gtime_t), td->cmp_result)) {
155 TEST_info("ASN1_TIME_cmp_time_t(%s) to baseline bad comparison", atime.data);
156 error = 1;
157 }
158
159 ptime = ASN1_TIME_set(NULL, td->t);
160 if (!TEST_ptr(ptime)) {
161 TEST_info("ASN1_TIME_set(%ld) failed", (long)td->t);
162 error = 1;
163 } else {
164 int local_error = 0;
165 if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, td->t), 0)) {
166 TEST_info("ASN1_TIME_set(%ld) compare failed (%s->%s)",
167 (long)td->t, td->data, ptime->data);
168 local_error = error = 1;
169 }
170 if (!TEST_int_eq(ptime->type, td->expected_type)) {
171 TEST_info("ASN1_TIME_set(%ld) unexpected type", (long)td->t);
172 local_error = error = 1;
173 }
174 if (local_error)
175 TEST_info("ASN1_TIME_set() = %*s", ptime->length, ptime->data);
176 ASN1_TIME_free(ptime);
177 }
178
179 ptime = ASN1_TIME_new();
180 if (!TEST_ptr(ptime)) {
181 TEST_info("ASN1_TIME_new() failed");
182 error = 1;
183 } else {
184 int local_error = 0;
185 if (!TEST_int_eq(ASN1_TIME_set_string(ptime, td->data), td->check_result)) {
186 TEST_info("ASN1_TIME_set_string_gmt(%s) failed", td->data);
187 local_error = error = 1;
188 }
189 if (!TEST_int_eq(ASN1_TIME_normalize(ptime), td->check_result)) {
190 TEST_info("ASN1_TIME_normalize(%s) failed", td->data);
191 local_error = error = 1;
192 }
193 if (!TEST_int_eq(ptime->type, td->expected_type)) {
194 TEST_info("ASN1_TIME_set_string_gmt(%s) unexpected type", td->data);
195 local_error = error = 1;
196 }
197 day = sec = 0;
198 if (!TEST_true(ASN1_TIME_diff(&day, &sec, ptime, &atime)) || !TEST_int_eq(day, 0) || !TEST_int_eq(sec, 0)) {
199 TEST_info("ASN1_TIME_diff(day=%d, sec=%d, %s) after ASN1_TIME_set_string_gmt() failed", day, sec, td->data);
200 local_error = error = 1;
201 }
202 if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, gtime_t), td->cmp_result)) {
203 TEST_info("ASN1_TIME_cmp_time_t(%s) after ASN1_TIME_set_string_gnt() to baseline bad comparison", td->data);
204 local_error = error = 1;
205 }
206 if (local_error)
207 TEST_info("ASN1_TIME_set_string_gmt() = %*s", ptime->length, ptime->data);
208 ASN1_TIME_free(ptime);
209 }
210
211 ptime = ASN1_TIME_new();
212 if (!TEST_ptr(ptime)) {
213 TEST_info("ASN1_TIME_new() failed");
214 error = 1;
215 } else {
216 int local_error = 0;
217 if (!TEST_int_eq(ASN1_TIME_set_string(ptime, td->data), td->check_result)) {
218 TEST_info("ASN1_TIME_set_string(%s) failed", td->data);
219 local_error = error = 1;
220 }
221 day = sec = 0;
222 if (!TEST_true(ASN1_TIME_diff(&day, &sec, ptime, &atime)) || !TEST_int_eq(day, 0) || !TEST_int_eq(sec, 0)) {
223 TEST_info("ASN1_TIME_diff(day=%d, sec=%d, %s) after ASN1_TIME_set_string() failed", day, sec, td->data);
224 local_error = error = 1;
225 }
226 if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, gtime_t), td->cmp_result)) {
227 TEST_info("ASN1_TIME_cmp_time_t(%s) after ASN1_TIME_set_string() to baseline bad comparison", td->data);
228 local_error = error = 1;
229 }
230 if (local_error)
231 TEST_info("ASN1_TIME_set_string() = %*s", ptime->length, ptime->data);
232 ASN1_TIME_free(ptime);
233 }
234
235 if (td->type == V_ASN1_UTCTIME) {
236 ptime = ASN1_TIME_to_generalizedtime(&atime, NULL);
237 if (td->convert_result == 1 && !TEST_ptr(ptime)) {
238 TEST_info("ASN1_TIME_to_generalizedtime(%s) failed", atime.data);
239 error = 1;
240 } else if (td->convert_result == 0 && !TEST_ptr_null(ptime)) {
241 TEST_info("ASN1_TIME_to_generalizedtime(%s) should have failed", atime.data);
242 error = 1;
243 }
244 if (ptime != NULL && !TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, td->t), 0)) {
245 TEST_info("ASN1_TIME_to_generalizedtime(%s->%s) bad result", atime.data, ptime->data);
246 error = 1;
247 }
248 ASN1_TIME_free(ptime);
249 }
250 /* else cannot simply convert GENERALIZEDTIME to UTCTIME */
251
252 if (error)
253 TEST_error("atime=%s", atime.data);
254
255 return !error;
256}
257
258static int test_table_pos(int idx)
259{
260 return test_table(tbl_testdata_pos, idx);
261}
262
263static int test_table_neg(int idx)
264{
265 return test_table(tbl_testdata_neg, idx);
266}
267
268static int test_table_pos_64bit(int idx)
269{
270 return test_table(tbl_testdata_pos_64bit, idx);
271}
272
273static int test_table_neg_64bit(int idx)
274{
275 return test_table(tbl_testdata_neg_64bit, idx);
276}
277
278struct compare_testdata {
279 ASN1_TIME t1;
280 ASN1_TIME t2;
281 int result;
282};
283
284static unsigned char TODAY_GEN_STR[] = "20170825000000Z";
285static unsigned char TOMORROW_GEN_STR[] = "20170826000000Z";
286static unsigned char TODAY_UTC_STR[] = "170825000000Z";
287static unsigned char TOMORROW_UTC_STR[] = "170826000000Z";
288
289#define TODAY_GEN { sizeof(TODAY_GEN_STR)-1, V_ASN1_GENERALIZEDTIME, TODAY_GEN_STR, 0 }
290#define TOMORROW_GEN { sizeof(TOMORROW_GEN_STR)-1, V_ASN1_GENERALIZEDTIME, TOMORROW_GEN_STR, 0 }
291#define TODAY_UTC { sizeof(TODAY_UTC_STR)-1, V_ASN1_UTCTIME, TODAY_UTC_STR, 0 }
292#define TOMORROW_UTC { sizeof(TOMORROW_UTC_STR)-1, V_ASN1_UTCTIME, TOMORROW_UTC_STR, 0 }
293
294static struct compare_testdata tbl_compare_testdata[] = {
295 { TODAY_GEN, TODAY_GEN, 0 },
296 { TODAY_GEN, TODAY_UTC, 0 },
297 { TODAY_GEN, TOMORROW_GEN, -1 },
298 { TODAY_GEN, TOMORROW_UTC, -1 },
299
300 { TODAY_UTC, TODAY_GEN, 0 },
301 { TODAY_UTC, TODAY_UTC, 0 },
302 { TODAY_UTC, TOMORROW_GEN, -1 },
303 { TODAY_UTC, TOMORROW_UTC, -1 },
304
305 { TOMORROW_GEN, TODAY_GEN, 1 },
306 { TOMORROW_GEN, TODAY_UTC, 1 },
307 { TOMORROW_GEN, TOMORROW_GEN, 0 },
308 { TOMORROW_GEN, TOMORROW_UTC, 0 },
309
310 { TOMORROW_UTC, TODAY_GEN, 1 },
311 { TOMORROW_UTC, TODAY_UTC, 1 },
312 { TOMORROW_UTC, TOMORROW_GEN, 0 },
313 { TOMORROW_UTC, TOMORROW_UTC, 0 }
314};
315
316static int test_table_compare(int idx)
317{
318 struct compare_testdata *td = &tbl_compare_testdata[idx];
319
320 return TEST_int_eq(ASN1_TIME_compare(&td->t1, &td->t2), td->result);
321}
322
323static int test_time_dup(void)
324{
325 int ret = 0;
326 ASN1_TIME *asn1_time = NULL;
327 ASN1_TIME *asn1_time_dup = NULL;
328 ASN1_TIME *asn1_gentime = NULL;
329
330 asn1_time = ASN1_TIME_adj(NULL, time(NULL), 0, 0);
331 if (asn1_time == NULL) {
332 TEST_info("Internal error.");
333 goto err;
334 }
335
336 asn1_gentime = ASN1_TIME_to_generalizedtime(asn1_time, NULL);
337 if (asn1_gentime == NULL) {
338 TEST_info("Internal error.");
339 goto err;
340 }
341
342 asn1_time_dup = ASN1_TIME_dup(asn1_time);
343 if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
344 TEST_info("ASN1_TIME_dup() failed.");
345 goto err;
346 }
347 if (!TEST_int_eq(ASN1_TIME_compare(asn1_time, asn1_time_dup), 0)) {
348 TEST_info("ASN1_TIME_dup() duplicated non-identical value.");
349 goto err;
350 }
351 ASN1_STRING_free(asn1_time_dup);
352
353 asn1_time_dup = ASN1_UTCTIME_dup(asn1_time);
354 if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
355 TEST_info("ASN1_UTCTIME_dup() failed.");
356 goto err;
357 }
358 if (!TEST_int_eq(ASN1_TIME_compare(asn1_time, asn1_time_dup), 0)) {
359 TEST_info("ASN1_UTCTIME_dup() duplicated non-identical UTCTIME value.");
360 goto err;
361 }
362 ASN1_STRING_free(asn1_time_dup);
363
364 asn1_time_dup = ASN1_GENERALIZEDTIME_dup(asn1_gentime);
365 if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
366 TEST_info("ASN1_GENERALIZEDTIME_dup() failed.");
367 goto err;
368 }
369 if (!TEST_int_eq(ASN1_TIME_compare(asn1_gentime, asn1_time_dup), 0)) {
370 TEST_info("ASN1_GENERALIZEDTIME_dup() dup'ed non-identical value.");
371 goto err;
372 }
373
374 ret = 1;
375 err:
376 ASN1_STRING_free(asn1_time);
377 ASN1_STRING_free(asn1_gentime);
378 ASN1_STRING_free(asn1_time_dup);
379 return ret;
380}
381
382int setup_tests(void)
383{
384 /*
385 * On platforms where |time_t| is an unsigned integer, t will be a
386 * positive number.
387 *
388 * We check if we're on a platform with a signed |time_t| with '!(t > 0)'
389 * because some compilers are picky if you do 't < 0', or even 't <= 0'
390 * if |t| is unsigned.
391 */
392 time_t t = -1;
393 /*
394 * On some platforms, |time_t| is signed, but a negative value is an
395 * error, and using it with gmtime() or localtime() generates a NULL.
396 * If that is the case, we can't perform tests on negative values.
397 */
398 struct tm *ptm = localtime(&t);
399
400 ADD_ALL_TESTS(test_table_pos, OSSL_NELEM(tbl_testdata_pos));
401 if (!(t > 0) && ptm != NULL) {
402 TEST_info("Adding negative-sign time_t tests");
403 ADD_ALL_TESTS(test_table_neg, OSSL_NELEM(tbl_testdata_neg));
404 }
405 if (sizeof(time_t) > sizeof(uint32_t)) {
406 TEST_info("Adding 64-bit time_t tests");
407 ADD_ALL_TESTS(test_table_pos_64bit, OSSL_NELEM(tbl_testdata_pos_64bit));
408#ifndef __hpux
409 if (!(t > 0) && ptm != NULL) {
410 TEST_info("Adding negative-sign 64-bit time_t tests");
411 ADD_ALL_TESTS(test_table_neg_64bit, OSSL_NELEM(tbl_testdata_neg_64bit));
412 }
413#endif
414 }
415 ADD_ALL_TESTS(test_table_compare, OSSL_NELEM(tbl_compare_testdata));
416 ADD_TEST(test_time_dup);
417 return 1;
418}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette