pgpringui.c

著名的加密软件的应用于电子邮件中

void
ringKeyPrint(PgpOutputType OutputType,
	     struct RingSet const *set,
	     union RingObject *obj,
	     int level)
{
	struct RingIterator *iter;
	char const *name;
	size_t len;
	int i;

	ringTtyPutKeyInfo(TRUE, OutputType, set, obj);
	iter = ringIterCreate(set);
	if (iter) {
		i = ringIterSeekTo(iter, obj);
		while (ringIterNextObject(iter, i+1) > 0) {
			obj = ringIterCurrentObject(iter, i+1);
			pgpAssert(obj);
			if (ringObjectType(obj) != RINGTYPE_NAME)
				continue;
			name = ringNameName(set, obj, &len);
			SpecifiedOutputString(TRUE,
					      OutputType,
					      0,
					      "%*s",
					      level+2,
					      "");
			(void)ringTtyPutString(name,
					       len,
					       -1u,
					       FALSE,
					       OutputType,
					       '"',
					       '"');
			SpecifiedOutputString(FALSE, OutputType, 0, "\n");
			/*	break; */
		}
		ringIterDestroy(iter);
	}
}


void
ringObjPrint(PgpOutputType OutputType,
	     struct RingSet const *set,
	     union RingObject *obj,
	     int level)
{
	int i = ringObjectType(obj);
	int err;
	char const *name;
	size_t len;
	char buf[PGPDATESTRINGLEN+1];

	switch (i) {
	    case RINGTYPE_KEY:
		err = ringKeyError(set, obj);
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*sKey: error=%d ",
				      level, "", err);
		ringTtyPutKeyInfo(TRUE, OutputType, set, obj);
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*s     fingerprint16=",
				      level, "");
		ringTtyPutFingerprint16(OutputType, set, obj, 100);
		SpecifiedOutputString(FALSE, OutputType, 0, "\n");
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*s     fingerprint20=",
				      level, "");
		ringTtyPutFingerprint20(OutputType, set, obj, 100);
		SpecifiedOutputString(FALSE, OutputType, 0, "\n");
		break;

	    case RINGTYPE_SEC:
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*sSecret: (not much to say)\n",
				      level, "");
		break;

	    case RINGTYPE_NAME:
		name = ringNameName(set, obj, &len);
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*sName: ",
				      level, "");
		(void)ringTtyPutString(name,
				       len,
				       -1u,
				       FALSE,
				       OutputType,
				       '"',
				       '"');
		SpecifiedOutputString(FALSE, OutputType, 0, "\n");
		break;

	    case RINGTYPE_SIG:
		err = ringSigError(set, obj);
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*sSig: error=%d ",
				      level, "", err);
		ringTtyPutSigID(FALSE, OutputType, set, obj);
		SpecifiedOutputString(FALSE, OutputType, 0, " ");
		pgpDateString(ringSigTimestamp(set, obj), buf);
		SpecifiedOutputString(FALSE,
				      OutputType,
				      0,
				      "%s, type=%x",
				      buf,
				      ringSigType(set, obj));

		obj = ringSigMaker(set, obj, set);
		if (!obj) {
		    SpecifiedOutputString(FALSE, OutputType, 0, "\n");
		} else {
		    SpecifiedOutputString(FALSE,
					  OutputType,
					  0,
					  " made by:\n");
		    ringKeyPrint(OutputType, set, obj, level);
		    ringObjectRelease(obj);
		}
		break;
	    default:
		SpecifiedOutputString(TRUE,
				      OutputType,
				      0,
				      "%*s### Unknown object: type %d\n",
				      level,
				      "",
				      i);
		break;
	}
}

