pgpk.c

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

		FreeString(&string);

		if((err = selectOneDBObj(iter,
								 KDBTYPE_USERID,
								 selecttype, header)) <= 0) {
			StatusOutput(TRUE, "NO_USER_IDS_SELECTED", prep);
			err = 0;
		}
		else {
			if (selecttype == KDBTYPE_CERT) {
				if((err = LoadString(&string, "PLEASE_SELECT_A_SIGNATURE")) ==
				   PGPERR_OK && string) {
					sprintf(header, string, prep);
					FreeString(&string);
					if((err = selectOneDBObj(iter,
											KDBTYPE_CERT,
											0,
											header)) <= 0) {
						StatusOutput(TRUE, "NO_SIGNATURES_SELECTED", prep);
					}
				}
			}
		}
	}

	return err;	/* success */
}


/*
 * Selection routine. Selects a key, userid or
 * signature depending on the selecttype parameter, a RINGTYPE_ value.
 * Returns pointer to a key iterator that references the selected object.
 * Prep is a prepositional clause like "to be removed".  Returns 0 if
 * no keys selected, negative on error.  If objects are selected returns
 * the number of objects at that level, e.g. if a user ID is selected it
 * returns the number of user ID's on that key; if a signature is selected
 * it returns the number of sigs on that user ID.
 * This will always be at least 1.
 */
static int
selectDBObject(int argc, char **argv,
				 PGPKeySet *fullset, int selecttype, char const *prep,
			   PGPKeyIter **iter)
{
	PGPKeySet *subset = NULL;
	PGPKeyList *keylist = NULL;
	char namebuf[256];
	char header[256], *string = NULL;
	size_t namelen;
	int err = 0;
	int anykeys;

	/*
	 * Protect header[] from being overfilled by the sprintf's to it.
	 * prep is only set within the program to small strings, so this
	 * should never happen.
	 */
	pgpAssert (strlen(prep) < 100);

	if (argc == 0) {
		InteractionOutput(TRUE, "A_USERID_IS_REQUIRED", prep);
		namelen = pgpTtyGetString (namebuf, sizeof (namebuf), TRUE);
		argv = (char **) malloc(sizeof(char *));
		argv[0] = namebuf;
		argc = 1;
	}

	/* Build ordered subset of keys */
	anykeys = selectKeyArgs (argc, argv, fullset, &subset, 0, FALSE);

	if (anykeys) {
		keylist = pgpOrderKeySet (subset, kPGPUserIDOrdering);
		if (keylist) {
			*iter = pgpNewKeyIter (keylist);
			if(*iter) {
				switch(selecttype) {
					case KDBTYPE_USERID:
						LoadString(&string,
								   "PLEASE_SELECT_A_KEY_WITH_USERID");
						break;

					case KDBTYPE_CERT:
						LoadString(&string, "PLEASE_SELECT_A_KEY_WITH_SIG");
						break;

					default:
						LoadString(&string, "PLEASE_SELECT_A_KEY");
						break;
				}

				if(string) {
					sprintf(header, string, prep);
					FreeString(&string);
					/*  Point the iterator at the selected key  */
					err = selectOneDBObj(iter,
										 KDBTYPE_KEY,
										 selecttype,
										 header);
				}
			}
			else {
				ErrorOutput(TRUE, LEVEL_CRITICAL, "UNABLE_TO_CREATE_ITER");
				err = PGPERR_NOMEM;
			}
		}
		else {
			ErrorOutput(TRUE, LEVEL_CRITICAL, "UNABLE_TO_ORDER_KEYSET");
			err = PGPERR_NOMEM;
		}
	}

	if (err <= 0) {
		StatusOutput(TRUE, "NO_KEYS_SELECTED", prep);
		err = 0;
	}
	else {
		/* Handle signature and user ID selection */
		if (selecttype != KDBTYPE_KEY) {
			err = selectChildObject(iter, selecttype, prep);
		}
	}

	if (keylist)
		pgpFreeKeyList (keylist);
 	if (subset)
		pgpFreeKeySet (subset);
	return err;
}

