More changes. Still embryonic.

[u/mdw/catacomb] / keyutil.c

/* -*-c-*-
 *
 * $Id: keyutil.c,v 1.3 1999/11/02 15:23:24 mdw Exp $
 *
 * Simple key manager program
 *
 * (c) 1999 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * Catacomb 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 Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: keyutil.c,v $
 * Revision 1.3  1999/11/02 15:23:24  mdw
 * Fix newlines in keyring list.
 *
 * Revision 1.2  1999/10/15 21:05:28  mdw
 * In `key list', show timezone for local times, and support `-u' option
 * for UTC output.
 *
 * Revision 1.1  1999/09/03 08:41:12  mdw
 * Initial import.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sub.h>

#include <noise.h>
#include <rand.h>

#include "getdate.h"
#include "key.h"

/*----- Handy global state ------------------------------------------------*/

static const char *keyfile = "keyring";

/*----- Useful shared functions -------------------------------------------*/

/* --- @doopen@ --- *
 *
 * Arguments:	@key_file *f@ = pointer to key file block
 *		@unsigned how@ = method to open file with
 *
 * Returns:	---
 *
 * Use:		Opens a key file and handles errors by panicking
 *		appropriately.
 */

static void doopen(key_file *f, unsigned how)
{
  if (key_open(f, keyfile, how))
    die(1, "couldn't open file `%s': %s", keyfile, strerror(errno));
}

/* --- @doclose@ --- *
 *
 * Arguments:	@key_file *f@ = pointer to key file block
 *
 * Returns:	---
 *
 * Use:		Closes a key file and handles errors by panicking
 *		appropriately.
 */

static void doclose(key_file *f)
{
  switch (key_close(f)) {
    case KWRITE_FAIL:
      die(EXIT_FAILURE, "couldn't write file `%s': %s",
	  keyfile, strerror(errno));
    case KWRITE_BROKEN:
      die(EXIT_FAILURE, "keyring file `%s' broken: %s (repair manually)",
	  keyfile, strerror(errno));
  }
}

/* --- @setattr@ --- *
 *
 * Arguments:	@key_file *f@ = pointer to key file block
 *		@key *k@ = pointer to key block
 *		@char *v[]@ = array of assignments (overwritten!)
 *
 * Returns:	---
 *
 * Use:		Applies the attribute assignments to the key.
 */

static void setattr(key_file *f, key *k, char *v[])
{
  while (*v) {
    char *p = *v;
    size_t eq = strcspn(p, "=");
    if (p[eq] == 0)
      moan("invalid assignment: `%s'", p);
    p[eq] = 0;
    p += eq + 1;
    key_putattr(f, k, *v, *p ? p : 0);
    v++;
  }
}

/*----- Command implementation --------------------------------------------*/

/* --- @cmd_add@ --- */

static int cmd_add(int argc, char *argv[])
{
  key_file f;
  key *k;
  int bits = 128;
  time_t exp = KEXP_EXPIRE;
  unsigned fl = 0;
  unsigned char *p;
  size_t sz;
  const char *c = 0;

  /* --- Various useful flag bits --- */

  enum {
    f_bogus = 1
  };

  /* --- Parse options for the subcommand --- */

  for (;;) {
    static struct option opt[] = {
      { "bits",		OPTF_ARGREQ,	0,	'b' },
      { "expire",	OPTF_ARGREQ,	0,	'e' },
      { "comment",	OPTF_ARGREQ,	0,	'c' },
      { 0,		0,		0,	0 }
    };
    int i = mdwopt(argc, argv, "+b:e:c:", opt, 0, 0, 0);
    if (i < 0)
      break;

    /* --- Handle the various options --- */

    switch (i) {

      /* --- Bits must be nonzero and a multiple of 8 --- */

      case 'b':
	if (!(bits = atoi(optarg)) || bits % 8)
	  die(EXIT_FAILURE, "bad number of bits: `%s'", optarg);
	break;

      /* --- Expiry dates get passed to @get_date@ for parsing --- */

      case 'e':
	if (strcmp(optarg, "forever") == 0)
	  exp = KEXP_FOREVER;
	else {
	  exp = get_date(optarg, 0);
	  if (exp == -1)
	    die(EXIT_FAILURE, "bad expiry date: `%s'", optarg);
	}
	break;

      /* --- Store comments without interpretation --- */

      case 'c':
	if (key_chkcomment(c))
	  die(EXIT_FAILURE, "bad comment string: `%s'", optarg);
	c = optarg;
	break;

      /* --- Other things are bogus --- */

      default:
	fl |= f_bogus;
	break;
    }
  }

  /* --- Various sorts of bogusity --- */

  if (fl & f_bogus || optind + 1 > argc) {
    die(EXIT_FAILURE,
	"Usage: add [-b BITS] [-e EXPIRE] [-c COMMENT] TYPE [ATTR...]");
  }
  if (key_chktype(argv[optind]))
    die(EXIT_FAILURE, "bad key type: `%s'", argv[optind]);
  if (exp == KEXP_EXPIRE)
    exp = time(0) + 14 * 24 * 60 * 60;

  /* --- Initialize the Catacomb random number generator --- */

  rand_init(RAND_GLOBAL);
  rand_noisesrc(RAND_GLOBAL, &noise_source);

  /* --- Extract the key data from the generator --- */

  sz = bits / 8;
  p = xmalloc(sz);
  rand_getgood(RAND_GLOBAL, p, sz);

  /* --- Open the file, add the key, set attributes, close, return --- */

  doopen(&f, KOPEN_WRITE);
  if (!(k = key_new(&f, argv[optind], p, sz, exp, c)))
    moan("key not added: expiry date in past?");
  setattr(&f, k, argv + optind + 1);
  doclose(&f);
  return (0);
}

