pgppassphrasedialog.cpp

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

	{
		char MsgTxt[255];
		char StrRes[500];

		LoadString (gPGPsdkUILibInst, IDS_NUMUNKNOWNKEYS, StrRes, sizeof(StrRes));
	
		sprintf(MsgTxt,StrRes,options->mMissingKeyIDCount);

		SendDlgItemMessage (hDlg, IDC_KEYLISTBOX, LB_INSERTSTRING, -1, 
			(LPARAM)MsgTxt);
	}

	if(!bAtLeastOneValidSecretKey)
	{
		EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), FALSE);
		ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_HIDE);
		EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), FALSE);
		ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDOK), SW_HIDE);
		EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
		ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_CANNOTDECRYPTTEXT),SW_SHOW);
	}
	else
	{
		EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), TRUE);
		ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_SHOW);
		EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), TRUE);
		ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_SHOW);
		ShowWindow (GetDlgItem (hDlg, IDOK), SW_SHOW);
		EnableWindow (GetDlgItem (hDlg, IDOK), TRUE);
		ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_SHOW);
		ShowWindow (GetDlgItem (hDlg, IDC_CANNOTDECRYPTTEXT),SW_HIDE);
	}

	return bAtLeastOneValidSecretKey;
}

//	____________________________
//
//  setup keyselection combo box

BOOL 
InitSigningKeyComboBox (HWND hDlg, CPGPKeySetPassphraseDialogOptions *options) 
{
	PGPKeyListRef	KeyList;
	PGPKeyIterRef	KeyIter;
	PGPKeyDBObjRef	Key;
	UINT			uIndex;
	INT				iKeyDefault, iKeySelected;
	PGPBoolean		bSecret, bRevoked, bExpired, bCanSign;
	BOOL			bAtLeastOneSecretKey;
	CHAR			szNameFinal[MAXUSERIDSTRING];
	HDC				hdc;
	RECT			rc;
	INT				iComboWidth;
	HFONT			hFontOld;

	PGPOrderKeySet (options->mKeySet, kPGPKeyOrdering_Validity, FALSE, &KeyList);
	PGPNewKeyIter (KeyList, &KeyIter);

	SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, CB_GETDROPPEDCONTROLRECT,
						0, (LPARAM)&rc);
	iComboWidth = rc.right-rc.left - GetSystemMetrics (SM_CXVSCROLL);
	hdc = GetDC (GetDlgItem (hDlg, IDC_SIGNKEYCOMBO));
	hFontOld = (HFONT)SelectObject (hdc, (HFONT)GetStockObject (DEFAULT_GUI_FONT));

	iKeySelected = -1;
	iKeyDefault = 0;

	bAtLeastOneSecretKey = FALSE;

	PGPKeyIterNextKeyDBObj(KeyIter, kPGPKeyDBObjType_Key, &Key);
	while (Key) {
		PGPGetKeyDBObjBooleanProperty (Key, kPGPKeyProperty_IsSecret, &bSecret);
		if (bSecret) {
			PGPGetKeyDBObjBooleanProperty (Key, kPGPKeyProperty_IsRevoked, (unsigned char *)&bRevoked);
			PGPGetKeyDBObjBooleanProperty (Key, kPGPKeyProperty_IsExpired, (unsigned char *)&bExpired);
			PGPGetKeyDBObjBooleanProperty (Key, kPGPKeyProperty_CanSign, (unsigned char *)&bCanSign);
			if (!bRevoked && !bExpired && bCanSign) {
				bAtLeastOneSecretKey = TRUE;

				GetKeyString(hdc,iComboWidth,Key,szNameFinal);

				uIndex = SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, 
								CB_ADDSTRING, 0, (LPARAM)szNameFinal);
				if (uIndex != CB_ERR) {
					SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, 
								CB_SETITEMDATA, uIndex, (LPARAM)Key);
					if (options->mDefaultKey) {
						if (Key == options->mDefaultKey) 
							iKeySelected = uIndex;
					}
				}
			}
		}
		PGPKeyIterNextKeyDBObj(KeyIter, kPGPKeyDBObjType_Key, &Key);
	}
	PGPFreeKeyIter (KeyIter);
	PGPFreeKeyList (KeyList);

	if (iKeySelected == -1) iKeySelected = iKeyDefault;
	SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, CB_SETCURSEL, 
							iKeySelected, 0);

	SelectObject (hdc, hFontOld);
	ReleaseDC (GetDlgItem (hDlg, IDC_SIGNKEYCOMBO), hdc);

	return (bAtLeastOneSecretKey);

}

