core: Add Base-64 encoder.

* src/b64enc.c: Change to fit into libgpg-error.
* src/Makefile.am: Add b64enc.c
* src/b64dec.c: Use xtrymalloc etc.  Always use gpg_err_code_t.
(_gpgrt_b64dec_start): Set decoder flag
(_gpgrt_b64dec_finish): Check for conflict.
(_gpgrt_b64state): Move to ...
* src/gpgrt-int.h: here.  Add new fields.
* src/visibility.c (gpgrt_b64enc_start): New.
(gpgrt_b64enc_write): New.
(gpgrt_b64enc_finish): New.
* src/gpg-error.vers, src/gpg-error.def.in: Add new functions.
* src/gpg-error.h.in: Ditto.
* src/visibility.h: Ditto.

* tests/t-b64dec.c: Remove.
* tests/t-b64.c: New.
* tests/Makefile.am (TESTS): Replace t-b64dec by t-b64.
--

Signed-off-by: Werner Koch <wk@gnupg.org>

1 files changed, 373 insertions, 0 deletions

diff --git a/tests/t-b64.c b/tests/t-b64.c
new file mode 100644
index 0000000..96e8fa4
--- /dev/null
+++ b/tests/t-b64.c
@@ -0,0 +1,373 @@
+/* t-b64.c - b64dec tests.
+ * Copyright (C) 2017, 2018 g10 Code GmbH
+ *
+ * This file is part of Libgpg-error.
+ *
+ * This file 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.
+ *
+ * This file 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 <https://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#define PGM "t-b64"
+#include "t-common.h"
+
+static const char *test_string = "libgpg-error 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.";
+
+static const char *test_string_b64_0 = "bGliZ3BnLWVycm9yIGlzIGZyZWUgc29"
+  "mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgd"
+  "W5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIEx"
+  "pY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb"
+  "247IGVpdGhlciB2ZXJzaW9uIDIuMSBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXI"
+  "gb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4=";
+
+static const char *test_string_b64_1 =
+  "bGliZ3BnLWVycm9yIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli\n"
+  "dXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH\n"
+  "TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5\n"
+  "IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIu\n"
+  "MSBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg\n"
+  "dmVyc2lvbi4=\n";
+
+static const char *test_string_b64_2 =
+  "-----BEGIN DATA-----\n"
+  "bGliZ3BnLWVycm9yIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli\n"
+  "dXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH\n"
+  "TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5\n"
+  "IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIu\n"
+  "MSBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg\n"
+  "dmVyc2lvbi4=\n"
+  "-----END DATA-----\n";
+
+static const char *test_string_b64_3 =
+  "-----BEGIN PGP ARMORED FILE-----\n"
+  "\n"
+  "bGliZ3BnLWVycm9yIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli\n"
+  "dXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH\n"
+  "TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5\n"
+  "IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIu\n"
+  "MSBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg\n"
+  "dmVyc2lvbi4=\n"
+  "=4BMJ\n"
+  "-----END PGP ARMORED FILE-----\n";
+
+static const char *test_blob_1 = "\x01\x03\x04\xff";
+static const char *test_blob_1_b64_0 = "AQME/w==";
+static const char *test_blob_2 = "\x01\x03\x04\xff""A";
+static const char *test_blob_2_b64_0 = "AQME/0E=";
+static const char *test_blob_3 = "\x01\x03\x04\xff""AB";
+static const char *test_blob_3_b64_0 = "AQME/0FC";
+
+
+#define FAIL(a)  do { fail ("line %d: test %d failed\n", __LINE__, (a));  \
+                    } while(0)
+
+static gpg_error_t
+test_b64enc_string (const char *string, const char *expected, const char *title)
+{
+  gpg_err_code_t err;
+  estream_t fp;
+  gpgrt_b64state_t state;
+  char *result;
+
+  fp = es_fopenmem (0, "rwb");
+  if (!fp)
+    die ("es_fopenmem failed: %s\n", gpg_strerror (gpg_error_from_syserror ()));
+
+  state = gpgrt_b64enc_start (fp, title);
+  if (!state)
+    {
+      err = gpg_err_code_from_syserror ();
+      fail ("gpgrt_b64enc_start failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  err = gpgrt_b64enc_write (state, string, strlen (string));
+  if (err)
+    {
+      fail ("gpgrt_b64enc_write failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  err = gpgrt_b64enc_finish (state);
+  if (err)
+    {
+      fail ("gpgrt_b64enc_finish failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  es_fputc (0, fp);
+  if (es_fclose_snatch (fp, (void**)&result, NULL))
+    die ("es_fclose_snatch failed: %s\n",
+         gpg_strerror (gpg_error_from_syserror ()));
+
+  if (strcmp (result, expected))
+    {
+      if (verbose)
+        {
+          gpgrt_log_debug_string (result,   "result: ");
+          gpgrt_log_debug_string (expected, "expect: ");
+        }
+      return GPG_ERR_FALSE;
+    }
+
+  es_free (result);
+  return 0;
+}
+
+
+static gpg_error_t
+test_b64dec_string (const char *string, const char *expected, const char *title)
+{
+  gpg_error_t err;
+  gpgrt_b64state_t state;
+  char *buffer;
+  size_t len;
+
+  len = strlen (string);
+  buffer = malloc (strlen (string) + 1);
+  if (!buffer)
+    {
+      err = gpg_error_from_syserror ();
+      return err;
+    }
+  strcpy (buffer, string);
+
+  state = gpgrt_b64dec_start (title);
+  if (!state)
+    {
+      err = gpg_err_code_from_syserror ();
+      fail ("gpgrt_b64dec_start failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  err = gpgrt_b64dec_proc (state, buffer, len, &len);
+  if (err)
+    {
+      if (gpg_err_code (err) != GPG_ERR_EOF)
+        {
+          free (buffer);
+          free (state);
+          return err;
+        }
+    }
+
+  err = gpgrt_b64dec_finish (state);
+  if (err)
+    {
+      free (buffer);
+      return err;
+    }
+
+  if (len != strlen (expected) || strncmp (buffer, expected, len))
+    {
+      if (verbose)
+        {
+          gpgrt_log_debug_string (buffer,   "result(len=%zu): ", len);
+          gpgrt_log_debug_string (expected, "expect(len=%zu): ",
+                                  strlen (expected));
+        }
+      return GPG_ERR_FALSE;
+    }
+
+  free (buffer);
+  return 0;
+}
+
+
+static void
+encoder_tests (void)
+{
+  gpg_err_code_t err;
+
+  if (verbose)
+    show ("running encoder tests\n");
+
+  err = test_b64enc_string (test_string, test_string_b64_0, "");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string (test_string, test_string_b64_1, NULL);
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string (test_string, test_string_b64_2, "DATA");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string (test_string, test_string_b64_3, "PGP ARMORED FILE");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+  /* Note that the _test_ function dows not allow to provide a string
+   * with an empdded Nul.  */
+  err = test_b64enc_string (test_blob_1, test_blob_1_b64_0, "");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string (test_blob_2, test_blob_2_b64_0, "");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string (test_blob_3, test_blob_3_b64_0, "");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+  err = test_b64enc_string ("@", "QA==", "");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string ("@", "QA==\n", NULL);
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string ("@",
+                            "-----BEGIN PGP SOMETHING-----\n"
+                            "\n"
+                            "QA==\n"
+                            "=eMoB\n"
+                            "-----END PGP SOMETHING-----\n",
+                            "PGP SOMETHING");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+  err = test_b64enc_string ("", "", "");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string ("", "", NULL);
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+  err = test_b64enc_string ("", "", "PGP SOMETHING");
+  if (err)
+    fail ("encoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+}
+
+
+static void
+decoder_tests (void)
+{
+  gpg_err_code_t err;
+
+  if (verbose)
+    show ("running decoder tests\n");
+
+  err = test_b64dec_string (test_string_b64_0, test_string, NULL);
+  if (err)
+    fail ("decoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+  err = test_b64dec_string (test_string_b64_1, test_string, NULL);
+  if (err)
+    fail ("decoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+  err = test_b64dec_string (test_string_b64_2, test_string, "");
+  if (err)
+    fail ("decoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+  err = test_b64dec_string (test_string_b64_2, test_string, NULL);
+  if (err != GPG_ERR_BAD_DATA)
+    fail ("decoder test at line %d failed: %s\n", __LINE__, gpg_strerror (err));
+
+}
+
+
+static gpg_error_t
+extra_tests (void)
+{
+  gpg_err_code_t err;
+  gpgrt_b64state_t state;
+
+  if (verbose)
+    show ("running extra tests\n");
+
+  /* Check that we detect mismacthed use of enc and dec functions.  */
+  state = gpgrt_b64enc_start (es_stdout, NULL);
+  if (!state)
+    {
+      err = gpg_err_code_from_syserror ();
+      fail ("gpgrt_b64enc_start failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  err = gpgrt_b64dec_finish (state);
+  if (err != GPG_ERR_CONFLICT)
+    {
+      fail ("gpgrt_b64dec_finish failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  state = gpgrt_b64dec_start (NULL);
+  if (!state)
+    {
+      err = gpg_err_code_from_syserror ();
+      fail ("gpgrt_b64dec_start failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  err = gpgrt_b64enc_finish (state);
+  if (err != GPG_ERR_CONFLICT)
+    {
+      fail ("gpgrt_b64enc_finish failed: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  return 0;
+}
+
+
+int
+main (int argc, char **argv)
+{
+  int last_argc = -1;
+
+  if (argc)
+    {
+      argc--; argv++;
+    }
+  while (argc && last_argc != argc )
+    {
+      last_argc = argc;
+      if (!strcmp (*argv, "--help"))
+        {
+          puts (
+"usage: ./" PGM " [options]\n"
+"\n"
+"Options:\n"
+"  --verbose      Show what is going on\n"
+"  --debug        Flyswatter\n"
+);
+          exit (0);
+        }
+      if (!strcmp (*argv, "--verbose"))
+        {
+          verbose = 1;
+          argc--; argv++;
+        }
+      else if (!strcmp (*argv, "--debug"))
+        {
+          verbose = debug = 1;
+          argc--; argv++;
+        }
+    }
+
+  encoder_tests ();
+  decoder_tests ();
+  extra_tests ();
+
+  return !!errorcount;
+}