| /* t-convert.c - Tests for mpi print and scna functions |
| * Copyright (C) 2013 g10 Code GmbH |
| * |
| * This file is part of Libgcrypt. |
| * |
| * Libgcrypt is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU Lesser General Public License as |
| * published by the Free Software Foundation; either version 2.1 of |
| * the License, or (at your option) any later version. |
| * |
| * Libgcrypt is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this program; if not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include <config.h> |
| #endif |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <stdarg.h> |
| |
| #include "../src/gcrypt-int.h" |
| |
| #define PGM "t-convert" |
| |
| #define DIM(v) (sizeof(v)/sizeof((v)[0])) |
| #define DIMof(type,member) DIM(((type *)0)->member) |
| |
| static const char *wherestr; |
| static int verbose; |
| static int debug; |
| static int error_count; |
| |
| |
| #define xmalloc(a) gcry_xmalloc ((a)) |
| #define xcalloc(a,b) gcry_xcalloc ((a),(b)) |
| #define xfree(a) gcry_free ((a)) |
| #define pass() do { ; } while (0) |
| |
| static void |
| show (const char *format, ...) |
| { |
| va_list arg_ptr; |
| |
| if (!verbose) |
| return; |
| fprintf (stderr, "%s: ", PGM); |
| va_start (arg_ptr, format); |
| vfprintf (stderr, format, arg_ptr); |
| va_end (arg_ptr); |
| } |
| |
| static void |
| showhex (const char *prefix, const void *buffer, size_t buflen) |
| { |
| const unsigned char *s; |
| |
| if (!verbose) |
| return; |
| fprintf (stderr, "%s: %s ", PGM, prefix); |
| for (s= buffer; buflen; buflen--, s++) |
| fprintf (stderr, "%02x", *s); |
| putc ('\n', stderr); |
| } |
| |
| |
| /* Allocate a bit string consisting of '0' and '1' from the MPI A. Do |
| not return any leading zero bits. Caller needs to gcry_free the |
| result. */ |
| static char * |
| mpi2bitstr_nlz (gcry_mpi_t a) |
| { |
| char *p, *buf; |
| size_t length = gcry_mpi_get_nbits (a); |
| |
| if (!length) |
| { |
| buf = p = xmalloc (3); |
| *p++ = ' '; |
| *p++ = '0'; |
| } |
| else |
| { |
| buf = p = xmalloc (length + 1 + 1); |
| *p++ = gcry_mpi_is_neg (a)? '-':' '; |
| while (length-- > 1) |
| *p++ = gcry_mpi_test_bit (a, length) ? '1':'0'; |
| *p++ = gcry_mpi_test_bit (a, 0) ? '1':'0'; |
| } |
| *p = 0; |
| return buf; |
| } |
| |
| |
| static void |
| showmpi (const char *prefix, gcry_mpi_t a) |
| { |
| char *bitstr; |
| |
| if (!verbose) |
| return; |
| bitstr = mpi2bitstr_nlz (a); |
| fprintf (stderr, "%s: %s%s\n", PGM, prefix, bitstr); |
| xfree (bitstr); |
| } |
| |
| |
| static void |
| fail (const char *format, ...) |
| { |
| va_list arg_ptr; |
| |
| fflush (stdout); |
| fprintf (stderr, "%s: ", PGM); |
| if (wherestr) |
| fprintf (stderr, "%s: ", wherestr); |
| va_start (arg_ptr, format); |
| vfprintf (stderr, format, arg_ptr); |
| va_end (arg_ptr); |
| error_count++; |
| } |
| |
| static void |
| die (const char *format, ...) |
| { |
| va_list arg_ptr; |
| |
| fflush (stdout); |
| fprintf (stderr, "%s: ", PGM); |
| if (wherestr) |
| fprintf (stderr, "%s: ", wherestr); |
| va_start (arg_ptr, format); |
| vfprintf (stderr, format, arg_ptr); |
| va_end (arg_ptr); |
| exit (1); |
| } |
| |
| |
| /* Check that mpi_print does not return a negative zero. */ |
| static void |
| negative_zero (void) |
| { |
| gpg_error_t err; |
| gcry_mpi_t a; |
| char *buf; |
| void *bufaddr = &buf; |
| struct { const char *name; enum gcry_mpi_format format; } fmts[] = |
| { |
| { "STD", GCRYMPI_FMT_STD }, |
| { "PGP", GCRYMPI_FMT_PGP }, |
| { "SSH", GCRYMPI_FMT_SSH }, |
| { "HEX", GCRYMPI_FMT_HEX }, |
| { "USG", GCRYMPI_FMT_USG }, |
| { NULL, 0 } |
| }; |
| int i; |
| |
| if (debug) |
| show ("negative zero printing\n"); |
| |
| a = gcry_mpi_new (0); |
| for (i=0; fmts[i].name; i++) |
| { |
| err = gcry_mpi_aprint (fmts[i].format, bufaddr, NULL, a); |
| if (err) |
| fail ("error printing a zero as %s: %s\n", |
| fmts[i].name,gpg_strerror (err) ); |
| else |
| gcry_free (buf); |
| } |
| |
| /* With the current version of libgcrypt the next two statements |
| should set a to -0. */ |
| gcry_mpi_sub_ui (a, a, 1); |
| gcry_mpi_add_ui (a, a, 1); |
| |
| for (i=0; fmts[i].name; i++) |
| { |
| err = gcry_mpi_aprint (fmts[i].format, bufaddr, NULL, a); |
| if (err) |
| fail ("error printing a negative zero as %s: %s\n", |
| fmts[i].name,gpg_strerror (err) ); |
| else |
| gcry_free (buf); |
| } |
| |
| gcry_mpi_release (a); |
| } |
| |
| |
| static void |
| check_formats (void) |
| { |
| static struct { |
| int value; |
| struct { |
| const char *hex; |
| size_t stdlen; |
| const char *std; |
| size_t sshlen; |
| const char *ssh; |
| size_t usglen; |
| const char *usg; |
| size_t pgplen; |
| const char *pgp; |
| } a; |
| } data[] = { |
| { 0, { "00", |
| 0, "", |
| 4, "\x00\x00\x00\x00", |
| 0, "", |
| 2, "\x00\x00"} |
| }, |
| { 1, { "01", |
| 1, "\x01", |
| 5, "\x00\x00\x00\x01\x01", |
| 1, "\x01", |
| 3, "\x00\x01\x01" } |
| }, |
| { 2, { "02", |
| 1, "\x02", |
| 5, "\x00\x00\x00\x01\x02", |
| 1, "\x02", |
| 3, "\x00\x02\x02" } |
| }, |
| { 127, { "7F", |
| 1, "\x7f", |
| 5, "\x00\x00\x00\x01\x7f", |
| 1, "\x7f", |
| 3, "\x00\x07\x7f" } |
| }, |
| { 128, { "0080", |
| 2, "\x00\x80", |
| 6, "\x00\x00\x00\x02\x00\x80", |
| 1, "\x80", |
| 3, "\x00\x08\x80" } |
| }, |
| { 129, { "0081", |
| 2, "\x00\x81", |
| 6, "\x00\x00\x00\x02\x00\x81", |
| 1, "\x81", |
| 3, "\x00\x08\x81" } |
| }, |
| { 255, { "00FF", |
| 2, "\x00\xff", |
| 6, "\x00\x00\x00\x02\x00\xff", |
| 1, "\xff", |
| 3, "\x00\x08\xff" } |
| }, |
| { 256, { "0100", |
| 2, "\x01\x00", |
| 6, "\x00\x00\x00\x02\x01\x00", |
| 2, "\x01\x00", |
| 4, "\x00\x09\x01\x00" } |
| }, |
| { 257, { "0101", |
| 2, "\x01\x01", |
| 6, "\x00\x00\x00\x02\x01\x01", |
| 2, "\x01\x01", |
| 4, "\x00\x09\x01\x01" } |
| }, |
| { -1, { "-01", |
| 1, "\xff", |
| 5, "\x00\x00\x00\x01\xff", |
| 1,"\x01" } |
| }, |
| { -2, { "-02", |
| 1, "\xfe", |
| 5, "\x00\x00\x00\x01\xfe", |
| 1, "\x02" } |
| }, |
| { -127, { "-7F", |
| 1, "\x81", |
| 5, "\x00\x00\x00\x01\x81", |
| 1, "\x7f" } |
| }, |
| { -128, { "-0080", |
| 1, "\x80", |
| 5, "\x00\x00\x00\x01\x80", |
| 1, "\x80" } |
| }, |
| { -129, { "-0081", |
| 2, "\xff\x7f", |
| 6, "\x00\x00\x00\x02\xff\x7f", |
| 1, "\x81" } |
| }, |
| { -255, { "-00FF", |
| 2, "\xff\x01", |
| 6, "\x00\x00\x00\x02\xff\x01", |
| 1, "\xff" } |
| }, |
| { -256, { "-0100", |
| 2, "\xff\x00", |
| 6, "\x00\x00\x00\x02\xff\x00", |
| 2, "\x01\x00" } |
| }, |
| { -257, { "-0101", |
| 2, "\xfe\xff", |
| 6, "\x00\x00\x00\x02\xfe\xff", |
| 2, "\x01\x01" } |
| }, |
| { 65535, { "00FFFF", |
| 3, "\x00\xff\xff", |
| 7, "\x00\x00\x00\x03\x00\xff\xff", |
| 2, "\xff\xff", |
| 4, "\x00\x10\xff\xff" } |
| }, |
| { 65536, { "010000", |
| 3, "\x01\00\x00", |
| 7, "\x00\x00\x00\x03\x01\x00\x00", |
| 3, "\x01\x00\x00", |
| 5, "\x00\x11\x01\x00\x00 "} |
| }, |
| { 65537, { "010001", |
| 3, "\x01\00\x01", |
| 7, "\x00\x00\x00\x03\x01\x00\x01", |
| 3, "\x01\x00\x01", |
| 5, "\x00\x11\x01\x00\x01" } |
| }, |
| { -65537, { "-010001", |
| 3, "\xfe\xff\xff", |
| 7, "\x00\x00\x00\x03\xfe\xff\xff", |
| 3, "\x01\x00\x01" } |
| }, |
| { -65536, { "-010000", |
| 3, "\xff\x00\x00", |
| 7, "\x00\x00\x00\x03\xff\x00\x00", |
| 3, "\x01\x00\x00" } |
| }, |
| { -65535, { "-00FFFF", |
| 3, "\xff\x00\x01", |
| 7, "\x00\x00\x00\x03\xff\x00\x01", |
| 2, "\xff\xff" } |
| } |
| }; |
| gpg_error_t err; |
| gcry_mpi_t a, b; |
| char *buf; |
| void *bufaddr = &buf; |
| int idx; |
| size_t buflen; |
| |
| a = gcry_mpi_new (0); |
| for (idx=0; idx < DIM(data); idx++) |
| { |
| if (debug) |
| show ("print test %d\n", data[idx].value); |
| |
| if (data[idx].value < 0) |
| { |
| gcry_mpi_set_ui (a, -data[idx].value); |
| gcry_mpi_neg (a, a); |
| } |
| else |
| gcry_mpi_set_ui (a, data[idx].value); |
| |
| err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a); |
| if (err) |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "HEX", gpg_strerror (err)); |
| else |
| { |
| if (strcmp (buf, data[idx].a.hex)) |
| { |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "HEX", "wrong result"); |
| show ("expected: '%s'\n", data[idx].a.hex); |
| show (" got: '%s'\n", buf); |
| } |
| gcry_free (buf); |
| } |
| |
| err = gcry_mpi_aprint (GCRYMPI_FMT_STD, bufaddr, &buflen, a); |
| if (err) |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "STD", gpg_strerror (err)); |
| else |
| { |
| if (buflen != data[idx].a.stdlen |
| || memcmp (buf, data[idx].a.std, data[idx].a.stdlen)) |
| { |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "STD", "wrong result"); |
| showhex ("expected:", data[idx].a.std, data[idx].a.stdlen); |
| showhex (" got:", buf, buflen); |
| } |
| gcry_free (buf); |
| } |
| |
| err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, bufaddr, &buflen, a); |
| if (err) |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "SSH", gpg_strerror (err)); |
| else |
| { |
| if (buflen != data[idx].a.sshlen |
| || memcmp (buf, data[idx].a.ssh, data[idx].a.sshlen)) |
| { |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "SSH", "wrong result"); |
| showhex ("expected:", data[idx].a.ssh, data[idx].a.sshlen); |
| showhex (" got:", buf, buflen); |
| } |
| gcry_free (buf); |
| } |
| |
| err = gcry_mpi_aprint (GCRYMPI_FMT_USG, bufaddr, &buflen, a); |
| if (err) |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "USG", gpg_strerror (err)); |
| else |
| { |
| if (buflen != data[idx].a.usglen |
| || memcmp (buf, data[idx].a.usg, data[idx].a.usglen)) |
| { |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "USG", "wrong result"); |
| showhex ("expected:", data[idx].a.usg, data[idx].a.usglen); |
| showhex (" got:", buf, buflen); |
| } |
| gcry_free (buf); |
| } |
| |
| err = gcry_mpi_aprint (GCRYMPI_FMT_PGP, bufaddr, &buflen, a); |
| if (gcry_mpi_is_neg (a)) |
| { |
| if (gpg_err_code (err) != GPG_ERR_INV_ARG) |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "PGP", "Expected error not returned"); |
| } |
| else if (err) |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "PGP", gpg_strerror (err)); |
| else |
| { |
| if (buflen != data[idx].a.pgplen |
| || memcmp (buf, data[idx].a.pgp, data[idx].a.pgplen)) |
| { |
| fail ("error printing value %d as %s: %s\n", |
| data[idx].value, "PGP", "wrong result"); |
| showhex ("expected:", data[idx].a.pgp, data[idx].a.pgplen); |
| showhex (" got:", buf, buflen); |
| } |
| gcry_free (buf); |
| } |
| } |
| |
| |
| /* Now for the other direction. */ |
| for (idx=0; idx < DIM(data); idx++) |
| { |
| if (debug) |
| show ("scan test %d\n", data[idx].value); |
| |
| if (data[idx].value < 0) |
| { |
| gcry_mpi_set_ui (a, -data[idx].value); |
| gcry_mpi_neg (a, a); |
| } |
| else |
| gcry_mpi_set_ui (a, data[idx].value); |
| |
| err = gcry_mpi_scan (&b, GCRYMPI_FMT_HEX, data[idx].a.hex, 0, &buflen); |
| if (err) |
| fail ("error scanning value %d from %s: %s\n", |
| data[idx].value, "HEX", gpg_strerror (err)); |
| else |
| { |
| if (gcry_mpi_cmp (a, b)) |
| { |
| fail ("error scanning value %d from %s: %s\n", |
| data[idx].value, "HEX", "wrong result"); |
| showmpi ("expected:", a); |
| showmpi (" got:", b); |
| } |
| gcry_mpi_release (b); |
| } |
| |
| err = gcry_mpi_scan (&b, GCRYMPI_FMT_STD, |
| data[idx].a.std, data[idx].a.stdlen, &buflen); |
| if (err) |
| fail ("error scanning value %d as %s: %s\n", |
| data[idx].value, "STD", gpg_strerror (err)); |
| else |
| { |
| if (gcry_mpi_cmp (a, b) || data[idx].a.stdlen != buflen) |
| { |
| fail ("error scanning value %d from %s: %s (%u)\n", |
| data[idx].value, "STD", "wrong result", buflen); |
| showmpi ("expected:", a); |
| showmpi (" got:", b); |
| } |
| gcry_mpi_release (b); |
| } |
| |
| err = gcry_mpi_scan (&b, GCRYMPI_FMT_SSH, |
| data[idx].a.ssh, data[idx].a.sshlen, &buflen); |
| if (err) |
| fail ("error scanning value %d as %s: %s\n", |
| data[idx].value, "SSH", gpg_strerror (err)); |
| else |
| { |
| if (gcry_mpi_cmp (a, b) || data[idx].a.sshlen != buflen) |
| { |
| fail ("error scanning value %d from %s: %s (%u)\n", |
| data[idx].value, "SSH", "wrong result", buflen); |
| showmpi ("expected:", a); |
| showmpi (" got:", b); |
| } |
| gcry_mpi_release (b); |
| } |
| |
| err = gcry_mpi_scan (&b, GCRYMPI_FMT_USG, |
| data[idx].a.usg, data[idx].a.usglen, &buflen); |
| if (err) |
| fail ("error scanning value %d as %s: %s\n", |
| data[idx].value, "USG", gpg_strerror (err)); |
| else |
| { |
| if (gcry_mpi_is_neg (a)) |
| gcry_mpi_neg (b, b); |
| if (gcry_mpi_cmp (a, b) || data[idx].a.usglen != buflen) |
| { |
| fail ("error scanning value %d from %s: %s (%u)\n", |
| data[idx].value, "USG", "wrong result", buflen); |
| showmpi ("expected:", a); |
| showmpi (" got:", b); |
| } |
| gcry_mpi_release (b); |
| } |
| |
| /* Negative values are not supported by PGP, thus we don't have |
| an samples. */ |
| if (!gcry_mpi_is_neg (a)) |
| { |
| err = gcry_mpi_scan (&b, GCRYMPI_FMT_PGP, |
| data[idx].a.pgp, data[idx].a.pgplen, &buflen); |
| if (err) |
| fail ("error scanning value %d as %s: %s\n", |
| data[idx].value, "PGP", gpg_strerror (err)); |
| else |
| { |
| if (gcry_mpi_cmp (a, b) || data[idx].a.pgplen != buflen) |
| { |
| fail ("error scanning value %d from %s: %s (%u)\n", |
| data[idx].value, "PGP", "wrong result", buflen); |
| showmpi ("expected:", a); |
| showmpi (" got:", b); |
| } |
| gcry_mpi_release (b); |
| } |
| } |
| } |
| |
| gcry_mpi_release (a); |
| } |
| |
| |
| int |
| main (int argc, char **argv) |
| { |
| if (argc > 1 && !strcmp (argv[1], "--verbose")) |
| verbose = 1; |
| else if (argc > 1 && !strcmp (argv[1], "--debug")) |
| verbose = debug = 1; |
| |
| if (!gcry_check_version (GCRYPT_VERSION)) |
| die ("version mismatch\n"); |
| |
| gcry_control (GCRYCTL_DISABLE_SECMEM, 0); |
| gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0); |
| if (debug) |
| gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0); |
| gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0); |
| |
| negative_zero (); |
| check_formats (); |
| |
| show ("All tests completed. Errors: %d\n", error_count); |
| return error_count ? 1 : 0; |
| } |