/* --- @cmd_expire@ --- */

static int cmd_expire(int argc, char *argv[])
{
  key_file f;
  key *k;
  uint32 id;
  int i;
  int rc = 0;

  if (argc < 2)
    die(EXIT_FAILURE, "Usage: expire KEYID...");
  doopen(&f, KOPEN_WRITE);
  for (i = 1; i < argc; i++) {
    id = (uint32)strtoul(argv[i], 0, 16);
    if ((k = key_byid(&f, id)) != 0)
      key_expire(&f, k);
    else {
      moan("keyid %lx not found", (unsigned long)id);
      rc = 1;
    }
  }
  doclose(&f);
  return (rc);
}

/* --- @cmd_delete@ --- */

static int cmd_delete(int argc, char *argv[])
{
  key_file f;
  key *k;
  uint32 id;
  int i;
  int rc = 0;

  if (argc < 2)
    die(EXIT_FAILURE, "Usage: delete KEYID...");
  doopen(&f, KOPEN_WRITE);
  for (i = 1; i < argc; i++) {
    id = (uint32)strtoul(argv[i], 0, 16);
    if ((k = key_byid(&f, id)) != 0)
      key_delete(&f, k);
    else {
      moan("keyid %lx not found", (unsigned long)id);
      rc = 1;
    }
  }
  doclose(&f);
  return (rc);
}

/* --- @cmd_setattr@ --- */

static int cmd_setattr(int argc, char *argv[])
{
  key_file f;
  key *k;
  uint32 id;

  if (argc < 3)
    die(EXIT_FAILURE, "Usage: setattr KEYID ATTR...");
  doopen(&f, KOPEN_WRITE);
  id = (uint32)strtoul(argv[1], 0, 16);
  if ((k = key_byid(&f, id)) == 0)
    die(EXIT_FAILURE, "keyid %lx not found", (unsigned long)id);
  setattr(&f, k, argv + 2);
  doclose(&f);
  return (0);
}

/* --- @cmd_comment@ --- */

static int cmd_comment(int argc, char *argv[])
{
  uint32 id;
  key_file f;
  key *k;

  if (argc < 2 || argc > 3)
    die(EXIT_FAILURE, "Usage: comment KEYID [COMMENT]");
  doopen(&f, KOPEN_WRITE);
  id = (uint32)strtoul(argv[1], 0, 16);
  if ((k = key_byid(&f, id)) == 0)
    die(EXIT_FAILURE, "keyid %lx not found", (unsigned long)id);
  if (key_chkcomment(argv[2]))
    die(EXIT_FAILURE, "bad comment: `%s'", argv[2]);
  key_setcomment(&f, k, argv[2]);
  doclose(&f);
  return (0);
}

/* --- @cmd_list@ --- */