/*
 * Selects one key from those that match the given substring, or
 * from all keys if <subStr> is NULL.
 */
static PGPError
selectOneKey(char const *subStr, PGPKeySet *fullset, PGPKey **key,
			char const *header)
{
	PGPError		result;
	PGPKeySet *		matches;
	PGPKeyList *	matchList;
	PGPKeyIter *	iter = NULL;

	*key = NULL;

	if (subStr == NULL) {
		pgpIncKeySetRefCount(fullset);
		matches = fullset;
	} else {
		matches = pgpFilterKeySetAuto(fullset, subStr);
	}
	if (matches == NULL)
		return -1;
	
	matchList = pgpOrderKeySet(matches, kPGPUserIDOrdering);
	pgpFreeKeySet(matches);
	if (matchList == NULL)
		return PGPERR_NOMEM;

	iter = pgpNewKeyIter(matchList);
	pgpFreeKeyList(matchList);
	if (iter == NULL)
		return PGPERR_NOMEM;

	result = selectOneDBObj(&iter,
							KDBTYPE_KEY,
							KDBTYPE_KEY,
							(char *) header);
	if (result > 0)
	{
		result = PGPERR_OK;
		*key = pgpKeyIterKey(iter);
	}

	if(iter) {
		pgpFreeKeyIter(iter);
	}
	return result;
}


static int
doKeyAdd (int argc, char *argv[])
{
	PGPKeySet		*newset = NULL;
	PGPKeyList		*list = NULL;
	PGPFileRef		*fileRef = NULL;
	int             newkeys = 0;
	int             err = PGPERR_OK, port = 0;
	char server[1024], file[1024], protocol[16];

	if (!argc) {
		ErrorOutput(TRUE, LEVEL_CRITICAL, "NO_KEYFILE_SPECIFIED");
		err = PGPERR_MISSING_ARGUMENT;
	}
	
	while (argc--) {
		if(parse_url(protocol, server, file, &port, argv[argc]) ==
		   PGPERR_OK) {
			char *buffer = NULL;

			if(GetKeyInfo(protocol,
						  server,
						  file,
						  port,
						  &buffer)
			   == PGPERR_OK) {
				newset = pgpImportKeyBuffer((unsigned char *) buffer,
											strlen(buffer));
				pgpFree(buffer);
			}
			else {
				newset = NULL;
				continue;
			}
		}
		else {
			Boolean ImportedOK = FALSE;

			if((fileRef = pgpNewFileRefFromFullPath (argv[argc]))) {
				if((newset = pgpImportKeyFile (fileRef))) {
					ImportedOK = TRUE;
				}
				pgpFreeFileRef(fileRef);
			}

			if(!ImportedOK) {
				ErrorOutput(TRUE,
							LEVEL_SEVERE,
							"UNABLE_TO_IMPORT_KEYFILE",
							argv[0]);
				argv++;
				continue;
			}
		}

		StatusOutputString(FALSE, "\n");

		if(newset) {
			StatusOutput(TRUE,
						 "ADDING_KEYS");
			/* Order keys for display */
			list = pgpOrderKeySet (newset, kPGPAnyOrdering);
			if (list) {
				kdbTtyKeyView(list, defaultset, argv[0], 0);
				newkeys++;
				pgpAddKeys (defaultset, newset);
				pgpFreeKeyList (list); list = NULL;
				PrimaryOutputString("\n");
				argv++;
				/*
				 * Must commit changes before freeing source set, a temporary
				 * library restriction.
				 */
				pgpCommitKeyRingChanges (defaultset);
				pgpFreeKeySet (newset); newset = NULL;
			}
			else {
				ErrorOutput(TRUE, LEVEL_CRITICAL, "UNABLE_TO_CREATE_KEYLIST");
				err = PGPERR_NOMEM;
			}
		}

		if (newkeys) {
			StatusOutput(TRUE, "KEYS_ADDED_SUCCESSFULLY");
			err = PGPERR_OK;
		}
		else {
			ErrorOutput(TRUE, LEVEL_CRITICAL, "NO_KEYS_TO_ADD");
		}
	}

	if (list)
		pgpFreeKeyList (list);
	if (newset)
		pgpFreeKeySet (newset);

	return err;
}

