[openssl-commits] [openssl] master update
Andy Polyakov
appro at openssl.org
Fri May 19 11:27:37 UTC 2017
The branch master has been updated
via ffbaf06ade6dab6a0805a24087cf2e84c5db8d43 (commit)
from 5ec3210fc106ecc6badb48db6cfb1493a7607763 (commit)
- Log -----------------------------------------------------------------
commit ffbaf06ade6dab6a0805a24087cf2e84c5db8d43
Author: Pauli <paul.dale at oracle.com>
Date: Mon May 15 08:49:36 2017 +1000
Reformat the output of BIGNUMS where test cases fail.
Reviewed-by: Richard Levitte <levitte at openssl.org>
Reviewed-by: Andy Polyakov <appro at openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3465)
-----------------------------------------------------------------------
Summary of changes:
test/test_test.c | 44 +++++++++
test/testutil/tests.c | 248 ++++++++++++++++++++++++++++++++++++++++----------
2 files changed, 244 insertions(+), 48 deletions(-)
diff --git a/test/test_test.c b/test/test_test.c
index 0094c1c..7a5079a 100644
--- a/test/test_test.c
+++ b/test/test_test.c
@@ -306,6 +306,9 @@ static int test_bignum(void)
| !TEST(0, TEST_BN_gt_zero(a))
| !TEST(1, TEST_BN_even(a))
| !TEST(0, TEST_BN_odd(a))
+ | !TEST(1, TEST_BN_eq(b, c))
+ | !TEST(0, TEST_BN_eq(a, b))
+ | !TEST(1, TEST_BN_ne(NULL, c))
| !TEST(1, TEST_int_eq(BN_dec2bn(&b, "1"), 1))
| !TEST(1, TEST_BN_eq_word(b, 1))
| !TEST(1, TEST_BN_eq_one(b))
@@ -374,6 +377,46 @@ static int test_long_output(void)
& TEST(0, TEST_mem_eq(r, strlen(r), s, strlen(s)));
}
+static int test_long_bignum(void)
+{
+ int r;
+ BIGNUM *a = NULL, *b = NULL, *c = NULL, *d = NULL;
+ const char as[] = "1234567890123456789012345678901234567890123456789012"
+ "1234567890123456789012345678901234567890123456789012"
+ "1234567890123456789012345678901234567890123456789012"
+ "1234567890123456789012345678901234567890123456789012"
+ "1234567890123456789012345678901234567890123456789012"
+ "1234567890123456789012345678901234567890123456789012"
+ "FFFFFF";
+ const char bs[] = "1234567890123456789012345678901234567890123456789012"
+ "1234567890123456789012345678901234567890123456789013"
+ "987657";
+ const char cs[] = "-" /* 64 characters plus sign */
+ "123456789012345678901234567890"
+ "123456789012345678901234567890"
+ "ABCD";
+ const char ds[] = "-" /* 63 characters plus sign */
+ "23456789A123456789B123456789C"
+ "123456789D123456789E123456789F"
+ "ABCD";
+
+ r = TEST_true(BN_hex2bn(&a, as))
+ && TEST_true(BN_hex2bn(&b, bs))
+ && TEST_true(BN_hex2bn(&c, cs))
+ && TEST_true(BN_hex2bn(&d, ds))
+ && (TEST(0, TEST_BN_eq(a, b))
+ & TEST(0, TEST_BN_eq(b, a))
+ & TEST(0, TEST_BN_eq(b, NULL))
+ & TEST(0, TEST_BN_eq(NULL, a))
+ & TEST(1, TEST_BN_ne(a, NULL))
+ & TEST(0, TEST_BN_eq(c, d)));
+ BN_free(a);
+ BN_free(b);
+ BN_free(c);
+ BN_free(d);
+ return r;
+}
+
static int test_messages(void)
{
TEST_info("This is an %s message.", "info");
@@ -452,6 +495,7 @@ void register_tests(void)
ADD_TEST(test_memory_overflow);
ADD_TEST(test_bignum);
ADD_TEST(test_long_output);
+ ADD_TEST(test_long_bignum);
ADD_TEST(test_messages);
ADD_TEST(test_single_eval);
}
diff --git a/test/testutil/tests.c b/test/testutil/tests.c
index a6c9a99..ef020f7 100644
--- a/test/testutil/tests.c
+++ b/test/testutil/tests.c
@@ -16,11 +16,9 @@
#include "../../e_os.h"
/* The size of memory buffers to display on failure */
-#define MEM_BUFFER_SIZE (33)
+#define MEM_BUFFER_SIZE (2000)
#define MAX_STRING_WIDTH (80)
-
-/* Special representation of -0 */
-static char BN_minus_zero[] = "-0";
+#define BN_OUTPUT_SIZE (8)
/* Output a failed test first line */
static void test_fail_message_prefix(const char *prefix, const char *file,
@@ -184,13 +182,195 @@ fin:
test_flush_stderr();
}
-static char *convertBN(const BIGNUM *b)
+static void hex_convert_memory(const unsigned char *m, size_t n, char *b,
+ size_t width)
+{
+ size_t i;
+
+ for (i = 0; i < n; i++) {
+ const unsigned char c = *m++;
+
+ *b++ = "0123456789abcdef"[c >> 4];
+ *b++ = "0123456789abcdef"[c & 15];
+ if (i % width == width - 1 && i != n - 1)
+ *b++ = ' ';
+ }
+ *b = '\0';
+}
+
+static const int bn_bytes = (MAX_STRING_WIDTH - 9) / (BN_OUTPUT_SIZE * 2 + 1)
+ * BN_OUTPUT_SIZE;
+static const int bn_chars = (MAX_STRING_WIDTH - 9) / (BN_OUTPUT_SIZE * 2 + 1)
+ * (BN_OUTPUT_SIZE * 2 + 1) - 1;
+
+static void test_bignum_header_line(void)
+{
+ test_printf_stderr("%*s# %*s\n", subtest_level(), "", bn_chars + 6,
+ "bit position");
+}
+
+static void test_bignum_zero_print(const BIGNUM *bn, char sep)
+{
+ const char *v = "NULL", *suf = "";
+ if (bn != NULL) {
+ suf = ": 0";
+ v = BN_is_negative(bn) ? "-0" : "0";
+ }
+ test_printf_stderr("%*s# %c%*s%s\n", subtest_level(), "", sep, bn_chars,
+ v, suf);
+}
+
+static int convert_bn_memory(const unsigned char *in, size_t bytes,
+ char *out, int *lz, const BIGNUM *bn)
{
- if (b == NULL)
- return NULL;
- if (BN_is_zero(b) && BN_is_negative(b))
- return BN_minus_zero;
- return BN_bn2hex(b);
+ int n = bytes * 2, i;
+ char *p = out, *q = NULL;
+
+ if (bn != NULL && !BN_is_zero(bn)) {
+ hex_convert_memory(in, bytes, out, BN_OUTPUT_SIZE);
+ if (*lz) {
+ for (; *p == '0' || *p == ' '; p++)
+ if (*p == '0') {
+ q = p;
+ *p = ' ';
+ n--;
+ }
+ if (*p == '\0') {
+ /*
+ * in[bytes] is defined because we're converting a non-zero
+ * number and we've not seen a non-zero yet.
+ */
+ if ((in[bytes] & 0xf0) != 0 && BN_is_negative(bn)) {
+ *lz = 0;
+ *q = '-';
+ n++;
+ }
+ } else {
+ *lz = 0;
+ if (BN_is_negative(bn)) {
+ /*
+ * This is valid because we always convert more digits than
+ * the number holds.
+ */
+ *q = '-';
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ for (i = 0; i < n; i++) {
+ *p++ = ' ';
+ if (i % (2 * BN_OUTPUT_SIZE) == 2 * BN_OUTPUT_SIZE - 1 && i != n - 1)
+ *p++ = ' ';
+ }
+ *p = '\0';
+ if (bn == NULL)
+ q = "NULL";
+ else
+ q = BN_is_negative(bn) ? "-0" : "0";
+ strcpy(p - strlen(q), q);
+ return 0;
+}
+
+static void 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)
+{
+ const int indent = subtest_level();
+ const size_t bytes = bn_bytes;
+ char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
+ char *p, bdiff[MAX_STRING_WIDTH + 1];
+ size_t l1, l2, n1, n2, i, len;
+ unsigned int cnt, diff, real_diff;
+ unsigned char *m1 = NULL, *m2 = NULL;
+ int lz1 = 1, lz2 = 1;
+ unsigned char buffer[MEM_BUFFER_SIZE * 2], *bufp = buffer;
+
+ l1 = bn1 == NULL ? 0 : (BN_num_bytes(bn1) + (BN_is_negative(bn1) ? 1 : 0));
+ l2 = bn2 == NULL ? 0 : (BN_num_bytes(bn2) + (BN_is_negative(bn2) ? 1 : 0));
+ if (l1 == 0 && l2 == 0) {
+ if ((bn1 == NULL) == (bn2 == NULL)) {
+ test_bignum_header_line();
+ test_bignum_zero_print(bn1, ' ');
+ } else {
+ test_diff_header(left, right);
+ test_bignum_header_line();
+ test_bignum_zero_print(bn1, '-');
+ test_bignum_zero_print(bn2, '+');
+ }
+ goto fin;
+ }
+
+ if (l1 != l2 || bn1 == NULL || bn2 == NULL || BN_cmp(bn1, bn2) != 0)
+ test_diff_header(left, right);
+ test_bignum_header_line();
+
+ len = ((l1 > l2 ? l1 : l2) + bytes - 1) / bytes * bytes;
+
+ if (len > MEM_BUFFER_SIZE && (bufp = OPENSSL_malloc(len * 2)) == NULL) {
+ bufp = buffer;
+ len = MEM_BUFFER_SIZE;
+ test_printf_stderr("%*s# WARNING: these BIGNUMs have been truncated",
+ indent, "");
+ }
+
+ if (bn1 != NULL) {
+ m1 = bufp;
+ BN_bn2binpad(bn1, m1, len);
+ }
+ if (bn2 != NULL) {
+ m2 = bufp + len;
+ BN_bn2binpad(bn2, m2, len);
+ }
+
+ while (len > 0) {
+ cnt = 8 * (len - bytes);
+ n1 = convert_bn_memory(m1, bytes, b1, &lz1, bn1);
+ n2 = convert_bn_memory(m2, bytes, b2, &lz2, bn2);
+
+ diff = real_diff = 0;
+ i = 0;
+ p = bdiff;
+ for (i=0; b1[i] != '\0'; i++)
+ if (b1[i] == b2[i] || b1[i] == ' ' || b2[i] == ' ') {
+ *p++ = ' ';
+ diff |= b1[i] != b2[i];
+ } else {
+ *p++ = '^';
+ real_diff = diff = 1;
+ }
+ *p++ = '\0';
+ if (!diff) {
+ test_printf_stderr("%*s# %s:% 5d\n", indent, "",
+ n2 > n1 ? b2 : b1, cnt);
+ } else {
+ if (cnt == 0 && bn1 == NULL)
+ test_printf_stderr("%*s# -%s\n", indent, "", b1);
+ else if (cnt == 0 || n1 > 0)
+ test_printf_stderr("%*s# -%s:% 5d\n", indent, "", b1, cnt);
+ if (cnt == 0 && bn2 == NULL)
+ test_printf_stderr("%*s# +%s\n", indent, "", b2);
+ else if (cnt == 0 || n2 > 0)
+ test_printf_stderr("%*s# +%s:% 5d\n", indent, "", b2, cnt);
+ if (real_diff && (cnt == 0 || (n1 > 0 && n2 > 0))
+ && bn1 != NULL && bn2 != NULL)
+ test_printf_stderr("%*s# %s\n", indent, "", bdiff);
+ }
+ if (m1 != NULL)
+ m1 += bytes;
+ if (m2 != NULL)
+ m2 += bytes;
+ len -= bytes;
+ }
+fin:
+ test_printf_stderr("\n");
+ test_flush_stderr();
+ if (bufp != buffer)
+ OPENSSL_free(bufp);
}
static void test_fail_bignum_message(const char *prefix, const char *file,
@@ -199,16 +379,8 @@ static void test_fail_bignum_message(const char *prefix, const char *file,
const char *op,
const BIGNUM *bn1, const BIGNUM *bn2)
{
- char *s1 = convertBN(bn1), *s2 = convertBN(bn2);
- size_t l1 = s1 != NULL ? strlen(s1) : 0;
- size_t l2 = s2 != NULL ? strlen(s2) : 0;
-
- test_fail_string_message(prefix, file, line, type, left, right, op,
- s1, l1, s2, l2);
- if (s1 != BN_minus_zero)
- OPENSSL_free(s1);
- if (s2 != BN_minus_zero)
- OPENSSL_free(s2);
+ test_fail_message_prefix(prefix, file, line, type, left, right, op);
+ test_fail_bignum_common(prefix, file, line, type, left, right, op, bn1, bn2);
}
static void test_fail_bignum_mono_message(const char *prefix, const char *file,
@@ -216,35 +388,16 @@ static void test_fail_bignum_mono_message(const char *prefix, const char *file,
const char *left, const char *right,
const char *op, const BIGNUM *bn)
{
- char *s = convertBN(bn);
- size_t l = s != NULL ? strlen(s) : 0;
-
- test_fail_string_message(prefix, file, line, type, left, right, op,
- s, l, s, l);
- if (s != BN_minus_zero)
- OPENSSL_free(s);
-}
-
-static void hex_convert_memory(const char *m, size_t n, char *b)
-{
- size_t i;
-
- for (i = 0; i < n; i++) {
- const unsigned char c = *m++;
-
- *b++ = "0123456789abcdef"[c >> 4];
- *b++ = "0123456789abcdef"[c & 15];
- if ((i % 8) == 7 && i != n - 1)
- *b++ = ' ';
- }
- *b = '\0';
+ test_fail_message_prefix(prefix, file, line, type, left, right, op);
+ test_fail_bignum_common(prefix, file, line, type, left, right, op, bn, bn);
}
static void 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 char *m1, size_t l1,
- const char *m2, size_t l2)
+ const char *op,
+ const unsigned char *m1, size_t l1,
+ const unsigned char *m2, size_t l2)
{
const int indent = subtest_level();
const size_t bytes = (MAX_STRING_WIDTH - 9) / 17 * 8;
@@ -279,11 +432,11 @@ static void test_fail_memory_message(const char *prefix, const char *file,
n1 = n2 = 0;
if (l1 > 0) {
n1 = l1 > bytes ? bytes : l1;
- hex_convert_memory(m1, n1, b1);
+ hex_convert_memory(m1, n1, b1, 8);
}
if (l2 > 0) {
n2 = l2 > bytes ? bytes : l2;
- hex_convert_memory(m2, n2, b2);
+ hex_convert_memory(m2, n2, b2, 8);
}
diff = n1 != n2;
@@ -607,8 +760,7 @@ int test_BN_odd(const char *file, int line, const char *s, const BIGNUM *a)
{
if (a != NULL && BN_is_odd(a))
return 1;
- test_fail_bignum_mono_message(NULL, file, line, "BIGNUM", "ODD(", ")", s,
- a);
+ test_fail_bignum_mono_message(NULL, file, line, "BIGNUM", "ODD(", ")", s, a);
return 0;
}
More information about the openssl-commits
mailing list