path: root/lib/openpgp/output.c

/*
 * Copyright (C) 2007, 2008 Free Software Foundation
 *
 * Author: Simon Josefsson, Nikos Mavrogiannopoulos
 *
 * This file is part of GNUTLS.
 *
 * The GNUTLS library 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 library 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 *
 */

/* Functions for printing X.509 Certificate structures
 */

#include <gnutls_int.h>
#include <gnutls/openpgp.h>
#include <gnutls_errors.h>

/* I18n of error codes. */
#include "gettext.h"
#define _(String) dgettext (PACKAGE, String)
#define N_(String) gettext_noop (String)

#define addf _gnutls_string_append_printf
#define adds _gnutls_string_append_str

static void
hexdump (gnutls_string * str, const char *data, size_t len, const char *spc)
{
  size_t j;

  if (spc)
    adds (str, spc);
  for (j = 0; j < len; j++)
    {
      if (((j + 1) % 16) == 0)
	{
	  addf (str, "%.2x\n", (unsigned char) data[j]);
	  if (spc && j != (len - 1))
	    adds (str, spc);
	}
      else if (j == (len - 1))
	addf (str, "%.2x", (unsigned char) data[j]);
      else
	addf (str, "%.2x:", (unsigned char) data[j]);
    }
  if ((j % 16) != 0)
    adds (str, "\n");
}

static void
hexprint (gnutls_string * str, const char *data, size_t len)
{
  size_t j;

  if (len == 0)
    adds (str, "00");
  else
    {
      for (j = 0; j < len; j++)
	addf (str, "%.2x", (unsigned char) data[j]);
    }
}

static void
print_key_usage (gnutls_string * str, gnutls_openpgp_crt_t cert, unsigned int idx)
{
  unsigned int key_usage;
  int err;

  addf (str, _("\t\tKey Usage:\n"));


  if (idx == -1)
    err = gnutls_openpgp_crt_get_key_usage (cert, &key_usage);
  else
    err = gnutls_openpgp_crt_get_subkey_usage (cert, idx, &key_usage);
  if (err < 0)
    {
      addf (str, _("error: get_key_usage: %s\n"), gnutls_strerror (err));
      return;
    }

  if (key_usage & GNUTLS_KEY_DIGITAL_SIGNATURE)
    addf (str, _("\t\t\tDigital signatures.\n"));
  if (key_usage & GNUTLS_KEY_KEY_ENCIPHERMENT)
    addf (str, _("\t\t\tCommunications encipherment.\n"));
  if (key_usage & GNUTLS_KEY_DATA_ENCIPHERMENT)
    addf (str, _("\t\t\tStorage data encipherment.\n"));
  if (key_usage & GNUTLS_KEY_KEY_AGREEMENT)
    addf (str, _("\t\t\tAuthentication.\n"));
  if (key_usage & GNUTLS_KEY_KEY_CERT_SIGN)
    addf (str, _("\t\t\tCertificate signing.\n"));
}

/* idx == -1 indicates main key
 * otherwise the subkey.
 */