static int
doKeyExtract (struct PgpEnv const *env,
			  struct Flags *flags,
			  int argc,
			  char *argv[])
{
	PGPKeySet	*keyset = NULL;
	PGPFileRef	*fileRef = NULL;
	int err, port = 0;
	char server[1024], file[1024], protocol[16];

	err = selectKeyArgs (argc, argv, defaultset, &keyset, 0, TRUE);

	if(err > 0) {
		if(flags->outfile) {
			if(parse_url(protocol, server, file, &port, flags->outfile)
			   == PGPERR_OK) {
				/*No file specified, dump it out to the console:*/
				char *buffer = NULL;
				size_t length = 1;
			
				if((buffer = pgpAlloc(sizeof(char) * length))) {
					pgpExportKeyBuffer(keyset,
									   (unsigned char *) buffer,
									   &length);
					pgpFree(buffer);
					++length; /*Make room for a null*/
					if((buffer = pgpAlloc(sizeof(char) * length))) {
						err = pgpExportKeyBuffer(keyset,
												 (unsigned char *) buffer,
												 &length);
						if(err == PGPERR_OK) {
							if(strcasecmp(protocol, "hkp") == 0) {
								PutKeyInfoHkp(server, port, buffer);
							}
							else {
								if(strcasecmp(protocol, "http") == 0)
									ErrorOutput(TRUE,
												LEVEL_CRITICAL,
												"NO_HTTP_SEND");
								else
									ErrorOutput(TRUE,
												LEVEL_CRITICAL,
												"UNKNOWN_PROTOCOL",
												protocol);
							}
							pgpFree(buffer);
						}
					}
					else
						err = PGPERR_NOMEM;
				}
			}
			else {
				if(pgpTtyCheckOverwrite (env, flags->outfile)) {
					err = PGPERR_NO_FILE;
				}
				else {
					fileRef =
						pgpNewFileRefFromFullPath ((char *) flags->outfile);
					if (fileRef != NULL) {
						err = pgpExportKeyFile (keyset, fileRef);
						pgpFreeFileRef (fileRef);
					}
					else
						err = PGPERR_NOMEM;
				}
			}
		}
		else {
			/*No file specified, dump it out to the console:*/
			char *buffer = NULL;
			size_t length = 1;
			
			if((buffer = pgpAlloc(sizeof(char) * length))) {
				pgpExportKeyBuffer(keyset,
								   (unsigned char *) buffer,
								   &length);
				pgpFree(buffer);
				++length; /*Make room for a null*/
				if((buffer = pgpAlloc(sizeof(char) * length))) {
					err = pgpExportKeyBuffer(keyset,
											 (unsigned char *) buffer,
											 &length);
					if(err == PGPERR_OK) {
						*(buffer + length) = '\0';
						PrimaryOutputString(buffer);
						pgpFree(buffer);
					}
				}
				else
					err = PGPERR_NOMEM;
			}
			else
				err = PGPERR_NOMEM;
		}
	}
	else {
		if(err == 0)
			ErrorOutput(TRUE,
						LEVEL_CRITICAL,
						"NO_KEYS_SELECTED_FOR_EXTRACTION");
	}

	if(keyset)
		pgpFreeKeySet (keyset);

	return err;
}