static int cmd_list(int argc, char *argv[])
{
  key_file f;
  key *k;
  key_iter i;
  unsigned fl = 0;
  const char *tfmt;
  int v = 0;
  time_t t;

  enum {
    f_bogus = 1,
    f_newline = 2,
    f_attr = 4,
    f_utc = 8
  };

  /* --- Parse subcommand options --- */

  for (;;) {
    static struct option opt[] = {
      { "quiet",	0,	0,	'q' },
      { "verbose",	0,	0,	'v' },
      { "utc",		0,	0,	'u' },
      { 0,		0,	0,	0 }
    };
    int i = mdwopt(argc, argv, "+uqv", opt, 0, 0, 0);
    if (i < 0)
      break;

    switch (i) {
      case 'u':
	fl |= f_utc;
	break;
      case 'q':
	if (v)
	  v--;
	break;
      case 'v':
	v++;
	break;
      default:
	fl |= f_bogus;
	break;
    }
  }

  if (fl & f_bogus || optind != argc)
    die(EXIT_FAILURE, "Usage: list [-uqv]");

  /* --- Open the key file --- */

  doopen(&f, KOPEN_READ);
  t = time(0);

  /* --- Write the header --- */

  if (!v)
    tfmt = "%Y-%m-%d";
  else if (fl & f_utc)
    tfmt = "%Y-%m-%d %H:%M:%S UTC";
  else
    tfmt = "%Y-%m-%d %H:%M:%S %Z";

  /* --- Now iterate through the keys --- */

  for (key_mkiter(&i, &f); (k = key_next(&i)) != 0; ) {
    char ebuf[24], dbuf[24];
    struct tm *tm;

    /* --- Sort out the expiry times --- */

    if (KEY_EXPIRED(t, k->exp)) {
      strcpy(ebuf, "expired");
      if (KEY_DELETED(t, k->del)) {
	strcpy(dbuf, "deleted");
	goto donetime;
      } else
	goto deltime;
    }

    if (k->exp == KEXP_FOREVER)
      strcpy(ebuf, "forever");
    else {
      tm = (fl & f_utc) ? gmtime(&k->exp) : localtime(&k->exp);
      strftime(ebuf, sizeof(ebuf), tfmt, tm);
    }

    /* --- Sort out the delete times --- */

  deltime:
    if (k->del == KEXP_UNUSED)
      strcpy(dbuf, "on expiry");
    else if (k->del == KEXP_FOREVER)
      strcpy(dbuf, "forever");
    else {
      tm = localtime(&k->del);
      strftime(dbuf, sizeof(dbuf), tfmt, tm);
    }

  donetime:;

    /* --- Display the data obtained so far --- */

    if (!v) {
      if (!(fl & f_newline)) {
	printf("%8s  %-20s  %-10s  %-10s  %-23s\n",
	       "Id", "Type", "Expire", "Delete", "Comment");
      }
      printf("%08lx  %-20s  %-10s  %-10s  %-23s\n",
	     (unsigned long)k->id, k->type, ebuf, dbuf,
	     k->c ? k->c : "<none>");
      fl |= f_newline;
    } else {

      /* --- Display the standard header --- */

      if (fl & f_newline)
	fputc('\n', stdout);
      printf("keyid: %08lx\n", (unsigned long)k->id);
      printf("type: %s\n", k->type);
      printf("expiry: %s\n", ebuf);
      printf("delete: %s\n", dbuf);
      printf("comment: %s\n", k->c ? k->c : "<none>");

      /* --- Display the attributes --- */

      if (v > 1) {
	key_attriter i;
	const char *av, *an;

	fl &= ~f_attr;
	printf("attributes:");
	for (key_mkattriter(&i, &f, k); key_nextattr(&i, &an, &av); ) {
	  printf("\n\t%s = %s", an, av);
	  fl |= f_attr;
	}
	if (fl & f_attr)
	  fputc('\n', stdout);
	else
	  puts(" <none>");
      }

      /* --- If dumping requested, dump the raw key data in hex --- */

      if (v > 2) {
	unsigned char *p = k->k;
	unsigned char *l = p + k->ksz;
	size_t sz = 0;

	fputs("key:", stdout);
	while (p < l) {
	  if (sz % 16 == 0)
	    fputs("\n\t", stdout);
	  else if (sz % 8 == 0)
	    fputs("  ", stdout);
	  else
	    fputc(' ', stdout);
	  printf("%02x", *p++);
	  sz++;
	}
	fputc('\n', stdout);
      }
      fl |= f_newline;
    }
  }

  doclose(&f);
  return (0);
}

/* --- @cmd_extract@ --- */

static int cmd_extract(int argc, char *argv[])
{
  key_file f;
  key *k;
  uint32 id;
  int i;
  int rc = 0;
  FILE *fp;

  if (argc < 3)
    die(EXIT_FAILURE, "Usage: extract FILE KEYID...");
  if (strcmp(argv[1], "-") == 0)
    fp = stdout;
  else if (!(fp = fopen(argv[1], "w"))) {
    die(EXIT_FAILURE, "couldn't open `%s' for writing: %s",
	argv[1], strerror(errno));
  }

  doopen(&f, KOPEN_WRITE);
  for (i = 2; i < argc; i++) {
    id = (uint32)strtoul(argv[i], 0, 16);
    if ((k = key_byid(&f, id)) != 0)
      key_extract(&f, k, fp);
    else {
      moan("keyid %lx not found", (unsigned long)id);
      rc = 1;
    }
  }
  doclose(&f);
  return (rc);
}

/* --- @cmd_tidy@ --- */

static int cmd_tidy(int argc, char *argv[])
{
  key_file f;
  if (argc != 1)
    die(EXIT_FAILURE, "usage: tidy");
  doopen(&f, KOPEN_WRITE);
  f.f |= KF_MODIFIED; /* Nasty hack */
  doclose(&f);
  return (0);
}

/* --- @cmd_merge@ --- */

