gpgme/tests/gpg/t-sig-notation.c

/* t-sig-notation.c - Regression test.
 * Copyright (C) 2005 g10 Code GmbH
 *
 * This file is part of GPGME.
 *
 * GPGME 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.
 *
 * GPGME 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://gnu.org/licenses/>.
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

/* We need to include config.h so that we know whether we are building
   with large file system (LFS) support. */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <gpgme.h>

#include "t-support.h"



/* GnuPG prior to 2.1.13 did not report the critical flag
   correctly.  */
int have_correct_sig_data;

static struct {
  const char *name;
  const char *value;
  gpgme_sig_notation_flags_t flags;
  int seen;
} expected_notations[] = {
  { "laughing@me",
    "Just Squeeze Me",
    GPGME_SIG_NOTATION_HUMAN_READABLE },
  { "preferred-email-encoding@pgp.com",
    "pgpmime",
    GPGME_SIG_NOTATION_HUMAN_READABLE | GPGME_SIG_NOTATION_CRITICAL },
  { NULL,
    "https://www.gnu.org/policy/",
    0 }
};

static void
check_result (gpgme_verify_result_t result)
{
  int i;
  gpgme_sig_notation_t r;

  gpgme_signature_t sig;

  sig = result->signatures;
  if (!sig || sig->next)
    {
      fprintf (stderr, "%s:%i: Unexpected number of signatures\n",
	       __FILE__, __LINE__);
      exit (1);
    }

  for (i=0; i < DIM(expected_notations); i++ )
    expected_notations[i].seen = 0;

  for (r = result->signatures->notations; r; r = r->next)
    {
      int any = 0;
      for (i=0; i < DIM(expected_notations); i++)
	{
	  if ( ((r->name && expected_notations[i].name
		 && !strcmp (r->name, expected_notations[i].name)
		 && r->name_len
		 == strlen (expected_notations[i].name))
		|| (!r->name && !expected_notations[i].name
		    && r->name_len == 0))
	       && r->value
	       && !strcmp (r->value, expected_notations[i].value)
	       && r->value_len == strlen (expected_notations[i].value)
	       && r->flags
                  == (have_correct_sig_data
                      ? expected_notations[i].flags
                      : expected_notations[i].flags
                        & ~GPGME_SIG_NOTATION_CRITICAL)
	       && r->human_readable
	       == !!(r->flags & GPGME_SIG_NOTATION_HUMAN_READABLE)
	       && r->critical
                  == (have_correct_sig_data
                      ? !!(r->flags & GPGME_SIG_NOTATION_CRITICAL)
                      : 0))
	    {
	      expected_notations[i].seen++;
	      any++;
	    }
	}
      if (!any)
	{
	  fprintf (stderr, "%s:%i: Unexpected notation data\n",
		   __FILE__, __LINE__);
	  exit (1);
	}
    }
  for (i=0; i < DIM(expected_notations); i++ )
    {
      if (expected_notations[i].seen != 1)
	{
	  fprintf (stderr, "%s:%i: Missing or duplicate notation data\n",
		   __FILE__, __LINE__);
	  exit (1);
	}
    }
}


int
main (int argc, char *argv[])
{
  gpgme_ctx_t ctx;
  gpgme_error_t err;
  gpgme_data_t in, out;
  gpgme_verify_result_t result;
  char *agent_info;
  int i;
  gpgme_engine_info_t engine_info;

  (void)argc;
  (void)argv;

  init_gpgme (GPGME_PROTOCOL_OpenPGP);

  err = gpgme_get_engine_info (&engine_info);
  fail_if_err (err);
  for (; engine_info; engine_info = engine_info->next)
    if (engine_info->protocol == GPGME_PROTOCOL_OpenPGP)
      break;
  assert (engine_info);

  /* GnuPG prior to 2.1.13 did not report the critical flag
     correctly.  */
  have_correct_sig_data =
    ! (strncmp ("1.", engine_info->version, 2) == 0
       || strncmp ("2.0.", engine_info->version, 4) == 0
       || (strncmp ("2.1.1", engine_info->version, 5) == 0
           && (engine_info->version[5] == 0
               || engine_info->version[5] < '3')));

  err = gpgme_new (&ctx);
  fail_if_err (err);

  agent_info = getenv ("GPG_AGENT_INFO");
  if (!(agent_info && strchr (agent_info, ':')))
    gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL);

  err = gpgme_data_new_from_mem (&in, "Hallo Leute\n", 12, 0);
  fail_if_err (err);
  err = gpgme_data_new (&out);
  fail_if_err (err);

  for (i = 0; i < sizeof (expected_notations) / sizeof (expected_notations[0]);
       i++)
    {
      err = gpgme_sig_notation_add (ctx, expected_notations[i].name,
				    expected_notations[i].value,
				    expected_notations[i].flags);
      fail_if_err (err);
    }

  err = gpgme_op_sign (ctx, in, out, GPGME_SIG_MODE_NORMAL);
  fail_if_err (err);

  gpgme_data_release (in);
  err = gpgme_data_new (&in);
  fail_if_err (err);

  gpgme_data_seek (out, 0, SEEK_SET);

  err = gpgme_op_verify (ctx, out, NULL, in);
  fail_if_err (err);
  result = gpgme_op_verify_result (ctx);
  check_result (result);

  gpgme_data_release (in);
  gpgme_data_release (out);
  gpgme_release (ctx);
  return 0;
}