kmkeyops.c

vc环境下的pgp源码

{
	TL_TREEITEM tli;

	tli.hItem = lptli->hItem;
	tli.mask = TLIF_NEXTHANDLE;
	TreeList_GetItem (hWndTree, &tli);
	if (!tli.hItem) {
		tli.hItem = lptli->hItem;
		tli.mask = TLIF_PREVHANDLE;
		TreeList_GetItem (hWndTree, &tli);
		if (!tli.hItem) {
			tli.hItem = lptli->hItem;
			tli.mask = TLIF_PARENTHANDLE;
			TreeList_GetItem (hWndTree, &tli);
		}
	}

	return tli.hItem;
}

	
//	_______________________________________________
//
//  Delete a single object
//	routine called either from KMDeleteObject or as a
//	callback function from the TreeList control to 
//	delete a single item.
//
//	lptli	= pointer to TreeList item to delete

static BOOL CALLBACK 
sDeleteSingleObject (
		TL_TREEITEM*	lptli, 
		LPARAM			lParam) 
{
	PDELETESTRUCT	pds			= (PDELETESTRUCT)lParam;
	PGPKeySetRef	keyset;
	PGPKeyRef		key;
	PGPUserIDRef	userid;
	BOOL			bPrimary;
	INT				iConfirm;
	LONG			lVal;
	PGPError		err;

	switch (lptli->iImage) {
	case IDX_RSASECKEY :
	case IDX_RSASECDISKEY :
	case IDX_RSASECSHRKEY :
	case IDX_DSASECKEY :
	case IDX_DSASECDISKEY :
	case IDX_DSASECSHRKEY :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFPRIVKEY, pds);
		if (iConfirm == IDYES) {
			if ((PGPKeyRef)(lptli->lParam) == pds->keyDefault) {
				if (KMMessageBox (pds->pKM->hWndParent, IDS_CAPTION, 
					IDS_DELCONFDEFKEY,
					MB_YESNO|MB_TASKMODAL|MB_DEFBUTTON2|MB_ICONWARNING)
					==IDNO) 
						return TRUE;
			}
			PGPNewSingletonKeySet ((PGPKeyRef)(lptli->lParam),
									&keyset);
			KMGetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), &lVal);
			KMSetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), 0);
			if (IsntPGPError (PGPclErrorBox (NULL, PGPRemoveKeys (
					keyset, pds->pKM->KeySetDisp)))) {
				KMDeletePropertiesKey (pds->pKM, (PGPKeyRef)(lptli->lParam));
				pds->bItemModified = TRUE;
				if (!pds->bItemNotDeleted) 
					pds->hPostDeleteFocusItem = 
							sGetAdjacentItem (pds->pKM->hWndTree, lptli); 
				TreeList_DeleteItem (pds->pKM->hWndTree, lptli);
			}
			else 
				KMSetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), lVal);

			PGPFreeKeySet (keyset);
		}
		if (iConfirm == IDCANCEL) return FALSE; 
		else return TRUE;

	case IDX_RSASECREVKEY :
	case IDX_RSASECEXPKEY :
	case IDX_DSASECREVKEY :
	case IDX_DSASECEXPKEY :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFPRIVKEY, pds);
		if (iConfirm == IDYES) {
			PGPNewSingletonKeySet ((PGPKeyRef)(lptli->lParam),
									&keyset);
			KMGetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), &lVal);
			KMSetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), 0);
			if (IsntPGPError (PGPclErrorBox (NULL, PGPRemoveKeys (
					keyset, pds->pKM->KeySetDisp)))) {
				KMDeletePropertiesKey (pds->pKM, (PGPKeyRef)(lptli->lParam));
				pds->bItemModified = TRUE;
				if (!pds->bItemNotDeleted) 
					pds->hPostDeleteFocusItem = 
							sGetAdjacentItem (pds->pKM->hWndTree, lptli); 
				TreeList_DeleteItem (pds->pKM->hWndTree, lptli);
			}
			else 
				KMSetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), lVal);

			PGPFreeKeySet (keyset);
		}
		if (iConfirm == IDCANCEL) return FALSE; 
		else return TRUE;

	case IDX_RSAPUBKEY :
	case IDX_RSAPUBDISKEY :
	case IDX_RSAPUBREVKEY :
	case IDX_RSAPUBEXPKEY :
	case IDX_DSAPUBKEY :
	case IDX_DSAPUBDISKEY :
	case IDX_DSAPUBREVKEY :
	case IDX_DSAPUBEXPKEY :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFKEY, pds);
		if (iConfirm == IDYES) {
			PGPNewSingletonKeySet ((PGPKeyRef)(lptli->lParam), 
									&keyset);
			KMGetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), &lVal);
			KMSetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), 0);
			if (IsntPGPError (PGPclErrorBox (NULL, PGPRemoveKeys (
								keyset, pds->pKM->KeySetDisp)))) {
				KMDeletePropertiesKey (pds->pKM, (PGPKeyRef)(lptli->lParam));
				pds->bItemModified = TRUE;
				if (!pds->bItemNotDeleted) 
					pds->hPostDeleteFocusItem = 
							sGetAdjacentItem (pds->pKM->hWndTree, lptli); 
				TreeList_DeleteItem (pds->pKM->hWndTree, lptli);
			}
			else
				KMSetKeyUserVal (pds->pKM, (PGPKeyRef)(lptli->lParam), lVal);
			PGPFreeKeySet (keyset);
		}
		if (iConfirm == IDCANCEL) return FALSE;
		else return TRUE;

	case IDX_RSAUSERID :
	case IDX_DSAUSERID :
		if (KMIsThisTheOnlyUserID (pds->pKM, (PGPUserIDRef)(lptli->lParam))) {
			KMMessageBox (pds->pKM->hWndParent, IDS_CAPTION, 
						IDS_DELONLYUSERID, MB_OK|MB_ICONEXCLAMATION);
			break;
		}
		// fall through

	case IDX_PHOTOUSERID :
	case IDX_INVALIDUSERID :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFUSERID, pds);
		if (iConfirm == IDYES) {
			key = KMGetKeyFromUserID (pds->pKM, 
											(PGPUserIDRef)(lptli->lParam));

			PGPGetPrimaryUserID (key, &userid);
			if (userid == (PGPUserIDRef)(lptli->lParam)) 
				bPrimary = TRUE;
			else 
				bPrimary = FALSE;

			KMGetUserIDUserVal (pds->pKM,(PGPUserIDRef)(lptli->lParam),&lVal);
			KMSetUserIDUserVal (pds->pKM,(PGPUserIDRef)(lptli->lParam),0);
			err = PGPRemoveUserID ((PGPUserIDRef)(lptli->lParam));
			if (IsntPGPError (err)) {			
				pds->bItemModified = TRUE;
				if (bPrimary) {
					pds->bDeletedPrimaryUserID = TRUE;
				}
				else { 
					if (!pds->bItemNotDeleted) 
						pds->hPostDeleteFocusItem = 
							sGetAdjacentItem (pds->pKM->hWndTree, lptli); 
					TreeList_DeleteItem (pds->pKM->hWndTree, lptli);
				}
			}
			else {
				PGPclErrorBox (NULL, err);
				KMSetUserIDUserVal (pds->pKM, 
									(PGPUserIDRef)(lptli->lParam), lVal);
			}
		}
		if (iConfirm == IDCANCEL) return FALSE;
		else return TRUE;

	case IDX_CERT :
	case IDX_REVCERT :
	case IDX_BADCERT :
	case IDX_EXPCERT :
	case IDX_EXPORTCERT :
	case IDX_TRUSTEDCERT :
	case IDX_METACERT :
	case IDX_X509CERT :
	case IDX_X509EXPCERT :
	case IDX_X509REVCERT :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFCERT, pds);
		if (iConfirm == IDYES) {
			KMGetCertUserVal (pds->pKM, (PGPSigRef)(lptli->lParam), &lVal);
			KMSetCertUserVal (pds->pKM, (PGPSigRef)(lptli->lParam), 0);
			if (IsntPGPError (PGPclErrorBox (NULL, PGPRemoveSig (
											(PGPSigRef)(lptli->lParam))))) {
				pds->bItemModified = TRUE;
				if (!pds->bItemNotDeleted) 
					pds->hPostDeleteFocusItem = 
							sGetAdjacentItem (pds->pKM->hWndTree, lptli); 
				TreeList_DeleteItem (pds->pKM->hWndTree, lptli);
			}
			else
				KMSetCertUserVal (pds->pKM, (PGPSigRef)(lptli->lParam), lVal);
		}
		if (iConfirm == IDCANCEL) return FALSE;
		else return TRUE;
	}

	return FALSE;
}