static void
ringObjPrintAll(PgpOutputType OutputType,
		struct RingSet const *set,
		union RingObject *obj,
		int level)
{
	struct RingIterator *iter;
	int i, j;

	iter = ringIterCreate(set);
	if (iter) {
		i = ringIterSeekTo(iter, obj);
		for (j = 1; j < i; j++) {
			obj = ringIterCurrentObject(iter, j);
			ringObjPrint(OutputType, set, obj, level+2*(j-1));
		}
		ringIterDestroy(iter);
	} else {
	    ringObjPrint(OutputType, set, obj, level);
	}
}

#if 0
* - PGPERR_KEYIO_READING
* - PGPERR_KEYIO_EOF
* - PGPERR_KEYIO_BADPKT
* - PGPERR_NOMEM
*/
#define PGPERR_TROUBLE_BADTRUST	-320
PGPERR (PGPERR_TROUBLE_BADTRUST,	"Trust packet malformed")
#define PGPERR_TROUBLE_UNKPKTBYTE -321
PGPERR (PGPERR_TROUBLE_UNKPKTBYTE,	"Unknown packet byte in keyring")
#define PGPERR_TROUBLE_UNXNAME	-322
PGPERR (PGPERR_TROUBLE_UNXNAME,		"Unexpected name (before key)")
#define PGPERR_TROUBLE_UNXSIG 	-323
PGPERR (PGPERR_TROUBLE_UNXSIG,	 	"Unexpected sig (before key)")
#define PGPERR_TROUBLE_UNXTRUST	-324
PGPERR (PGPERR_TROUBLE_UNXTRUST,	"Unexpected trust packet")
#define PGPERR_TROUBLE_KEY2BIG	-325
PGPERR (PGPERR_TROUBLE_KEY2BIG,		"Key too damn big")
#define PGPERR_TROUBLE_NAME2BIG	-326
PGPERR (PGPERR_TROUBLE_NAME2BIG,	"Name too damn big")
#define PGPERR_TROUBLE_SIG2BIG	-327
PGPERR (PGPERR_TROUBLE_SIG2BIG,		"Sig too damn big")
#define PGPERR_TROUBLE_DUPKEYID	-328
PGPERR (PGPERR_TROUBLE_DUPKEYID, 	"Duplicate KeyID, different keys")
#define PGPERR_TROUBLE_DUPKEY	-329
PGPERR (PGPERR_TROUBLE_DUPKEY, 		"Duplicate key (within keyring)")
#define PGPERR_TROUBLE_DUPNAME	-330
PGPERR (PGPERR_TROUBLE_DUPNAME,		"Duplicate name (in same keyring)")
#define PGPERR_TROUBLE_DUPSIG	-331
PGPERR (PGPERR_TROUBLE_DUPSIG,		"Duplicate signature")
#define PGPERR_TROUBLE_BAREKEY	-332
PGPERR (PGPERR_TROUBLE_BAREKEY,		"Key found with no names")
#define PGPERR_TROUBLE_VERSION_BUG_PREV	-333
PGPERR (PGPERR_TROUBLE_VERSION_BUG_PREV, "Bug introduced by legal_kludge")
#define PGPERR_TROUBLE_VERSION_BUG_CUR	-334
PGPERR (PGPERR_TROUBLE_VERSION_BUG_CUR,	"Bug introduced by legal_kludge")
#endif
/*
 * Print a single trouble message
 * A message with extra lines of information (such as a key) is followed
 * by a blank line. This is a feature, for clarity, not an accident of
 * the way it is implemented.
 */
#if 0
struct RingTrouble const *next;
union RingObject *obj;	/* The pertinent object, if applicable */
word32 num;	/* An integer parameter, if applicable */
word32 fpos;	/* File position related to the error */
int type;	/* PGPERR_ code from pgpErr.h */
#endif

static void
ringTopDoPrintTrouble(PgpOutputType OutputType, struct RingFile *file,
		struct RingTrouble const *t)
{
#if 0
    fprintf(f, "%7lu: ", (unsigned long)t->fpos);
#endif