static void
print_key_id (gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
{
    gnutls_openpgp_keyid_t id;
    int err;

    if (idx < 0)
      err = gnutls_openpgp_crt_get_key_id (cert, id);
    else
      err = gnutls_openpgp_crt_get_subkey_id( cert, idx, id);

    if (err < 0)
      addf (str, "error: get_key_id: %s\n", gnutls_strerror (err));
    else
      {
	addf (str, _("\tID (hex): "));
	hexprint (str, id, sizeof(id));
	addf (str, "\n");
      }
}

/* idx == -1 indicates main key
 * otherwise the subkey.
 */
static void
print_key_fingerprint (gnutls_string * str, gnutls_openpgp_crt_t cert)
{
    char fpr[128];
    size_t fpr_size = sizeof (fpr);
    int err;

    err = gnutls_openpgp_crt_get_fingerprint (cert, fpr, &fpr_size);
    if (err < 0)
      addf (str, "error: get_fingerprint: %s\n", gnutls_strerror (err));
    else
      {
	addf (str, _("\tFingerprint (hex): "));
	hexprint (str, fpr, fpr_size);
	addf (str, "\n");
      }
}

static void
print_key_revoked (gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
{
    int err;

    if (idx < 0)
      err = gnutls_openpgp_crt_get_revoked_status (cert);
    else
      err = gnutls_openpgp_crt_get_subkey_revoked_status( cert, idx);

    if (err != 0)
      addf (str, _("\tRevoked: True\n"));
    else
      addf (str, _("\tRevoked: False\n"));
}

static void
print_key_times(gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
{
    time_t tim;

    addf (str, _("\tTime stamps:\n"));

    if (idx == -1)
      tim = gnutls_openpgp_crt_get_creation_time (cert);
    else
      tim = gnutls_openpgp_crt_get_subkey_creation_time (cert, idx);
      
    {
      char s[42];
      size_t max = sizeof (s);
      struct tm t;

      if (gmtime_r (&tim, &t) == NULL)
	addf (str, "error: gmtime_r (%d)\n", t);
      else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
	addf (str, "error: strftime (%d)\n", t);
      else
	addf (str, _("\t\tCreation: %s\n"), s);
    }

    if (idx == -1)
      tim = gnutls_openpgp_crt_get_expiration_time (cert);
    else
      tim = gnutls_openpgp_crt_get_subkey_expiration_time (cert, idx);
    {
      char s[42];
      size_t max = sizeof (s);
      struct tm t;

      if (tim == 0)
        {
          addf (str, _("\t\tExpiration: Never\n"), s);
        }
      else
        {
          if (gmtime_r (&tim, &t) == NULL)
  	    addf (str, "error: gmtime_r (%d)\n", t);
          else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
	    addf (str, "error: strftime (%d)\n", t);
          else
	    addf (str, _("\t\tExpiration: %s\n"), s);
	}
    }
}

static void
print_key_info(gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
{
    int err;
    unsigned int bits;

    if (idx == -1)
      err = gnutls_openpgp_crt_get_pk_algorithm (cert, &bits);
    else
      err = gnutls_openpgp_crt_get_subkey_pk_algorithm (cert, idx, &bits);

    if (err < 0)
      addf (str, "error: get_pk_algorithm: %s\n", gnutls_strerror (err));
    else
      {
	const char *name = gnutls_pk_algorithm_get_name (err);
	if (name == NULL)
	  name = _("unknown");

	addf (str, _("\tPublic Key Algorithm: %s\n"), name);
	switch (err)
	  {
	  case GNUTLS_PK_RSA:
	    {
	      gnutls_datum_t m, e;

              if (idx == -1)
	        err = gnutls_openpgp_crt_get_pk_rsa_raw (cert, &m, &e);
              else
	        err = gnutls_openpgp_crt_get_subkey_pk_rsa_raw (cert, idx, &m, &e);
	        
	      if (err < 0)
		addf (str, "error: get_pk_rsa_raw: %s\n",
		      gnutls_strerror (err));
	      else
		{
		  addf (str, _("\t\tModulus (bits %d):\n"), bits);
		  hexdump (str, m.data, m.size, "\t\t\t");
		  addf (str, _("\t\tExponent:\n"));
		  hexdump (str, e.data, e.size, "\t\t\t");

                  gnutls_free (m.data);
                  gnutls_free (e.data);
		}

	    }
	    break;

	  case GNUTLS_PK_DSA:
	    {
	      gnutls_datum_t p, q, g, y;

              if (idx == -1)
	        err = gnutls_openpgp_crt_get_pk_dsa_raw (cert, &p, &q, &g, &y);
              else
	        err = gnutls_openpgp_crt_get_subkey_pk_dsa_raw (cert, idx, &p, &q, &g, &y);
	      if (err < 0)
		addf (str, "error: get_pk_dsa_raw: %s\n",
		      gnutls_strerror (err));
	      else
		{
		  addf (str, _("\t\tPublic key (bits %d):\n"), bits);
		  hexdump (str, y.data, y.size, "\t\t\t");
		  addf (str, _("\t\tP:\n"));
		  hexdump (str, p.data, p.size, "\t\t\t");
		  addf (str, _("\t\tQ:\n"));
		  hexdump (str, q.data, q.size, "\t\t\t");
		  addf (str, _("\t\tG:\n"));
		  hexdump (str, g.data, g.size, "\t\t\t");

                  gnutls_free (p.data);
                  gnutls_free (q.data);
                  gnutls_free (g.data);
                  gnutls_free (y.data);
		}
	    }
	    break;

	  default:
	    break;
	  }
      }
}


static void
print_cert (gnutls_string * str, gnutls_openpgp_crt_t cert, unsigned int format)
{
int i, subkeys;
int err;
char dn[1024];
size_t dn_size;

  print_key_revoked( str, cert, -1);

  /* Version. */
  {
    int version = gnutls_openpgp_crt_get_version (cert);
    if (version < 0)
      addf (str, "error: get_version: %s\n", gnutls_strerror (version));
    else
      addf (str, _("\tVersion: %d\n"), version);
  }

  /* ID. */
  print_key_id( str, cert, -1);

  print_key_fingerprint( str, cert);

  /* Names. */
  i = 0;
  do {
      dn_size = sizeof(dn);
      err = gnutls_openpgp_crt_get_name (cert, i++, dn, &dn_size);

      if (err < 0 && err != GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE &&
	  err != GNUTLS_E_OPENPGP_UID_REVOKED)
	{
	  addf (str, "error: get_name: %s %d\n", gnutls_strerror (err), err);
	  break;
	}

      if (err >= 0)
	addf (str, _("\tName[%d]: %s\n"), i-1, dn);
      else if (err == GNUTLS_E_OPENPGP_UID_REVOKED) {
	addf (str, _("\tRevoked Name[%d]: %s\n"), i-1, dn);
      }

  } while( err >= 0);

  print_key_times( str, cert, -1);

  print_key_info( str, cert, -1);
  print_key_usage( str, cert, -1);

  subkeys = gnutls_openpgp_crt_get_subkey_count( cert);
  if (subkeys < 0)
    return;

  for (i=0;i<subkeys;i++) {
    addf( str, _("\n\tSubkey[%d]:\n"), i);

    print_key_revoked( str, cert, i);
    print_key_id( str, cert, i);
    print_key_times( str, cert, i);
    print_key_info( str, cert, i);
    print_key_usage( str, cert, i);
  }

}

/**
 * gnutls_openpgp_crt_print - Pretty print OpenPGP certificates
 * @cert: The structure to be printed
 * @format: Indicate the format to use
 * @out: Newly allocated datum with zero terminated string.
 *
 * This function will pretty print an OpenPGP certificate, suitable
 * for display to a human.
 *
 * The format should be zero for future compatibility.
 *
 * The output @out needs to be deallocate using gnutls_free().
 *
 * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
 **/
int
gnutls_openpgp_crt_print (gnutls_openpgp_crt_t cert,
		       gnutls_certificate_print_formats_t format,
		       gnutls_datum_t *out)
{
  gnutls_string str;

  _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);

  _gnutls_string_append_str (&str, _("OpenPGP Certificate Information:\n"));

  print_cert (&str, cert, format);

  _gnutls_string_append_data (&str, "\0", 1);
  out->data = str.data;
  out->size = strlen (str.data);

  return 0;
}