BOOL PassphraseLengthAndQualityOK(HWND hwnd,
								  CPGPPassphraseDialogOptions *options,
								  char *Passphrase)
{
	if(options->mMinPassphraseLength!=0)
	{
		if(strlen(Passphrase)<options->mMinPassphraseLength)
		{
			PGPsdkUIMessageBox (hwnd,
				IDS_PGPERROR,IDS_PASSNOTLONG,
				MB_OK|MB_ICONSTOP);

			return FALSE;
		}
	}

	if(options->mMinPassphraseQuality!=0)
	{
		if(PGPEstimatePassphraseQuality(Passphrase)<options->mMinPassphraseQuality)
		{
			PGPsdkUIMessageBox (hwnd,
				IDS_PGPERROR,IDS_PASSNOTQUALITY,
				MB_OK|MB_ICONSTOP);

			return FALSE;
		}
	}

	return TRUE;
}


//	______________________________________________________________
//
//  Enable or disable passphrase edit box on basis of selected key

VOID 
EnablePassPhraseControl (HWND hDlg, PGPContextRef context) 
{
	PGPKeyDBObjRef	Key;
	PGPBoolean	bNeedsPhrase,bShared,bIsSecret;
	INT			i;

	i = SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, CB_GETCURSEL, 0, 0);
	if (i != CB_ERR) 
	{					
		Key = (PGPKeyDBObjRef)SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, 
											CB_GETITEMDATA, i, 0);
		if (Key) 
		{
			PGPGetKeyDBObjBooleanProperty(Key, kPGPKeyProperty_IsSecret, &bIsSecret);
			PGPGetKeyDBObjBooleanProperty(Key, kPGPKeyProperty_NeedsPassphrase, &bNeedsPhrase);
			PGPGetKeyDBObjBooleanProperty(Key, kPGPKeyProperty_IsSecretShared, &bShared);

			if(!bIsSecret)
			{
				EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_HIDE);
				EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_SPLITINFO),SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_CACHEINFO),SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_NOPHRASEINFO),SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_NOSECRETINFO),SW_SHOW);
				SetFocus (GetDlgItem (hDlg, IDOK));
			} 
			else if (bNeedsPhrase) 
			{
				if (PGPPassphraseIsValid (Key, PGPOLastOption (context)))
				{
					EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), FALSE);
					ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_HIDE);
					EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), FALSE);
					ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_SPLITINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_CACHEINFO),SW_SHOW);
					ShowWindow (GetDlgItem (hDlg, IDC_NOPHRASEINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_NOSECRETINFO),SW_HIDE);
					SetFocus (GetDlgItem (hDlg, IDOK));
				}
				else if (bShared)
				{
					EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), FALSE);
					ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_HIDE);
					EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), FALSE);
					ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_SPLITINFO),SW_SHOW);
					ShowWindow (GetDlgItem (hDlg, IDC_CACHEINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_NOPHRASEINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_NOSECRETINFO),SW_HIDE);
					SetFocus (GetDlgItem (hDlg, IDOK));
				}
				else
				{
					SetDlgItemText (hDlg, IDC_PHRASE1, "");
					EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), TRUE);
					ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_SHOW);
					EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), TRUE);
					ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_SHOW);
					ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_SHOW);
					ShowWindow (GetDlgItem (hDlg, IDC_SPLITINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_CACHEINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_NOPHRASEINFO),SW_HIDE);
					ShowWindow (GetDlgItem (hDlg, IDC_NOSECRETINFO),SW_HIDE);
					SetFocus (GetDlgItem (hDlg, IDC_PHRASE1));
				}
			}
			else
			{
				EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_HIDE);
				EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_SPLITINFO),SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_CACHEINFO),SW_HIDE);
				ShowWindow (GetDlgItem (hDlg, IDC_NOPHRASEINFO),SW_SHOW);
				ShowWindow (GetDlgItem (hDlg, IDC_NOSECRETINFO),SW_HIDE);
				SetFocus (GetDlgItem (hDlg, IDOK));
			}
		}
	}
}