    switch(t->type) {
	/* Non-fatal errors */
	case PGPERR_TROUBLE_BADTRUST: /* Trust packet malformed */
	    SpecifiedOutput(OutputType,
			    TRUE,
			    0,
			    "PGPERR_TROUBLE_BADTRUST_LONG",
			    (unsigned long) t->num);
	    break;
	case PGPERR_TROUBLE_UNKPKTBYTE:	/* Unknown packet byte */
	    SpecifiedOutput(OutputType,
			    TRUE,
			    0,
			    "PGPERR_TROUBLE_UNKPKTBYTE_LONG",
			    (unsigned long) t->num);
	    break;
	case PGPERR_TROUBLE_KEY2BIG: /* Key too damn big */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_KEY2BIG_LONG",
			    (unsigned long) t->num);
	    break;
	case PGPERR_TROUBLE_NAME2BIG: /* Uid too damn big */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_NAME2BIG_LONG",
			    (unsigned long) t->num);
	    break;
	case PGPERR_TROUBLE_SIG2BIG: /* Sig too damn big */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_SIG2BIG_LONG",
			    (unsigned long) t->num);
	    break;
	case PGPERR_TROUBLE_DUPKEYID: /* Duplicate KeyID, different keys */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_DUPKEYID_LONG");
	    ringKeyPrint(OutputType, ringFileSet(file), t->obj, 2);
	    break;
	case PGPERR_TROUBLE_DUPKEY: /* Duplicate key (within keyring) */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_DUPKEY_LONG");
	    ringKeyPrint(OutputType, ringFileSet(file), t->obj, 2);
	    break;
	case PGPERR_TROUBLE_DUPNAME: /* Duplicate name (within keyring) */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_DUPNAME_LONG");
	    ringObjPrintAll(OutputType, ringFileSet(file), t->obj, 2);
	    break;
	case PGPERR_TROUBLE_BAREKEY: /* Duplicate key (within keyring) */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_BAREKEY_LONG");
	    ringKeyPrint(OutputType, ringFileSet(file), t->obj, 2);
	    break;
	
	case PGPERR_TROUBLE_VERSION_BUG_CUR: /* legal_kludge bug */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_VERSION_BUG_CUR_LONG");
		/* Obj is "sec" */
		ringKeyPrint(OutputType, ringFileSet(file), t->obj, 2);
		break;
	case PGPERR_TROUBLE_VERSION_BUG_PREV: /* legal_kludge bug */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_TROUBLE_VERSION_BUG_PREV_LONG");
	    ringKeyPrint(OutputType, ringFileSet(file), t->obj, 2);
	    break;

		/* Fatal errors */
	case PGPERR_KEYIO_READING: /* Read error */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_KEYIO_READING_LONG",
			    strerror((int)t->num));
		break;
	case PGPERR_KEYIO_FTELL: /* Read error */
 	    SpecifiedOutput(OutputType,
	 		    TRUE,
		 	    0,
			    "PGPERR_KEYIO_FTELL_LONG",
			    strerror((int)t->num));
		break;
	default:
	    PGPErrCodeOutput(TRUE, LEVEL_SEVERE, t->type);
	
	    ringObjPrintAll(OUTPUT_ERROR, ringFileSet(file), t->obj, 2);
	    break;
    }
}

/*
 * List any trouble spots encountered opening a file.
 * Ask the user if they wish to continue.  If not,
 * return an error code <0.
 *
 * Prints nothing if there is no trouble.
 */
