pgpringui.c

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

	name = NULL;
	do {
	    status = ringIterNextObject (iter, 2);
	    if (status > 0) {
		name = ringIterCurrentObject (iter, 2);
		pgpAssert (name != NULL);
		if (ringObjectType (name) != RINGTYPE_NAME)
		    name = NULL;
		else
		    SpecifiedOutputString(DisplayHeaders,
					  OutputType,
					  0,
					  "%*s",
					  name_indent,
					  "");
	    }
	} while (status > 0 && name == NULL);
    } /* end while */
    ringIterDestroy (iter);
    return 0;
}


int
ringTtyCheckKey (Boolean DisplayHeaders,
		 PgpOutputType OutputType,
		 union RingObject *key,
		 struct RingSet const *set,
		 int mode)
{
    struct RingIterator   *iter = ringIterCreate (set);
    union RingObject      *name;
    size_t                 len;
    int                    status;
    char const            *namestring;
    unsigned               confidence;
    unsigned               validity;
    int                    name_leader = 0;
    PgpTrustModel          pgptrustmodel;

    pgpAssert (key != NULL);
    pgpAssert (set != NULL);
    pgpAssert (mode == 4 || mode == 5);
    pgpAssert (ringObjectType (key) == RINGTYPE_KEY);

    pgptrustmodel = pgpTrustModel (ringSetPool (set));

    if (ringKeyError (set, key) != 0) {
	SpecifiedOutputString(DisplayHeaders, OutputType, 0, "? \n");
	/* return, otherwise some strange behaviour occurs */
	return 0;
    }

    if (ringKeyRevoked (set, key))
	SpecifiedOutputString(DisplayHeaders, OutputType, 0, "# ");
    else if (ringKeyAxiomatic(set, key))
	SpecifiedOutputString(DisplayHeaders, OutputType, 0, "* ");
    else
	SpecifiedOutputString(DisplayHeaders, OutputType, 0, "  ");

    ringTtyPutKeyID (FALSE, OutputType, set, key);

    if (pgptrustmodel==PGPTRUST0) {
	SpecifiedOutputString(FALSE,
			      OutputType,
			      0,
			      " %-10s",
			      keyTrustTable[ringKeyTrust(set, key)]);
    }

    if ((name = getFirstName (set, key)) != NULL)
	ringIterSeekTo (iter, name);
    else
	SpecifiedOutputString(FALSE,
			      OutputType,
			      0,
			      "\
                     *** This key is unnamed ***\n");

    while (name != NULL) {
	if (pgptrustmodel==PGPTRUST0) {
	    if (name_leader)
		SpecifiedOutputString(FALSE,
				      OutputType,
				      0,
				      "%*s",
				      name_indent - 9,
				      "");
	    name_leader = 1;
	    SpecifiedOutputString(FALSE,
				  OutputType,
				  0,
				  "%-10s",
				  uidValidityTable[ringNameTrust (set, name)]);
	} else {
	    if (name_leader)
		SpecifiedOutputString(FALSE,
				      OutputType,
				      0,
				      "%*s",
				      name_indent - 20,
				      "");
	    name_leader = 1;
	    confidence = (unsigned) ringNameConfidence (set, name);
	    validity = (unsigned) ringNameValidity (set, name);
	    SpecifiedOutputString(FALSE,
				  OutputType,
				  0,
				  " %10s",
				  getTrustStatement (confidence));
	    SpecifiedOutputString(FALSE,
				  OutputType,
				  0,
				  "%10s",
				  getTrustStatement (validity));
	}
	
	namestring = ringNameName (set, name, &len);
	ringTtyPutString (namestring,
			  len,
			  (unsigned) len,
			  FALSE,
			  OutputType,
			  0,
			  0);
	SpecifiedOutputString(FALSE, OutputType, 0, "\n");
	
	ringTtyCheckSigs(DisplayHeaders, OutputType, name, set, mode);
	
	name = NULL;
	do {
	    status = ringIterNextObject (iter, 2);
	    if (status > 0) {
		name = ringIterCurrentObject (iter, 2);
		pgpAssert (name != NULL);
		if (ringObjectType (name) != RINGTYPE_NAME)
		    name = NULL;
	    }
	} while (status > 0 && name == NULL);
    }
    ringIterDestroy (iter);
    return 0;
}


/* Note:  No mode 5 for the moment */

