pkrevoke.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

		}
		break;

	case WM_DESTROY :
		UTF8EditDestroy (GetDlgItem (hwnd, IDC_NAME));
		return FALSE;

	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDCANCEL:
			prcs = (PREVOKECERTSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			prcs->bSyncWithServer = FALSE;
			EndDialog (hwnd, 1);
			break;

		case IDOK:
			EndDialog (hwnd, 0);
			break;

		case IDHELP :
			PGPclHtmlHelp (hwnd, kPGPclHelpContext, 0, 0, 
					(char*)kPGPclHelpFile, (DWORD*)IDH_PGPPK_REVOKECERTDIALOG);
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	___________________________________________________
//
//  Revoke selected signature

BOOL 
PKRevokeCert (
		PPGPKEYSSTRUCT	ppks)
{
	PGPPrefRef			prefref			= kInvalidPGPPrefRef;
	BOOL				bRetVal			= TRUE;
	PGPByte*			pPasskey		= NULL;

	PGPSize				sizePasskey;
	PGPKeyDBObjRef		cert;
	PGPKeyDBObjRef		keySigning, keyParent;
	PGPError			err;
	CHAR				sz128[128];
	REVOKECERTSTRUCT	rcs;

	if (IsPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		return FALSE;

	PGPGetPrefBoolean (prefref, kPGPPrefKeyServerSyncOnRevocation, 
			&(rcs.bSyncWithServer));

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &cert, NULL, NULL);

	err = PGPGetSigCertifierKey (cert, ppks->keydbMain, &keySigning);
	if (err == kPGPError_ItemNotFound) 
	{
		keySigning = NULL;
		err = kPGPError_NoErr;
	}

	if (IsntPGPError (PGPclErrorBox (NULL, err))) 
	{
		if (!keySigning) 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
					IDS_CERTKEYNOTONRING, MB_OK|MB_ICONEXCLAMATION);
			return FALSE;
		}

		rcs.ppks = ppks;
		rcs.key = PGPPeekKeyDBObjKey (cert);

		if (DialogBoxParam (g_hinst, MAKEINTRESOURCE(IDD_REVOKECERT), 
				ppks->hwndMain, sRevokeCertDlgProc, (LPARAM)&rcs)) 
		{
			return FALSE;
		}
		
		// get valid passphrase
		LoadString (g_hinst, IDS_SIGNKEYPASSPHRASE, sz128, 128); 
		err = PGPclGetKeyPhrase (g_context, g_tlscontext,
				ppks->hwndMain, sz128, ppks->keydbMain, keySigning,
				NULL, &pPasskey, &sizePasskey);
		PGPclErrorBox (NULL, err);

		// now we have a valid passphrase, if required
		if (IsntPGPError (err)) 
		{
			// update from server
			if (rcs.bSyncWithServer) 
			{
				if (!PKGetFromServerInternal (ppks, FALSE, FALSE, FALSE)) 
				{
					if (PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
							IDS_QUERYCONTINUEREVOKINGCERT, 
							MB_YESNO|MB_ICONQUESTION) == IDNO) 
					{
						bRetVal = FALSE;
					}
				}
			}
		
			if (bRetVal) 
			{
				// make sure we have enough entropy
				PGPclRandom (g_context, ppks->hwndMain, 0);

				err = PGPRevokeSig (cert,
						pPasskey ? 
							PGPOPasskeyBuffer (g_context, 
								pPasskey, sizePasskey) :
							PGPONullOption (g_context),
						PGPOLastOption (g_context));
						
				if (IsntPGPError (PGPclErrorBox (ppks->hwndMain, err))) 
				{
					PKKeyDBModified (ppks, PK_MOD_INDEX_0);
					keyParent = PGPPeekKeyDBObjKey (cert);
					PGPclKeyListUpdateTree (ppks->hKL, 
							kPGPclKeyListUpdateObject, 
							keyParent, FALSE);
					PGPclKeyListSetTree (ppks->hKL,
							kPGPclSelectSpecifiedOnly, cert);
					PKUpdateAllObjectPropertiesWindows (ppks);
					PGPclKeyListUpdateTree (ppks->hKL, 
							kPGPclKeyListUpdateValidities, 
							kInvalidPGPKeyDBObjRef, FALSE);

					// send key to server, if selected
					if (rcs.bSyncWithServer)
						PKSendToServer (ppks, kPGPclDefaultServer);
				}
				else 
					bRetVal = FALSE;
			}
		}
		else 
			bRetVal = FALSE;
	}
	else 
		bRetVal = FALSE;

	if (pPasskey) 
	{
		PGPclFreePasskey (pPasskey, sizePasskey);
		pPasskey = NULL;
	}

	return bRetVal;
}


//	___________________________________________________
//
//  Add designated revoker to key