int
ringTopListTrouble(Boolean DisplayOutput,
		   PgpOutputType OutputType,
		   struct RingFile *file,
		   int writeflag)
{
    struct RingTrouble const *trouble;
    unsigned u = 0;

    (void) writeflag;

    trouble = ringFileTrouble(file);
    if (!trouble)
	return 0;

    /*
     * Special case: if first packet in the file isn't a packet,
     * it's unconditionally an error.
     */
    if (trouble->fpos == 0 && trouble->type == PGPERR_KEYIO_BADPKT) {
	SpecifiedOutput(TRUE, OutputType, 0, "NOT_PGP_KEYFILE");
	ringFilePurgeTrouble(file);
	return PGPERR_KEYIO_BADPKT;
    }

    SpecifiedOutput(TRUE, OutputType, 0, "FOLLOWING_KEYRING_PROBLEMS");
    SpecifiedOutput(TRUE, OutputType, 0, "OFFSET_DESCRIPTION");

    do {
	u++;
	ringTopDoPrintTrouble(OutputType, file, trouble);
    } while ((trouble = trouble->next) != NULL);

    if (u > 20)
	SpecifiedOutput(TRUE, OutputType, 0, "OFFSET_DESCRIPTION");

#if 1
	u = 1;
#else
	if (writeflag) {
		 u = userAsk("\n\
If you continue, PGP will ignore the errors and remove the\n\
offending data from the key file.  Do you want to continue with\n\
\"%s\"", 'y', ring->ring[bit].logname);
	 } else {
		u = userAsk("\n\
If you continue, PGP will ignore the errors.  Do you want to continue with\n\
\"%s\"", 'y', ring->ring[bit].logname);
		}
#endif

#if 0
	/*
	 * KLUDGE Version bug kludge: if told to correct, flags the
	 * offending keys appropriately.
	 */
	if (u) {
		trouble = ringFileTrouble(file);
		do {
			if (trouble->type == TROUBLE_VERSION_BUG_SEC ||
			    trouble->type == TROUBLE_VERSION_BUG_PUB) {
				trouble->obj->g.flags |= SECF_VERSION_BUG;
				ringPoolMarkDirty(ring,
					          trouble->obj->g.mask);
			}
		} while ((trouble=trouble->next) != NULL);
	}
#endif

	ringFilePurgeTrouble(file);

	return u ? 0 : -1;
}



/* Functions for displaying keys */


const int name_indent = 30;
const int sig_indent = 32;

/* Given a key object, return the first Name object attached to it. */

static union RingObject *
getFirstName (struct RingSet const *set, union RingObject *key)
{
	int				status;
	struct RingIterator		*iter = ringIterCreate (set);
	union RingObject		*object;

	pgpAssert (ringObjectType (key) == RINGTYPE_KEY);

	ringIterSeekTo (iter, key);
	while ((status = ringIterNextObject (iter, 2)) > 0) {
		object = ringIterCurrentObject (iter, 2);
		pgpAssert (object != NULL);
		if (ringObjectType (object) == RINGTYPE_NAME) {
			ringIterDestroy (iter);
			return object;
		}
	}
	ringIterDestroy (iter);
	return NULL;
}



/* Passed the keyid of a signature, its level, and its parent object,
   determine if the signature has been retired. */

static int
sigRetired (struct RingSet const *set, union RingObject *sig)
{
  struct RingIterator	*iter = ringIterCreate (set);
  union RingObject	*object;
  int 			status;
  int			level;

  level = ringIterSeekTo (iter, sig);
  if (level < 0)
    return level;
  ringIterRewind(iter, level);

  while ((status = ringIterNextObject (iter, level)) > 0) {
    object = ringIterCurrentObject (iter, level);
    pgpAssert (object != NULL);
    if (ringObjectType (object) == RINGTYPE_SIG) {
      if (ringSigError (set, object) == 0 &&
	  ringSigType (set, object) == PGP_SIGTYPE_KEY_UID_REVOKE &&
	  ringSigChecked (set, object) &&
	  ringSigMaker (set, object, set) == ringSigMaker (set, sig, set)) {
	ringIterDestroy (iter);
	return 1;
      }
    }
  }
  ringIterDestroy (iter);
  return 0;
}

/* List of algorithms indexed by the pkalg byte. Each entry contains
   the name of the algorithm and what it can be used for. */

static const char *pkalg_list[] =
{NULL, "RSA", "RSA", "RSA", NULL, NULL, NULL, NULL, NULL, NULL,
	NULL, NULL, NULL, NULL, NULL, NULL, "Diffie-Hellman", "DSS"};