int
ringTtyKeyCheck (Boolean DisplayHeaders,
		 PgpOutputType OutputType,
		 struct RingSet const *viewkeys,
		 struct RingSet const *allkeys,
		 int mode)
{
    struct RingIterator   *iter;
    union RingObject	*key;
    int			 status;
    PgpTrustModel    pgptrustmodel;

    pgpAssert (allkeys != NULL);

    pgptrustmodel = pgpTrustModel (ringSetPool (allkeys));

    if (viewkeys == NULL)
	viewkeys = allkeys;

    if (pgptrustmodel == PGPTRUST0) {
	SpecifiedOutputString(DisplayHeaders,
			      OutputType,
			      0,
			      "\n\n  KeyID    Trust     Validity  User ID\n");
    } else {
	SpecifiedOutputString(DisplayHeaders,
			      OutputType,
			      0,
			      "\n\n  KeyID   Confidence  Validity User ID\n");
    }
    iter = ringIterCreate (viewkeys);
    while ((status = ringIterNextObject (iter, 1)) > 0) {
	key = ringIterCurrentObject (iter, 1);
	ringTtyCheckKey(DisplayHeaders,
			OutputType,
			key,
			allkeys,
			mode);
    }
    ringIterDestroy (iter);

    return 0;
}


/* Modes:

   0          list keys, but no fingerprints or signatures (-kv)
   1          list keys with signatures, but no fingerprints (-kvv)
   2          list keys with fingerprints and signatures (-kvc)
   3          list keys with signature status info (-ka)
   4          list keys with signature status info, plus trust info (-kc)
   5          same as 4, but do not output numeric trust info
             (not implemented yet)
   */



int
ringTtyKeyView (struct RingSet const *viewkeys,
		struct RingSet const *allkeys,
		char const *keyring,
		int mode)
{
    struct RingIterator *iter;
    union RingObject	*key;
    char			 header[] =
	"Type Bits KeyID    Created    Expires    Algorithm Use\n";
    int			 count = 0;
    int			 status;

    pgpAssert (mode <= 5);
    pgpAssert (allkeys != NULL);

    if (viewkeys == NULL)
	viewkeys = allkeys;

    if (keyring)
	PrimaryOutputString("Key ring: \'%s\'\n", keyring);

    PrimaryOutputString(header);

    iter = ringIterCreate (viewkeys);
    while ((status = ringIterNextObject (iter, 1)) > 0) {
	count++;
	key = ringIterCurrentObject (iter, 1);
	ringTtyShowKey(TRUE, OUTPUT_PRIMARY, key, allkeys, mode);
    }
    ringIterDestroy (iter);

    if (mode < 4) {
	if (count == 1)
	    PrimaryOutputString("1 matching key found\n");
	else
	    PrimaryOutputString("%d matching keys found\n", count);
    }
    else
	ringTtyKeyCheck (TRUE,
			 OUTPUT_PRIMARY,
			 viewkeys,
			 allkeys,
			 mode);

    return 0;
}



/* Key selected for encryption.  Determine is the user really wants to
   use it. If 'batchmode' is set, we fail rather than ask. */

int
ringTtyKeyOKToEncrypt (struct RingSet const *set,
		       union RingObject *key)
{
    union RingObject *name;
    char const *namestring;
    size_t len;
    struct RingIterator *iter;
    time_t expiration;
    char datestring[11];
    int trust;
    unsigned validity;
    PgpTrustModel pgptrustmodel;

    pgptrustmodel = pgpTrustModel (ringSetPool (set));

    ringKeyPrint(OUTPUT_INFORMATION, set, key, 1);

    if (ringKeyRevoked (set, key)) {
	WarningOutput(TRUE,
		      LEVEL_SEVERE,
		      "ABOVE_KEY_REVOKED");
	return 0;
    }

    if (ringKeyDisabled (set, key)) {
	InteractionOutput(TRUE, "STILL_USE_REVOKED_KEY");
	
	if (!pgpTtyGetBool (0, TRUE))
	    return 0;
    }

    if ((expiration = ringKeyExpiration (set, key)) > 0 &&
	expiration <= time ((time_t *) 0)) {
	pgpDateString (expiration, datestring);
	InteractionOutput(TRUE,
			  "STILL_USE_EXPIRED_KEY",
			  datestring);
	if (!pgpTtyGetBool (0, TRUE))
	    return 0;
    }