//	_______________________________________________
//
//  Delete selected key or keys

BOOL 
KMDeleteObject (PKEYMAN pKM) 
{
	TL_TREEITEM		tli;
	DELETESTRUCT	ds;

	ds.lpfnCallback = sDeleteSingleObject;
	ds.context = pKM->Context;
	ds.pKM = pKM;
	ds.bItemModified = FALSE;
	ds.bDeleteAll = FALSE;
	ds.bItemNotDeleted = FALSE;
	ds.bDeletedPrimaryUserID = FALSE;
	ds.hPostDeleteFocusItem = NULL;
	PGPGetDefaultPrivateKey (pKM->KeySetMain, &ds.keyDefault);

	// call callback function for all selected objects
	TreeList_IterateSelected (pKM->hWndTree, &ds);

	if (ds.bItemModified) {
		KMCommitKeyRingChanges (pKM);
		if (ds.bDeletedPrimaryUserID) {
			KMSetFocus (pKM, NULL, FALSE);
			TreeList_DeleteTree (pKM->hWndTree, TRUE);
			KMAddColumns (pKM);
			KMLoadKeyRingIntoTree (pKM, FALSE, FALSE, TRUE);
		}
		else {
			KMLoadKeyRingIntoTree (pKM, FALSE, FALSE, FALSE);

			if (ds.bItemNotDeleted) {
				if (ds.hPostDeleteFocusItem) {
					tli.hItem = ds.hPostDeleteFocusItem;
					TreeList_Select (pKM->hWndTree, &tli, FALSE);
				}
				else KMSetFocus (pKM, NULL, FALSE);
			}
			else {
				if (ds.hPostDeleteFocusItem) {
					tli.hItem = ds.hPostDeleteFocusItem;
					TreeList_Select (pKM->hWndTree, &tli, TRUE);
					tli.stateMask = TLIS_SELECTED;
					tli.state = 0;
					tli.mask = TLIF_STATE;
					TreeList_SetItem (pKM->hWndTree, &tli);
				}
				KMSetFocus (pKM, NULL, FALSE);
			}
		}
		InvalidateRect (pKM->hWndTree, NULL, TRUE);
	}
	return (ds.bItemModified);
}