static int cmd_merge(int argc, char *argv[])
{
  key_file f;
  FILE *fp;

  if (argc != 2)
    die(EXIT_FAILURE, "Usage: merge FILE");
  if (strcmp(argv[1], "-") == 0)
    fp = stdin;
  else if (!(fp = fopen(argv[1], "r"))) {
    die(EXIT_FAILURE, "couldn't open `%s' for writing: %s",
	argv[1], strerror(errno));
  }

  doopen(&f, KOPEN_WRITE);
  key_merge(&f, argv[1], fp);
  doclose(&f);
  return (0);
}

/*----- Main command table ------------------------------------------------*/

static struct cmd {
  const char *name;
  int (*cmd)(int /*argc*/, char */*argv*/[]);
  const char *help;
} cmds[] = {
  { "add", cmd_add,
    "add [-b BITS] [-e EXPIRE] [-c COMMENT] TYPE [ATTR...]" },
  { "expire", cmd_expire, "expire KEYID..." },
  { "delete", cmd_delete, "delete KEYID..." },
  { "setattr", cmd_setattr, "setattr KEYID ATTR..." },
  { "comment", cmd_comment, "comment KEYID [COMMENT]" },
  { "list", cmd_list, "list [-uqv]" },
  { "tidy", cmd_tidy, "tidy" },
  { "extract", cmd_extract, "extract FILE KEYID..." },
  { "merge", cmd_merge, "merge FILE" },
  { 0, 0, 0 }
};

typedef struct cmd cmd;

/*----- Main code ---------------------------------------------------------*/

/* --- Helpful GNUy functions --- */

void usage(FILE *fp)
{
  fprintf(fp, "Usage: %s [-k file] command [args]\n", QUIS);
}

void version(FILE *fp)
{
  fprintf(fp, "%s, Catacomb version " VERSION "\n", QUIS);
}

void help(FILE *fp)
{
  cmd *c;
  version(fp);
  fputc('\n', fp);
  usage(fp);
  fputs("\n\
Performs various simple key management operations.  Command line options\n\
recognized are:\n\
\n\
-h, --help		Display this help text.\n\
-v, --version		Display version number.\n\
-u, --usage		Display short usage summary.\n\
\n\
-k, --keyring=FILE	Read and write keys in FILE.\n\
\n\
The following commands are understood:\n\n",
	fp);
  for (c = cmds; c->name; c++)
    fprintf(fp, "%s\n", c->help);
}

/* --- @main@ --- *
 *
 * Arguments:	@int argc@ = number of command line arguments
 *		@char *argv[]@ = array of command line arguments
 *
 * Returns:	Nonzero on failure.
 *
 * Use:		Main program.  Performs simple key management functions.
 */

int main(int argc, char *argv[])
{
  unsigned f = 0;

  enum {
    f_bogus = 1
  };

  /* --- Initialization --- */

  ego(argv[0]);
  sub_init();

  /* --- Parse command line options --- */

  for (;;) {
    static struct option opt[] = {

      /* --- Standard GNUy help options --- */

      { "help",		0,		0,	'h' },
      { "version",	0,		0,	'v' },
      { "usage",	0,		0,	'u' },

      /* --- Real live useful options --- */

      { "keyring",	OPTF_ARGREQ,	0,	'k' },

      /* --- Magic terminator --- */

      { 0,		0,		0,	0 }
    };
    int i = mdwopt(argc, argv, "+hvu k:", opt, 0, 0, 0);

    if (i < 0)
      break;
    switch (i) {

      /* --- GNU help options --- */
      case 'h':
	help(stdout);
	exit(0);
      case 'v':
	version(stdout);
	exit(0);
      case 'u':
	usage(stdout);
	exit(0);

      /* --- Real useful options --- */

      case 'k':
	keyfile = optarg;
	break;

      /* --- Bogosity --- */

      default:
	f |= f_bogus;
	break;
    }
  }

  /* --- Complain about excessive bogons --- */

  if (f & f_bogus || optind == argc) {
    usage(stderr);
    exit(1);
  }

  /* --- Dispatch to appropriate command handler --- */

  argc -= optind;
  argv += optind;
  optind = 0;

  {
    cmd *c, *chosen = 0;
    size_t sz = strlen(argv[0]);

    for (c = cmds; c->name; c++) {
      if (strncmp(argv[0], c->name, sz) == 0) {
	if (c->name[sz] == 0) {
	  chosen = c;
	  break;
	} else if (chosen)
	  die(EXIT_FAILURE, "ambiguous command name `%s'", argv[0]);
	else
	  chosen = c;
      }
    }
    if (!chosen)
      die(EXIT_FAILURE, "unknown command name `%s'", argv[0]);
    return (chosen->cmd(argc, argv));
  }
}

/*----- That's all, folks -------------------------------------------------*/