    iter = ringIterCreate (set);
    pgpAssert(iter != NULL);
    ringIterSeekTo (iter, key);
    while (ringIterNextObject (iter, 2) > 0) {
	name = ringIterCurrentObject (iter, 2);
	pgpAssert(name != NULL);
	if (ringObjectType (name) == RINGTYPE_NAME) {
	    int warn = 0;
	
	    if (pgptrustmodel == PGPTRUST0) {
		switch (trust = ringNameTrust (set, name)) {
		    case PGP_NAMETRUST_UNKNOWN:
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NAMETRUST_UNKNOWN");
			warn = 1;
			break;
		    case PGP_NAMETRUST_UNTRUSTED:
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NAMETRUST_UNTRUSTED");
			warn = 1;
			break;
		    case PGP_NAMETRUST_MARGINAL:
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NAMETRUST_MARGINAL");
			warn = 1;
			break;
		}
	    }
	    else {			/* new trust model */
		validity = ringNameValidity (set, name);
		if (validity == 0) {
		    WarningOutput(TRUE,
				  LEVEL_INFORMATION,
				  "PGP_NEWTRUST_NOT_TRUSTED");
		    warn = 1;
		}
		else if (!ringTrustValid (set, validity)) {
		    WarningOutput(TRUE,
				  LEVEL_INFORMATION,
				  "PGP_NEWTRUST_PARTIAL_TRUST",
				  strtol (getTrustStatement
					  (validity),
					  NULL, 10));
		    warn = 1;
		}
	    }
	    if (warn) {
		namestring = ringNameName (set, name, &len);
		ringTtyPutString (namestring,
				  len,
				  (unsigned) len,
				  TRUE,
				  OUTPUT_WARNING,
				  0,
				  0);
		WarningOutputString(FALSE, 0, "\n");
		if (ringNameWarnonly (set, name))
		    WarningOutput(TRUE,
				  LEVEL_INFORMATION,
				  "PREVIOUSLY_APPROVED_KEY");
		else {
		    InteractionOutput(TRUE,
				      "DO_YOU_WISH_TO_USE_UNTRUSTED_KEY");
		    if (pgpTtyGetBool (0, TRUE))
			ringNameSetWarnonly (set,
					     name);
		    else
			return 0;
		}
		InformationOutputString(FALSE, "\n");
	    }
	}
    }
    return 1;
}

void
ringTtyKeyOKToSign (struct RingSet const *set,
		    union RingObject *key)
{
    struct RingIterator *iter;
    union RingObject *name;
    size_t len;
    char const *namestr;
    int warn = 0;
    time_t expiration;
    char datestring[11];
    byte trust;
    unsigned validity;
    PgpTrustModel pgptrustmodel;

    pgptrustmodel = pgpTrustModel (ringSetPool (set));

    if (ringKeyRevoked (set, key)) {
	WarningOutput(TRUE,
		      LEVEL_SEVERE,
		      "DONT_TRUST_SIGS_FROM_REVOKED_KEYS");
	return;
    }
    if (ringKeyDisabled (set, key))
	WarningOutput(TRUE,
		      LEVEL_INFORMATION,
		      "YOU_HAVE_DISABLED_SIGNING_KEY");

    if ((expiration = ringKeyExpiration (set, key)) > 0 &&
	expiration <= time ((time_t *) 0)) {
	pgpDateString (expiration, datestring);
	WarningOutput(TRUE,
		      LEVEL_INFORMATION,
		      "KEY_HAS_EXPIRED",
		      datestring);
    }

    iter = ringIterCreate (set);
    pgpAssert(iter != NULL);

    ringIterSeekTo (iter, key);
    while (ringIterNextObject (iter, 2) > 0) {
	name = ringIterCurrentObject (iter, 2);
	if (name && ringObjectType (name) == RINGTYPE_NAME) {
	    warn = 0;
	    if (pgptrustmodel == PGPTRUST0) {
		trust = ringNameTrust (set, name);
		switch (trust = ringNameTrust (set, name)) {
		    case PGP_NAMETRUST_UNKNOWN:
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NAMETRUST_UNKNOWN");
			warn = 1;
			break;
		    case PGP_NAMETRUST_UNTRUSTED:
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NAMETRUST_UNTRUSTED_SIGNING_KEY");
			warn = 1;
			break;
		    case PGP_NAMETRUST_MARGINAL:
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NAMETRUST_MARGINAL");
			warn = 1;
			break;
		}
	    }
	    else {			/* new trust model */
		validity = ringNameValidity (set, name);
		if (validity == 0) {
		    WarningOutput(TRUE,
				  LEVEL_INFORMATION,
				  "PGP_NEWTRUST_NOT_TRUSTED_SIGNING_KEY");
		    warn = 1;
		}
		else
		    if (!ringTrustValid (set, validity)) {
			WarningOutput(TRUE,
				      LEVEL_INFORMATION,
				      "PGP_NEWTRUST_PARTIAL_TRUST",
				      strtol (getTrustStatement
					      (validity),
					      NULL, 10));
			warn = 1;
		    }
	    }
	    if (warn) {
		namestr = ringNameName (set, name, &len);
		ringTtyPutString (namestr,
				  len, (unsigned)
				  len,
				  TRUE,
				  OUTPUT_WARNING,
				  0,
				  0);
		WarningOutputString(FALSE, 0, "\n");
	    }
	}
    }
    if (warn)
	WarningOutputString(FALSE, 0, "\n");
}