//	_______________________________________________
//
//	Set focused key to be default signing key

BOOL 
KMSetDefaultKey (PKEYMAN pKM) 
{
	PGPKeyRef	keyNewDef;
	PGPKeyRef	keyOldDef;
	PGPError	err;

	PGPGetDefaultPrivateKey (pKM->KeySetMain, &keyOldDef);
	keyNewDef = (PGPKeyRef) KMFocusedObject (pKM);

	err = PGPSetDefaultPrivateKey (keyNewDef);
	if (IsntPGPError (PGPclErrorBox (pKM->hWndParent, err))) {

		PGPclErrorBox (NULL, PGPsdkSavePrefs (pKM->Context));
		if (keyOldDef)
			KMUpdateKeyInTree (pKM, keyOldDef, FALSE);
		KMUpdateKeyInTree (pKM, keyNewDef, FALSE);

		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//	Set focused UID to be primary UID

BOOL 
KMSetPrimaryUserID (PKEYMAN pKM) 
{
	PGPByte*		pPasskey			= NULL;
	LPSTR			pszPhrase			= NULL;

	PGPUserIDRef	userid;
	PGPKeyRef		key;
	PGPUInt32		iAlg;
	CHAR			sz[128];
	PGPError		err;
	PGPSize			sizePasskey;

	userid = (PGPUserIDRef) KMFocusedObject (pKM);
	key = KMGetKeyFromUserID (pKM, userid);

	PGPGetKeyNumber (key, kPGPKeyPropAlgID, &iAlg);
	if (iAlg == kPGPPublicKeyAlgorithm_RSA) 
	{
		err = PGPSetPrimaryUserID (userid);
	}

	else if (iAlg == kPGPPublicKeyAlgorithm_DSA) 
	{
		// get valid passphrase
		LoadString (g_hInst, IDS_SELKEYPASSPHRASE, sz, sizeof(sz)); 
		err = KMGetKeyPhrase (pKM->Context, pKM->tlsContext,
						pKM->hWndParent, sz,
						pKM->KeySetMain, key,
						&pszPhrase, &pPasskey, &sizePasskey);
		PGPclErrorBox (NULL, err);

		// now we have a valid passphrase
		if (IsntPGPError (err)) 
		{
			err = PGPCertifyPrimaryUserID (userid,
				pPasskey ?
					PGPOPasskeyBuffer (pKM->Context, pPasskey, sizePasskey) :
					PGPOPassphrase (pKM->Context, pszPhrase),
				PGPOLastOption (pKM->Context));
		}

		if (pszPhrase)
			KMFreePhrase (pszPhrase);
		if (pPasskey)
			KMFreePasskey (pPasskey, sizePasskey);
	}

	if (IsntPGPError (PGPclErrorBox (pKM->hWndParent, err)))
	{
		KMCommitKeyRingChanges (pKM);
		KMUpdateKeyInTree (pKM, key, TRUE);
		InvalidateRect (pKM->hWndTree, NULL, TRUE);
		return TRUE;
	}
	else
		return FALSE;
}


//	_______________________________________________
//
//	add selected keys to main keyset

BOOL 
KMAddSelectedToMain (PKEYMAN pKM) 
{
	PGPKeySetRef		keysetMain	= kInvalidPGPKeySetRef;
	PGPKeySetRef		keysetToAdd	= kInvalidPGPKeySetRef;
	PGPError			err			= kPGPError_NoErr;
	BOOL				bSecret		= FALSE;
	BOOL				bRet		= FALSE;

	err = KMGetSelectedKeys (pKM, &keysetToAdd, NULL);

	if (PGPKeySetRefIsValid (keysetToAdd)) 
	{
		if (pKM->bMainKeySet)
			keysetMain = pKM->KeySetMain;

		bSecret = KMCheckForSecretKeys (keysetToAdd);
		bRet = CLAddKeysToMain (pKM->Context, pKM->hWndParent, 
							keysetToAdd, keysetMain);

		if (bRet && bSecret)
		{
			KMMessageBox (pKM->hWndParent, IDS_CAPTION, 
					IDS_IMPORTEDSECRETKEYS, 
					MB_OK|MB_ICONEXCLAMATION);
		}

		PGPFreeKeySet (keysetToAdd);
	}

	return bRet;
}
	
//	_______________________________________________
//
//	routine called as a callback function from the 
//  PGPCheckKeyRingSigs function

static PGPError 
sKeyCheckEventHandler(
		PGPContextRef	context,
		PGPEvent		*event, 
		PGPUserValue	userValue)
{
	PREVERIFYSTRUCT prvs;
	CHAR			sz[64];
	INT				iTotal;

	prvs = (PREVERIFYSTRUCT)userValue;

	iTotal = LOWORD (event->data.nullData.bytesTotal);
	if (iTotal != prvs->iNumSigsTotal) {
		prvs->iNumSigsTotal = iTotal;

		EnableWindow (GetDlgItem (prvs->hwndProgress, IDCANCEL), TRUE);

		LoadString (g_hInst, IDS_VERIFYING, sz, sizeof(sz));
		SetDlgItemText (prvs->hwndProgress, IDC_TEXT, sz);

		SendDlgItemMessage (prvs->hwndProgress, IDC_PROGRESSBAR, 
					PBM_SETRANGE, 0, MAKELPARAM (0, prvs->iNumSigsTotal));
	}

	SendDlgItemMessage (prvs->hwndProgress, IDC_PROGRESSBAR, 
			PBM_SETPOS, LOWORD (event->data.nullData.bytesWritten), 0);

	if (prvs->bCancel)
		return kPGPError_UserAbort;
	else 
		return kPGPError_NoErr;
}
	
//	_______________________________________________
//
//	reverify signature progress dialog message procedure

static BOOL CALLBACK 
sReverifyProgressDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 								
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	PREVERIFYSTRUCT prvs;
	CHAR			sz[64];

	switch (uMsg) {
	case WM_INITDIALOG :
		SetWindowLong (hDlg, GWL_USERDATA, lParam);
		prvs = (PREVERIFYSTRUCT)lParam;
		LoadString (g_hInst, IDS_PREPARINGTOVERIFY, sz, sizeof(sz));
		SetDlgItemText (hDlg, IDC_TEXT, sz);
		prvs->hwndProgress = hDlg;
		return TRUE;

	case WM_APP :
		prvs = (PREVERIFYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
		SetForegroundWindow (prvs->hwndParent);
		EndDialog (hDlg, 0);
		break;

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDCANCEL :
			prvs = (PREVERIFYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			prvs->bCancel = TRUE;
			break;
		}
		return TRUE;
	}
	return FALSE;
}

//	_______________________________________________
//
//	reverify signatures thread routine

static DWORD WINAPI 
sReverifyProgressThreadRoutine (LPVOID lpvoid)
{
	PREVERIFYSTRUCT		prvs	= (PREVERIFYSTRUCT)lpvoid;

	DialogBoxParam (g_hInst, 
					MAKEINTRESOURCE(IDD_REVERIFYING), NULL, 
					sReverifyProgressDlgProc, (LPARAM)prvs);
								
	return 0;
}

//	_______________________________________________
//
//	reverify signatures of selected keys

BOOL 
KMReverifySigs (PKEYMAN pKM) 
{	
	PGPKeySetRef		keysetReverify	= kInvalidPGPKeySetRef;
	PGPError			err				= kPGPError_NoErr;
	REVERIFYSTRUCT		rvs;
	DWORD				dw;

	rvs.hwndParent = pKM->hWndParent;
	rvs.hwndProgress = NULL;
	rvs.iNumSigsTotal = -1;
	rvs.bCancel = FALSE;
	CreateThread (NULL, 0, sReverifyProgressThreadRoutine, &rvs, 0, &dw);

	// wait for dialog box
	EnableWindow (pKM->hWndParent, FALSE);
	while (rvs.hwndProgress == NULL) Sleep (100);

	err = KMGetSelectedKeys (pKM, &keysetReverify, NULL);

	if (PGPKeySetRefIsValid (keysetReverify)) 
	{
		err = PGPCheckKeyRingSigs (keysetReverify,
					pKM->KeySetMain, TRUE, sKeyCheckEventHandler, &rvs);
	}

	// send message to close down dialog
	SendMessage (rvs.hwndProgress, WM_APP, 0, 0);
	EnableWindow (pKM->hWndParent, TRUE);
					
	if (IsntPGPError (PGPclErrorBox (NULL, err))) {
		KMCommitKeyRingChanges (pKM);
		KMLoadKeyRingIntoTree (pKM, FALSE, FALSE, FALSE);
		InvalidateRect (pKM->hWndTree, NULL, TRUE);
	}

	if (PGPKeySetRefIsValid (keysetReverify)) 
		PGPFreeKeySet (keysetReverify);

	return (IsntPGPError (err));
}