void ShiftDialog(HWND hdlg,int delta)
{
	RECT rc;

	GetWindowRect (hdlg, &rc);
	rc.left=rc.left+delta;

	SetWindowPos (hdlg, NULL,
		rc.left,rc.top,
		0, 0, SWP_NOSIZE | SWP_NOZORDER);
}

void DoBadPassphraseShake(HWND hdlg,GPP *gpp)
{
	if(gpp->NoAnimIndex==0)
	{
		ShiftDialog(hdlg,NoAnim[gpp->NoAnimIndex]);

		gpp->NoAnimIndex++;

		SetTimer (hdlg, NOANIMTIMER, NOANIMINTERVAL, NULL);
	}
}

//	____________________________
//
//  search keys for matching phrase

PGPError 
ValidateSigningPhrase (HWND hDlg, 
				GPP *gpp, 
				LPSTR pszPhrase, 
				PGPKeyDBObjRef key) 
{
	CHAR	szName[MAXUSERIDSTRING];
	CHAR	sz[128];
	CHAR	sz2[kPGPMaxUserIDSize + 128];
	PGPSize	u;
	CPGPSigningPassphraseDialogOptions *options;
	HWND hwndStatic;

	options=(CPGPSigningPassphraseDialogOptions *)gpp->options;

	// does phrase match selected key ?
	if (PGPPassphraseIsValid (key, 
			PGPOPassphrase (gpp->context, pszPhrase),
				options->mCache ?
					PGPOCachePassphrase(gpp->context,
						options->mCacheTimeout, options->mCacheGlobal ) :
					PGPONullOption( gpp->context ),
			PGPOLastOption (gpp->context))) {
		*(options->mPassphraseKeyPtr) = key;
		return kPGPError_NoErr;
	}

	if(options->mFindMatchingKey)
	{
		PGPBoolean	nonUTF8	= FALSE;

		// does phrase match any private key ?
		key=GetKeyForPassphrase(options->mKeySet,pszPhrase,
				GetDlgItem(hDlg,IDC_PHRASE1),&nonUTF8,TRUE);

		if (key!=NULL) 
		{
			WCHAR	wsz[128];
			WCHAR	wsz2[kPGPMaxUserIDSize + 128];

			// ask user to use other key
			LoadString (gPGPsdkUILibInst, IDS_FOUNDMATCHFORPHRASE, sz, sizeof(sz));
			PGPGetPrimaryUserIDName(key, szName, sizeof(szName), &u);
			if (pgpIsntUTF8String (szName, u))
			{
				CHAR		sz[kPGPMaxUserIDSize];
				PGPUInt32	u2;

				u2 = u;
				lstrcpyn (sz, szName, u2+1);
				pgpLocalStringToUTF8 (0, 
						GetACP(), sz, u2, szName, 
						sizeof(szName), &u);
			}
			wsprintf (sz2, sz, szName);
			pgpUTF8StringToUCS2 (sz2, kPGPUnicodeNullTerminated, 
					wsz2, sizeof(wsz2)/sizeof(WCHAR), NULL);

			LoadString (gPGPsdkUILibInst, IDS_PGP, sz, sizeof(sz));
			pgpUTF8StringToUCS2 (sz, kPGPUnicodeNullTerminated, 
					wsz, sizeof(wsz)/sizeof(WCHAR), NULL);

			// MessageBoxW exists on all supported platforms (even Win95)
			if (MessageBoxW (hDlg, wsz2, wsz, MB_ICONQUESTION|MB_YESNO) == IDYES) 
			{
				*(options->mPassphraseKeyPtr) = key;
                
				// if the non-UTF8 version of the phrase matched,
				// then warn user about it.
				if (nonUTF8)
				{
					PGPsdkUIMessageBox (hDlg, IDS_PGP, 
							IDS_PHRASENOTUTF8,
							MB_OK|MB_ICONINFORMATION);
				}

				return kPGPError_NoErr;
			}
			return kPGPError_BadPassphrase;
		}
	}

	// phrase doesn't match any key
//	PGPsdkUIMessageBox (hDlg,
//		IDS_PGPERROR,IDS_BADPASSREENTER,
//		MB_OK|MB_ICONSTOP);
	DoBadPassphraseShake(hDlg,gpp);

	hwndStatic=GetDlgItem(hDlg,IDC_PROMPTSTRING);

	LoadString (gPGPsdkUILibInst, IDS_WRONGPHRASE, sz, sizeof (sz));
	SetWindowText(hwndStatic,sz);

	IBSetHighlightMode(hwndStatic,FALSE);

	return kPGPError_BadPassphrase;

}

