1 /*
2 * Copyright 2017-2021 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 "../testutil.h"
11 #include "output.h"
12 #include "tu_local.h"
13
14 #include <string.h>
15 #include <ctype.h>
16 #include "internal/nelem.h"
17
18 /* The size of memory buffers to display on failure */
19 #define MEM_BUFFER_SIZE (2000)
20 #define MAX_STRING_WIDTH (80)
21 #define BN_OUTPUT_SIZE (8)
22
23 /* Output a diff header */
test_diff_header(const char * left,const char * right)24 static void test_diff_header(const char *left, const char *right)
25 {
26 test_printf_stderr("--- %s\n", left);
27 test_printf_stderr("+++ %s\n", right);
28 }
29
30 /* Formatted string output routines */
test_string_null_empty(const char * m,char c)31 static void test_string_null_empty(const char *m, char c)
32 {
33 if (m == NULL)
34 test_printf_stderr("% 4s %c NULL\n", "", c);
35 else
36 test_printf_stderr("% 4u:%c ''\n", 0u, c);
37 }
38
test_fail_string_common(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const char * m1,size_t l1,const char * m2,size_t l2)39 static void test_fail_string_common(const char *prefix, const char *file,
40 int line, const char *type,
41 const char *left, const char *right,
42 const char *op, const char *m1, size_t l1,
43 const char *m2, size_t l2)
44 {
45 const size_t width = (MAX_STRING_WIDTH - subtest_level() - 12) / 16 * 16;
46 char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
47 char bdiff[MAX_STRING_WIDTH + 1];
48 size_t n1, n2, i;
49 unsigned int cnt = 0, diff;
50
51 test_fail_message_prefix(prefix, file, line, type, left, right, op);
52 if (m1 == NULL)
53 l1 = 0;
54 if (m2 == NULL)
55 l2 = 0;
56 if (l1 == 0 && l2 == 0) {
57 if ((m1 == NULL) == (m2 == NULL)) {
58 test_string_null_empty(m1, ' ');
59 } else {
60 test_diff_header(left, right);
61 test_string_null_empty(m1, '-');
62 test_string_null_empty(m2, '+');
63 }
64 goto fin;
65 }
66
67 if (l1 != l2 || strcmp(m1, m2) != 0)
68 test_diff_header(left, right);
69
70 while (l1 > 0 || l2 > 0) {
71 n1 = n2 = 0;
72 if (l1 > 0) {
73 b1[n1 = l1 > width ? width : l1] = 0;
74 for (i = 0; i < n1; i++)
75 b1[i] = isprint((unsigned char)m1[i]) ? m1[i] : '.';
76 }
77 if (l2 > 0) {
78 b2[n2 = l2 > width ? width : l2] = 0;
79 for (i = 0; i < n2; i++)
80 b2[i] = isprint((unsigned char)m2[i]) ? m2[i] : '.';
81 }
82 diff = 0;
83 i = 0;
84 if (n1 > 0 && n2 > 0) {
85 const size_t j = n1 < n2 ? n1 : n2;
86
87 for (; i < j; i++)
88 if (m1[i] == m2[i]) {
89 bdiff[i] = ' ';
90 } else {
91 bdiff[i] = '^';
92 diff = 1;
93 }
94 bdiff[i] = '\0';
95 }
96 if (n1 == n2 && !diff) {
97 test_printf_stderr("% 4u: '%s'\n", cnt, n2 > n1 ? b2 : b1);
98 } else {
99 if (cnt == 0 && (m1 == NULL || *m1 == '\0'))
100 test_string_null_empty(m1, '-');
101 else if (n1 > 0)
102 test_printf_stderr("% 4u:- '%s'\n", cnt, b1);
103 if (cnt == 0 && (m2 == NULL || *m2 == '\0'))
104 test_string_null_empty(m2, '+');
105 else if (n2 > 0)
106 test_printf_stderr("% 4u:+ '%s'\n", cnt, b2);
107 if (diff && i > 0)
108 test_printf_stderr("% 4s %s\n", "", bdiff);
109 }
110 if (m1 != NULL)
111 m1 += n1;
112 if (m2 != NULL)
113 m2 += n2;
114 l1 -= n1;
115 l2 -= n2;
116 cnt += width;
117 }
118 fin:
119 test_flush_stderr();
120 }
121
122 /*
123 * Wrapper routines so that the underlying code can be shared.
124 * The first is the call from inside the test utilities when a conditional
125 * fails. The second is the user's call to dump a string.
126 */
test_fail_string_message(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const char * m1,size_t l1,const char * m2,size_t l2)127 void test_fail_string_message(const char *prefix, const char *file,
128 int line, const char *type,
129 const char *left, const char *right,
130 const char *op, const char *m1, size_t l1,
131 const char *m2, size_t l2)
132 {
133 test_fail_string_common(prefix, file, line, type, left, right, op,
134 m1, l1, m2, l2);
135 test_printf_stderr("\n");
136 }
137
test_output_string(const char * name,const char * m,size_t l)138 void test_output_string(const char *name, const char *m, size_t l)
139 {
140 test_fail_string_common("string", NULL, 0, NULL, NULL, NULL, name,
141 m, l, m, l);
142 }
143
144 /* BIGNUM formatted output routines */
145
146 /*
147 * A basic memory byte to hex digit converter with allowance for spacing
148 * every so often.
149 */
hex_convert_memory(const unsigned char * m,size_t n,char * b,size_t width)150 static void hex_convert_memory(const unsigned char *m, size_t n, char *b,
151 size_t width)
152 {
153 size_t i;
154
155 for (i = 0; i < n; i++) {
156 const unsigned char c = *m++;
157
158 *b++ = "0123456789abcdef"[c >> 4];
159 *b++ = "0123456789abcdef"[c & 15];
160 if (i % width == width - 1 && i != n - 1)
161 *b++ = ' ';
162 }
163 *b = '\0';
164 }
165
166 /*
167 * Constants to define the number of bytes to display per line and the number
168 * of characters these take.
169 */
170 static const int bn_bytes = (MAX_STRING_WIDTH - 9) / (BN_OUTPUT_SIZE * 2 + 1)
171 * BN_OUTPUT_SIZE;
172 static const int bn_chars = (MAX_STRING_WIDTH - 9) / (BN_OUTPUT_SIZE * 2 + 1)
173 * (BN_OUTPUT_SIZE * 2 + 1) - 1;
174
175 /*
176 * Output the header line for the bignum
177 */
test_bignum_header_line(void)178 static void test_bignum_header_line(void)
179 {
180 test_printf_stderr(" %*s\n", bn_chars + 6, "bit position");
181 }
182
test_bignum_zero_null(const BIGNUM * bn)183 static const char *test_bignum_zero_null(const BIGNUM *bn)
184 {
185 if (bn != NULL)
186 return BN_is_negative(bn) ? "-0" : "0";
187 return "NULL";
188 }
189
190 /*
191 * Print a bignum zero taking care to include the correct sign.
192 * This routine correctly deals with a NULL bignum pointer as input.
193 */
test_bignum_zero_print(const BIGNUM * bn,char sep)194 static void test_bignum_zero_print(const BIGNUM *bn, char sep)
195 {
196 const char *v = test_bignum_zero_null(bn);
197 const char *suf = bn != NULL ? ": 0" : "";
198
199 test_printf_stderr("%c%*s%s\n", sep, bn_chars, v, suf);
200 }
201
202 /*
203 * Convert a section of memory from inside a bignum into a displayable
204 * string with appropriate visual aid spaces inserted.
205 */
convert_bn_memory(const unsigned char * in,size_t bytes,char * out,int * lz,const BIGNUM * bn)206 static int convert_bn_memory(const unsigned char *in, size_t bytes,
207 char *out, int *lz, const BIGNUM *bn)
208 {
209 int n = bytes * 2, i;
210 char *p = out, *q = NULL;
211
212 if (bn != NULL && !BN_is_zero(bn)) {
213 hex_convert_memory(in, bytes, out, BN_OUTPUT_SIZE);
214 if (*lz) {
215 for (; *p == '0' || *p == ' '; p++)
216 if (*p == '0') {
217 q = p;
218 *p = ' ';
219 n--;
220 }
221 if (*p == '\0') {
222 /*
223 * in[bytes] is defined because we're converting a non-zero
224 * number and we've not seen a non-zero yet.
225 */
226 if ((in[bytes] & 0xf0) != 0 && BN_is_negative(bn)) {
227 *lz = 0;
228 *q = '-';
229 n++;
230 }
231 } else {
232 *lz = 0;
233 if (BN_is_negative(bn)) {
234 /*
235 * This is valid because we always convert more digits than
236 * the number holds.
237 */
238 *q = '-';
239 n++;
240 }
241 }
242 }
243 return n;
244 }
245
246 for (i = 0; i < n; i++) {
247 *p++ = ' ';
248 if (i % (2 * BN_OUTPUT_SIZE) == 2 * BN_OUTPUT_SIZE - 1 && i != n - 1)
249 *p++ = ' ';
250 }
251 *p = '\0';
252 if (bn == NULL)
253 q = "NULL";
254 else
255 q = BN_is_negative(bn) ? "-0" : "0";
256 strcpy(p - strlen(q), q);
257 return 0;
258 }
259
260 /*
261 * Common code to display either one or two bignums, including the diff
262 * pointers for changes (only when there are two).
263 */
test_fail_bignum_common(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const BIGNUM * bn1,const BIGNUM * bn2)264 static void test_fail_bignum_common(const char *prefix, const char *file,
265 int line, const char *type,
266 const char *left, const char *right,
267 const char *op,
268 const BIGNUM *bn1, const BIGNUM *bn2)
269 {
270 const size_t bytes = bn_bytes;
271 char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
272 char *p, bdiff[MAX_STRING_WIDTH + 1];
273 size_t l1, l2, n1, n2, i, len;
274 unsigned int cnt, diff, real_diff;
275 unsigned char *m1 = NULL, *m2 = NULL;
276 int lz1 = 1, lz2 = 1;
277 unsigned char buffer[MEM_BUFFER_SIZE * 2], *bufp = buffer;
278
279 test_fail_message_prefix(prefix, file, line, type, left, right, op);
280 l1 = bn1 == NULL ? 0 : (BN_num_bytes(bn1) + (BN_is_negative(bn1) ? 1 : 0));
281 l2 = bn2 == NULL ? 0 : (BN_num_bytes(bn2) + (BN_is_negative(bn2) ? 1 : 0));
282 if (l1 == 0 && l2 == 0) {
283 if ((bn1 == NULL) == (bn2 == NULL)) {
284 test_bignum_header_line();
285 test_bignum_zero_print(bn1, ' ');
286 } else {
287 test_diff_header(left, right);
288 test_bignum_header_line();
289 test_bignum_zero_print(bn1, '-');
290 test_bignum_zero_print(bn2, '+');
291 }
292 goto fin;
293 }
294
295 if (l1 != l2 || bn1 == NULL || bn2 == NULL || BN_cmp(bn1, bn2) != 0)
296 test_diff_header(left, right);
297 test_bignum_header_line();
298
299 len = ((l1 > l2 ? l1 : l2) + bytes - 1) / bytes * bytes;
300
301 if (len > MEM_BUFFER_SIZE && (bufp = OPENSSL_malloc(len * 2)) == NULL) {
302 bufp = buffer;
303 len = MEM_BUFFER_SIZE;
304 test_printf_stderr("WARNING: these BIGNUMs have been truncated\n");
305 }
306
307 if (bn1 != NULL) {
308 m1 = bufp;
309 BN_bn2binpad(bn1, m1, len);
310 }
311 if (bn2 != NULL) {
312 m2 = bufp + len;
313 BN_bn2binpad(bn2, m2, len);
314 }
315
316 while (len > 0) {
317 cnt = 8 * (len - bytes);
318 n1 = convert_bn_memory(m1, bytes, b1, &lz1, bn1);
319 n2 = convert_bn_memory(m2, bytes, b2, &lz2, bn2);
320
321 diff = real_diff = 0;
322 i = 0;
323 p = bdiff;
324 for (i=0; b1[i] != '\0'; i++)
325 if (b1[i] == b2[i] || b1[i] == ' ' || b2[i] == ' ') {
326 *p++ = ' ';
327 diff |= b1[i] != b2[i];
328 } else {
329 *p++ = '^';
330 real_diff = diff = 1;
331 }
332 *p++ = '\0';
333 if (!diff) {
334 test_printf_stderr(" %s:% 5d\n", n2 > n1 ? b2 : b1, cnt);
335 } else {
336 if (cnt == 0 && bn1 == NULL)
337 test_printf_stderr("-%s\n", b1);
338 else if (cnt == 0 || n1 > 0)
339 test_printf_stderr("-%s:% 5d\n", b1, cnt);
340 if (cnt == 0 && bn2 == NULL)
341 test_printf_stderr("+%s\n", b2);
342 else if (cnt == 0 || n2 > 0)
343 test_printf_stderr("+%s:% 5d\n", b2, cnt);
344 if (real_diff && (cnt == 0 || (n1 > 0 && n2 > 0))
345 && bn1 != NULL && bn2 != NULL)
346 test_printf_stderr(" %s\n", bdiff);
347 }
348 if (m1 != NULL)
349 m1 += bytes;
350 if (m2 != NULL)
351 m2 += bytes;
352 len -= bytes;
353 }
354 fin:
355 test_flush_stderr();
356 if (bufp != buffer)
357 OPENSSL_free(bufp);
358 }
359
360 /*
361 * Wrapper routines so that the underlying code can be shared.
362 * The first two are calls from inside the test utilities when a conditional
363 * fails. The third is the user's call to dump a bignum.
364 */
test_fail_bignum_message(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const BIGNUM * bn1,const BIGNUM * bn2)365 void test_fail_bignum_message(const char *prefix, const char *file,
366 int line, const char *type,
367 const char *left, const char *right,
368 const char *op,
369 const BIGNUM *bn1, const BIGNUM *bn2)
370 {
371 test_fail_bignum_common(prefix, file, line, type, left, right, op, bn1, bn2);
372 test_printf_stderr("\n");
373 }
374
test_fail_bignum_mono_message(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const BIGNUM * bn)375 void test_fail_bignum_mono_message(const char *prefix, const char *file,
376 int line, const char *type,
377 const char *left, const char *right,
378 const char *op, const BIGNUM *bn)
379 {
380 test_fail_bignum_common(prefix, file, line, type, left, right, op, bn, bn);
381 test_printf_stderr("\n");
382 }
383
test_output_bignum(const char * name,const BIGNUM * bn)384 void test_output_bignum(const char *name, const BIGNUM *bn)
385 {
386 if (bn == NULL || BN_is_zero(bn)) {
387 test_printf_stderr("bignum: '%s' = %s\n", name,
388 test_bignum_zero_null(bn));
389 } else if (BN_num_bytes(bn) <= BN_OUTPUT_SIZE) {
390 unsigned char buf[BN_OUTPUT_SIZE];
391 char out[2 * sizeof(buf) + 1];
392 char *p = out;
393 int n = BN_bn2bin(bn, buf);
394
395 hex_convert_memory(buf, n, p, BN_OUTPUT_SIZE);
396 while (*p == '0' && *++p != '\0')
397 ;
398 test_printf_stderr("bignum: '%s' = %s0x%s\n", name,
399 BN_is_negative(bn) ? "-" : "", p);
400 } else {
401 test_fail_bignum_common("bignum", NULL, 0, NULL, NULL, NULL, name,
402 bn, bn);
403 }
404 }
405
406 /* Memory output routines */
407
408 /*
409 * Handle zero length blocks of memory or NULL pointers to memory
410 */
test_memory_null_empty(const unsigned char * m,char c)411 static void test_memory_null_empty(const unsigned char *m, char c)
412 {
413 if (m == NULL)
414 test_printf_stderr("% 4s %c%s\n", "", c, "NULL");
415 else
416 test_printf_stderr("%04x %c%s\n", 0u, c, "empty");
417 }
418
419 /*
420 * Common code to display one or two blocks of memory.
421 */
test_fail_memory_common(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const unsigned char * m1,size_t l1,const unsigned char * m2,size_t l2)422 static void test_fail_memory_common(const char *prefix, const char *file,
423 int line, const char *type,
424 const char *left, const char *right,
425 const char *op,
426 const unsigned char *m1, size_t l1,
427 const unsigned char *m2, size_t l2)
428 {
429 const size_t bytes = (MAX_STRING_WIDTH - 9) / 17 * 8;
430 char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
431 char *p, bdiff[MAX_STRING_WIDTH + 1];
432 size_t n1, n2, i;
433 unsigned int cnt = 0, diff;
434
435 test_fail_message_prefix(prefix, file, line, type, left, right, op);
436 if (m1 == NULL)
437 l1 = 0;
438 if (m2 == NULL)
439 l2 = 0;
440 if (l1 == 0 && l2 == 0) {
441 if ((m1 == NULL) == (m2 == NULL)) {
442 test_memory_null_empty(m1, ' ');
443 } else {
444 test_diff_header(left, right);
445 test_memory_null_empty(m1, '-');
446 test_memory_null_empty(m2, '+');
447 }
448 goto fin;
449 }
450
451 if (l1 != l2 || (m1 != m2 && memcmp(m1, m2, l1) != 0))
452 test_diff_header(left, right);
453
454 while (l1 > 0 || l2 > 0) {
455 n1 = n2 = 0;
456 if (l1 > 0) {
457 n1 = l1 > bytes ? bytes : l1;
458 hex_convert_memory(m1, n1, b1, 8);
459 }
460 if (l2 > 0) {
461 n2 = l2 > bytes ? bytes : l2;
462 hex_convert_memory(m2, n2, b2, 8);
463 }
464
465 diff = 0;
466 i = 0;
467 p = bdiff;
468 if (n1 > 0 && n2 > 0) {
469 const size_t j = n1 < n2 ? n1 : n2;
470
471 for (; i < j; i++) {
472 if (m1[i] == m2[i]) {
473 *p++ = ' ';
474 *p++ = ' ';
475 } else {
476 *p++ = '^';
477 *p++ = '^';
478 diff = 1;
479 }
480 if (i % 8 == 7 && i != j - 1)
481 *p++ = ' ';
482 }
483 *p++ = '\0';
484 }
485
486 if (n1 == n2 && !diff) {
487 test_printf_stderr("%04x: %s\n", cnt, b1);
488 } else {
489 if (cnt == 0 && (m1 == NULL || l1 == 0))
490 test_memory_null_empty(m1, '-');
491 else if (n1 > 0)
492 test_printf_stderr("%04x:-%s\n", cnt, b1);
493 if (cnt == 0 && (m2 == NULL || l2 == 0))
494 test_memory_null_empty(m2, '+');
495 else if (n2 > 0)
496 test_printf_stderr("%04x:+%s\n", cnt, b2);
497 if (diff && i > 0)
498 test_printf_stderr("% 4s %s\n", "", bdiff);
499 }
500 if (m1 != NULL)
501 m1 += n1;
502 if (m2 != NULL)
503 m2 += n2;
504 l1 -= n1;
505 l2 -= n2;
506 cnt += bytes;
507 }
508 fin:
509 test_flush_stderr();
510 }
511
512 /*
513 * Wrapper routines so that the underlying code can be shared.
514 * The first is the call from inside the test utilities when a conditional
515 * fails. The second is the user's call to dump memory.
516 */
test_fail_memory_message(const char * prefix,const char * file,int line,const char * type,const char * left,const char * right,const char * op,const unsigned char * m1,size_t l1,const unsigned char * m2,size_t l2)517 void test_fail_memory_message(const char *prefix, const char *file,
518 int line, const char *type,
519 const char *left, const char *right,
520 const char *op,
521 const unsigned char *m1, size_t l1,
522 const unsigned char *m2, size_t l2)
523 {
524 test_fail_memory_common(prefix, file, line, type, left, right, op,
525 m1, l1, m2, l2);
526 test_printf_stderr("\n");
527 }
528
test_output_memory(const char * name,const unsigned char * m,size_t l)529 void test_output_memory(const char *name, const unsigned char *m, size_t l)
530 {
531 test_fail_memory_common("memory", NULL, 0, NULL, NULL, NULL, name,
532 m, l, m, l);
533 }
534