BOOL 
PKAddRevoker (
		PPGPKEYSSTRUCT	ppks)
{
	PGPPrefRef		prefref				= kInvalidPGPPrefRef;
	PGPKeySetRef	keysetToChoose		= kInvalidPGPKeySetRef;
	PGPKeySetRef	keysetSelected		= kInvalidPGPKeySetRef;
	PGPFilterRef	filterKey			= kInvalidPGPFilterRef;
	PGPFilterRef	filterNotKey		= kInvalidPGPFilterRef;
	PGPFilterRef	filterV4			= kInvalidPGPFilterRef;
	PGPFilterRef	filterFinal			= kInvalidPGPFilterRef;
	PGPError		err					= kPGPError_NoErr;
	PGPByte*		pbyte				= NULL;
	BOOL			bRet				= FALSE;
	PGPUInt32		uCount				= 0;
	PGPBoolean		bSyncWithServer		= FALSE;

	PGPSize			size;
	PGPKeyID		keyid;
	PGPKeyDBObjRef	key;
	CHAR			szPrompt[256];


	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, NULL, NULL);

	err = PGPclPeekClientLibPrefRefs (&prefref, NULL); CKERR;
	err = PGPGetPrefBoolean (prefref, 
			kPGPPrefKeyServerSyncOnAdd, &bSyncWithServer); CKERR;

	// remove our own key from list
	err = PGPGetKeyID (key, &keyid); CKERR;
	err = PGPNewKeyDBObjDataFilter (g_context, 
			kPGPKeyProperty_KeyID, &keyid, sizeof(PGPKeyID),
			kPGPMatchCriterion_Equal, &filterKey); CKERR;
	err = PGPNegateFilter (filterKey, &filterNotKey); CKERR;

	// only allow V4 keys in list
	err = PGPNewKeyDBObjNumericFilter (g_context, 
			kPGPKeyProperty_Version, kPGPKeyVersion_V4,
			kPGPMatchCriterion_GreaterOrEqual, &filterV4); CKERR;

	// now actually create the keyset
	err = PGPIntersectFilters (filterNotKey, filterV4, &filterFinal); CKERR;
	err = PGPFilterKeyDB (ppks->keydbMain, filterFinal, &keysetToChoose);

	err = PGPCountKeys (keysetToChoose, &uCount); CKERR;
	if (uCount < 1) 
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
				IDS_NOTENOUGHKEYSTOADDREVOKER, MB_OK|MB_ICONINFORMATION);
		goto done;
	}

	LoadString (g_hinst, IDS_ADDREVOKERPROMPT, szPrompt, sizeof(szPrompt));
	err = PGPclSelectKeys (g_context, g_tlscontext, 
			ppks->hwndMain, szPrompt, keysetToChoose,
			kPGPclDefaultSelectionFlags, &keysetSelected);

	if (IsntPGPError (err) && PGPKeySetRefIsValid (keysetSelected))
	{
		if (PKMessageBox (ppks->hwndMain, IDS_CAPTIONWARNING, 
				IDS_ADDREVOKERCONFIRM, MB_YESNO|MB_ICONWARNING) == IDYES) 
		{
			err = PGPclGetKeyPhrase (g_context, g_tlscontext,
						ppks->hwndMain, NULL, ppks->keydbMain, key, 
						NULL, &pbyte, &size); CKERR;

			// update from server
			if (IsntPGPError (err) && bSyncWithServer) 
			{
				if (!PKGetFromServerInternal (ppks, FALSE, FALSE, FALSE)) 
				{
					if (PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
								IDS_QUERYCONTINUEADDING, 	
								MB_YESNO|MB_ICONQUESTION) == IDNO) 
					{
						err = kPGPError_UserAbort;
					}
				}
			}
		
			if (IsntPGPError (err)) 
			{
				err = PGPAddKeyOptions (key, 
					PGPORevocationKeySet (g_context, keysetSelected),
					pbyte ?
						PGPOPasskeyBuffer (g_context, pbyte, size) :
						PGPONullOption (g_context),
					PGPOLastOption (g_context)); CKERR;
				PKKeyDBModified (ppks, PK_MOD_INDEX_0);
			}
		}
		else
			err = kPGPError_UserAbort;
	}

	// send to server
	if (IsntPGPError (err) && bSyncWithServer) 
		PKSendToServer (ppks, kPGPclDefaultServer);

	if (IsntPGPError (err)) 
	{
		bRet = TRUE;

		if (bSyncWithServer) 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_ADDEDSENTREVOKERS, MB_OK|MB_ICONINFORMATION);
		}
		else 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_ADDEDREVOKERS, MB_OK|MB_ICONINFORMATION);
		}
	}

done :
	if (IsntNull (pbyte))
		PGPclFreePasskey (pbyte, size);
	if (PGPKeySetRefIsValid (keysetSelected))
		PGPFreeKeySet (keysetSelected);
	if (PGPKeySetRefIsValid (keysetToChoose))
		PGPFreeKeySet (keysetToChoose);
	if (PGPFilterRefIsValid (filterFinal))
		PGPFreeFilter (filterFinal);
	else
	{
		if (PGPFilterRefIsValid (filterV4))
			PGPFreeFilter (filterV4);

		if (PGPFilterRefIsValid (filterNotKey))
			PGPFreeFilter (filterNotKey);
		else
		{
			if (PGPFilterRefIsValid (filterKey))
				PGPFreeFilter (filterKey);
		}
	}

	PGPclErrorBox (ppks->hwndMain, err);

	return bRet;
}