VOID
SpaceEditCallback(HWND hwndEdit,void *pUserValue)
{
	GPP *gpp;
	BOOL OKactive,bShowCapsWarning;
	DWORD PassLen,PassQual;
	HWND hdlg;
	HWND hwndPhrase1,hwndPhrase2;

	hdlg=GetParent(hwndEdit);
	hwndPhrase1=GetDlgItem(hdlg,IDC_PHRASE1);
	hwndPhrase2=GetDlgItem(hdlg,IDC_PHRASE2);

	gpp=(GPP *)pUserValue;

	OKactive=TRUE;

	PassLen=SEGetTextLength(hwndEdit);
	PassQual=SEGetTextQuality(hwndEdit);
	bShowCapsWarning=SEGetShowWarning(hwndEdit);

	if(bShowCapsWarning)
	{
		ShowWindow(GetDlgItem(hdlg,IDC_CAPSWARNING),SW_SHOW);
	}
	else
	{
		ShowWindow(GetDlgItem(hdlg,IDC_CAPSWARNING),SW_HIDE);
	}

	if(hwndPhrase1==hwndEdit)
	{
		/*
		if(gpp->options->mMinPassphraseLength!=0)
		{
			if(PassLen<gpp->options->mMinPassphraseLength)
			{
				OKactive=FALSE;
			}
		}
		*/

		// Check Quality for setting OK to TRUE
		if(gpp->options->mMinPassphraseQuality!=0)
		{
			if(PassQual<gpp->options->mMinPassphraseQuality)
			{
				OKactive=FALSE;
			}
		}
	
		if(gpp->hwndQuality)
		{
			// Set new quality
			SendMessage (gpp->hwndQuality, PBM_SETPOS, PassQual, 0);
		}

		// Enable/disable OK
		if(!gpp->bNoOK)
		{
			EnableWindow (GetDlgItem (hdlg, IDOK), OKactive);
		}
	}
}

#define DIALOGTIMEOUTTIMER 1972