static int
doKeyDisable (int argc, char *argv[])
{
	Boolean disabled;
	int done_something = 0;
	int err;
	PGPKeyIter     *iter = NULL;
	PGPKey         *key;
	char *SentenceFragment = NULL;

	if(LoadString(&SentenceFragment, "TO_DISABLE_OR_ENABLE") == PGPERR_OK &&
	   SentenceFragment) {

		/* Select object to remove */
		if((err = selectDBObject(argc, argv, defaultset, KDBTYPE_KEY,
								 SentenceFragment, &iter)) > PGPERR_OK) {
			key = pgpKeyIterKey (iter);
			pgpFreeKeyIter (iter);
			pgpGetKeyBoolean (key, kPGPKeyPropIsDisabled, &disabled);

			InteractionOutputString(TRUE, "\n");
			if (disabled) {
				InteractionOutput(TRUE, "ENABLE_THIS_KEY");
				if (pgpTtyGetBool (0, TRUE)) {
					if ((err = pgpEnableKey (key)) == PGPERR_OK) {
						done_something = 1;
						StatusOutput(TRUE, "KEY_ENABLED");
					}
					else
						PGPErrCodeOutput(TRUE, LEVEL_CRITICAL, err);
				}
			}
			else {
				InteractionOutput(TRUE, "DISABLE_THIS_KEY");
				if (pgpTtyGetBool (0, TRUE)) {
					if ((err = pgpDisableKey (key)) == PGPERR_OK) {
						done_something = 1;
							StatusOutput(TRUE, "KEY_DISABLED");
					}
				}
			}
			if (done_something)	
				pgpCommitKeyRingChanges (defaultset);
		}
		else
			err = PGPERR_OK;
	}
	return 0;
}

static int
doKeyCheck (struct Flags *flags, int argc, char *argv[])
{
	PGPKeySet  *subset = NULL;
	PGPKeyList *keylist = NULL;

	(void)flags;

	if (argc > 0) {
		selectKeyArgs (argc, argv, defaultset, &subset, 0, FALSE);
		if (subset == NULL)
			return -1;
		pgpCheckKeyRingCertificates (subset);
		pgpCommitKeyRingChanges (defaultset);
		keylist = pgpOrderKeySet (subset, kPGPAnyOrdering);
		kdbTtyKeyView (keylist, defaultset, NULL, 4);
		pgpFreeKeyList (keylist);
		pgpFreeKeySet (subset);
	}
	else {
		pgpCheckKeyRingCertificates (defaultset);
		pgpCommitKeyRingChanges (defaultset);
		keylist = pgpOrderKeySet (defaultset, kPGPAnyOrdering);
		kdbTtyKeyView (keylist, defaultset, NULL, 4);
		pgpFreeKeyList (keylist);
	}
	return 0;
}


static int
doKeyList (struct Flags *flags, int argc, char *argv[])
{
	PGPKeySet *subset = NULL;
	PGPKeyList *keylist = NULL;
	int list_mode = 0;

	selectKeyArgs (argc, argv, defaultset, &subset, 1, TRUE);
	if (subset == NULL)
		return -1;

	if (flags->argc > 0 && flags->args[0] == 'l')
	        list_mode = 2;            /* verbose */
	keylist = pgpOrderKeySet (subset, kPGPUserIDOrdering);
	kdbTtyKeyView (keylist, defaultset, NULL, list_mode);
	pgpFreeKeyList (keylist);
	pgpFreeKeySet (subset);
	return 0;
}

/*
 * Give the user an opportunity to edit the trust of object obj.
 * Return 1 if he changes it, 0 if he does not.
 * firsttime means that we have not previously had a trust value for
 * this key, which changes the wording of the questions somewhat.
 * If PGPTRUSTMODEL is 0, obj should be a key, else it should be a name.
 * The key and/or name should have been printed just before this routine
 * is called.
 */
static int
doKeyEditTrust(PGPKeyIter *iter, int firsttime)
{
	byte keytrust;
	long oldtrust;
	unsigned long confvalue;
	unsigned long trustcode;
	int len;
#if ONLY_TRUST_VALID_KEYS
	long valid;
#endif
	PgpTrustModel pgptrustmodel;