BOOL CALLBACK 
DoCommonCalls (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	GPP *gpp;

	switch (uMsg)
	{
		case WM_INITDIALOG:
		{
			CPGPPassphraseDialogOptions *options;

			SetWindowLong (hDlg, GWL_USERDATA, lParam);
			gpp=(GPP *)lParam;

			options = (CPGPPassphraseDialogOptions *)gpp->options;

			if(options->mWindowTitle)
				SetWindowText(hDlg,options->mWindowTitle);

			if(options->mPrompt)
				SetDlgItemText (hDlg, IDC_PROMPTSTRING, options->mPrompt);

			gpp->bHideText = TRUE;
			CheckDlgButton (hDlg, IDC_HIDETYPING, BST_CHECKED);

			SetCapsLockMessageState(hDlg);

			gpp->hInfoIcon=LoadIcon(gPGPsdkUILibInst,MAKEINTRESOURCE(IDI_INFOICON));
			IBInit(GetDlgItem(hDlg,IDC_CAPSWARNING),gpp->hInfoIcon,FALSE);
			IBInit(GetDlgItem(hDlg,IDC_PROMPTSTRING),gpp->hInfoIcon,TRUE);

			if (options->mDialogTimeout!=0) 
			{
				SetTimer (hDlg, DIALOGTIMEOUTTIMER, 
					// minutes * 60 seconds/minute * 1000 u/second
					options->mDialogTimeout*60*1000, NULL);
			}

			SetForegroundWindow (hDlg);

			// Force focus to passphrase box
			SetFocus(GetDlgItem(hDlg, IDC_PHRASE1));
			break;
		}

		case WM_TIMER:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);

			switch(wParam)
			{
				case NOANIMTIMER:
				{
					if(gpp->NoAnimIndex!=NOANIMNUM)
					{
						ShiftDialog(hDlg,NoAnim[gpp->NoAnimIndex]);

						gpp->NoAnimIndex++;
					}
					else
					{
						KillTimer(hDlg,NOANIMTIMER);
						gpp->NoAnimIndex=0;
					}
					break;
				}

				case DIALOGTIMEOUTTIMER:
				{
					EndDialog (hDlg, kPGPError_UserAbort);
					break;
				}

				break;
			}
		}

		case WM_KEYUP:
		{
			SetCapsLockMessageState(hDlg);
			break;
		}

		case WM_HELP :
		{
			LPHELPINFO	phi = (LPHELPINFO)lParam;

			if (phi->iCtrlId != -1)
			{
				char szHelpFile[MAX_PATH+1];

				GetHelpDir(szHelpFile);
				strcat(szHelpFile, POPUPTEXTFILE);

				HtmlHelp ((HWND)phi->hItemHandle, szHelpFile, 
						HH_TP_HELP_WM_HELP, (DWORD)aIds);
			}
			return TRUE;
		}

		case WM_CONTEXTMENU :
		{
			if ((HWND)wParam != hDlg)
			{
				char szHelpFile[MAX_PATH+1];

				GetHelpDir(szHelpFile);
				strcat(szHelpFile, POPUPTEXTFILE);

				HtmlHelp ((HWND)wParam, szHelpFile, 
						HH_TP_HELP_CONTEXTMENU, (DWORD)aIds); 
			}
			return TRUE;
		}

		case WM_QUIT:
		case WM_CLOSE:
		case WM_DESTROY: 
		{
			HWND hwndPhrase1,hwndPhrase2;
			HWND hwndCaps,hwndPrompt;

			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);

			ClearPassphrases(hDlg,gpp);

			hwndPhrase1=GetDlgItem(hDlg, IDC_PHRASE1);
			hwndPhrase2=GetDlgItem(hDlg, IDC_PHRASE2);

			if(hwndPhrase1)
				SEDestroy(hwndPhrase1);

			if(hwndPhrase2)
				SEDestroy(hwndPhrase2);

			hwndCaps=GetDlgItem(hDlg, IDC_CAPSWARNING);
			hwndPrompt=GetDlgItem(hDlg, IDC_PROMPTSTRING);

			if(hwndCaps)
				IBDestroy(hwndCaps);

			if(hwndPrompt)