📄 pgppassphrasedialog.cpp

📁 可以实现对邮件的加密解密以及签名
💻 CPP
📖 第 1 页 / 共 4 页
字号:
				IBDestroy(hwndPrompt);

			DeleteObject(gpp->hInfoIcon);

			EndDialog(hDlg,kPGPError_UserAbort);
			break;
		}

		case WM_CTLCOLOREDIT:
		{
			HWND hwndPhrase1,hwndPhrase2;

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

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

			if(lParam==0)
				break;

			if (((HWND)lParam == hwndPhrase1) ||
				((HWND)lParam == hwndPhrase2)) 
			{
				SetBkColor ((HDC)wParam, GetSysColor (COLOR_WINDOW));

				SetTextColor ((HDC)wParam, 
							  GetSysColor (COLOR_WINDOWTEXT));
				return (BOOL)CreateSolidBrush (GetSysColor (COLOR_WINDOW));
			}
			break;
		}

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

			switch(LOWORD (wParam)) 
			{
				case IDCANCEL:
					EndDialog (hDlg, kPGPError_UserAbort);
					break;

				case IDC_HIDETYPING :
				{
					HWND hwndPhrase1,hwndPhrase2;
	
					hwndPhrase1=GetDlgItem(hDlg, IDC_PHRASE1);
					hwndPhrase2=GetDlgItem(hDlg, IDC_PHRASE2);

					if (IsDlgButtonChecked (hDlg, IDC_HIDETYPING)
							== BST_CHECKED) 
						gpp->bHideText = TRUE;
					else 
						gpp->bHideText = FALSE;

					if(hwndPhrase1)
						SEChangeHideTyping (hwndPhrase1, gpp->bHideText);

					if(hwndPhrase2)
						SEChangeHideTyping (hwndPhrase2, gpp->bHideText);
					break;
				}
			}
			break;	
		}
	}

	return FALSE;
}

HWND DisplayOptions(HWND hDlg,PGPOptionListRef options,int y)
{
	if(options==NULL)
	{
		return NULL;
	}
	else
	{
		RECT rc;

		GetWindowRect(hDlg,&rc);

		SetWindowPos (hDlg, 
			NULL, 0, 0,
			rc.right-rc.left,rc.bottom-rc.top+60, //45,
				SWP_NOMOVE|SWP_NOZORDER);

		return CreateOptionsControl(hDlg,
			options,
			10,y,
			200,86);//71);
	}
}

// ****************************************************************************
// ****************************************************************************

//	________________________
//
//  Dialog Message procedure

BOOL CALLBACK 
pgpPassphraseDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	CPGPPassphraseDialogOptions *options;
	GPP				*gpp;
	INT				i;
	BOOL			Common;

	Common=DoCommonCalls (hDlg,uMsg,wParam,lParam); 

	if(Common)
		return Common;

	switch (uMsg) 
	{
		case WM_INITDIALOG:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPPassphraseDialogOptions *)
				gpp->options;
	
			gpp->iNextTabControl = IDOK;

			SEInit(gpp->context,GetDlgItem(hDlg, IDC_PHRASE1),TRUE,
				SpaceEditCallback,(void *)gpp);

			gpp->hwndOptionsControl=DisplayOptions(hDlg,options->mDialogOptions,107);
			return FALSE;
		}

		case WM_COMMAND:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPPassphraseDialogOptions *)
				gpp->options;
	
			switch(LOWORD (wParam)) 
			{
				case IDOK: 
				{
					FreePassphrases(gpp);

					i=SEGetTextLength(GetDlgItem(hDlg,IDC_PHRASE1))+1;

					gpp->pszPassPhrase = (char *)secAlloc (gpp->context, i);

					if (gpp->pszPassPhrase) 
					{
						SEGetText(GetDlgItem(hDlg,IDC_PHRASE1),gpp->pszPassPhrase,i);

						if(PassphraseLengthAndQualityOK(hDlg,options,gpp->pszPassPhrase))
						{
							ClearPassphrases(hDlg,gpp);
							SaveOptionSettings(gpp->hwndOptionsControl);
							EndDialog (hDlg, kPGPError_NoErr);
							break;
						}
						// Passphrase quality not enough
						ClearPassphrases(hDlg,gpp);
						FreePassphrases(gpp);
						break;
					}
						
					// Couldn't allocate passphrases
					ClearPassphrases(hDlg,gpp);
					FreePassphrases(gpp);
					EndDialog (hDlg, kPGPError_OutOfMemory);
					break;
				}
			}
			break;
		}
	}
	return FALSE;
}

// Just a simple decryption
	PGPError
pgpPassphraseDialogPlatform(
	PGPContextRef					context,
	CPGPPassphraseDialogOptions 	*options)
{
	if (options->mTextUI) {
		return pgpPassphraseCL(context, options);
	} else {
		PGPError err;
		GPP	gpp;
		memset(&gpp,0x00,sizeof(GPP));
		gpp.context=context;
		gpp.options=options;
		
		InitRandomKeyHook(&hhookKeyboard, &hhookMouse);
		InstallSecurityHooks();
		
		err = DialogBoxParam (gPGPsdkUILibInst, 
							  MAKEINTRESOURCE (IDD_PASSPHRASE), 
							  options->mHwndParent,
							  (DLGPROC)pgpPassphraseDlgProc, (LPARAM)&gpp);
		
		*(options->mPassphrasePtr)=gpp.pszPassPhrase;
		
		UninstallSecurityHooks();
		UninitRandomKeyHook(hhookKeyboard, hhookMouse);
		
		return(err);
	}
}

	static VOID
sDrawListItem (
		LPDRAWITEMSTRUCT	pdis)
{
	CHAR	sz[MAXUSERIDSTRING];
	WCHAR	wsz[MAXUSERIDSTRING];
	UINT	ulen;
	HFONT	hfont, hFontOld;

	SendMessage (pdis->hwndItem, LB_GETTEXT, pdis->itemID, (LPARAM)sz);

	pgpUTF8StringToUCS2 (sz, kPGPUnicodeNullTerminated, 
			wsz, MAXUSERIDSTRING, &ulen);

	hfont = (HFONT)GetStockObject (DEFAULT_GUI_FONT);
	hFontOld = (HFONT)SelectObject (pdis->hDC, hfont);

	TextOutW (pdis->hDC, pdis->rcItem.left, 
			pdis->rcItem.top, wsz, ulen);

	SelectObject (pdis->hDC, hFontOld);
}

//	________________________
//
//  Dialog Message procedure

static PGPBoolean Working=FALSE;

BOOL CALLBACK 
pgpDecryptionPassphraseDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	CPGPDecryptionPassphraseDialogOptions *options;
	GPP				*gpp;
	INT				i;
	DWORD			Common;

	Common=DoCommonCalls (hDlg,uMsg,wParam,lParam); 

	if(Common)
		return Common;

	switch (uMsg) 
	{
		case WM_INITDIALOG:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPDecryptionPassphraseDialogOptions *)
				gpp->options;

			gpp->iNextTabControl = IDOK;

			gpp->bNoOK=!InitEncryptedToKeyListBox (hDlg, options);

			SEInit(gpp->context,GetDlgItem(hDlg, IDC_PHRASE1),TRUE,
				SpaceEditCallback,gpp);

			gpp->hwndOptionsControl=DisplayOptions(hDlg,options->mDialogOptions,200);

			return FALSE;
		}

		case WM_DRAWITEM:
		{
			if (wParam == IDC_KEYLISTBOX)
			{
				sDrawListItem ((LPDRAWITEMSTRUCT)lParam);
			}
			return TRUE;
		}

		case WM_COMMAND:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPDecryptionPassphraseDialogOptions *)
				gpp->options;

			switch(LOWORD (wParam)) 
			{

				case IDC_KEYLISTBOX:
				{
					if(HIWORD(wParam)==LBN_DBLCLK)
					{
						if(!Working)
						{
							Working=TRUE;

							if(IsntNull(options->mMissingKeyIDList))
							{
								PGPError	err;
								PGPBoolean	haveNewKeys;

								err=options->SearchForMissingKeys( hDlg, &haveNewKeys );

								PGPsdkUIErrorBox (hDlg,err);
								
								if( haveNewKeys )
								{
									gpp->bNoOK=!InitEncryptedToKeyListBox (hDlg, options);
								}
							}
					
							Working=FALSE;
						}
					}
					break;
				}

				case IDOK: 
				{
					FreePassphrases(gpp);

					i=SEGetTextLength(GetDlgItem(hDlg,IDC_PHRASE1))+1;

					gpp->pszPassPhrase = (char *)secAlloc (gpp->context, i);

					if (gpp->pszPassPhrase) 
					{
						CHAR		sz[256];
						PGPBoolean	nonUTF8;

						SEGetText(GetDlgItem(hDlg,IDC_PHRASE1),gpp->pszPassPhrase,i);

						if(PassphraseLengthAndQualityOK(hDlg,options,gpp->pszPassPhrase))
						{
							if (!options->mFindMatchingKey)
							{
								ClearPassphrases(hDlg,gpp);
								SaveOptionSettings(gpp->hwndOptionsControl);
								EndDialog (hDlg, kPGPError_NoErr);
								break;
							}

							*(options->mPassphraseKeyPtr)=
								GetKeyForPassphrase(options->mKeySet,
									gpp->pszPassPhrase,
									GetDlgItem(hDlg,IDC_PHRASE1),&nonUTF8,
									FALSE);
	
							if (*(options->mPassphraseKeyPtr)!=NULL)
							{        
								// if the non-UTF8 version of the phrase matched,
								// then warn the use about it.
								if (nonUTF8)
								{
									PGPsdkUIMessageBox (hDlg, IDS_PGP, 
											IDS_PHRASENOTUTF8,
											MB_OK|MB_ICONINFORMATION);
								}

								ClearPassphrases(hDlg,gpp);
								SaveOptionSettings(gpp->hwndOptionsControl);
								EndDialog (hDlg, kPGPError_NoErr);
								break;
							}
							else
							{
//								PGPsdkUIMessageBox (hDlg, IDS_PGPERROR, 
//									IDS_BADDECRYPTPHRASE, MB_OK|MB_ICONEXCLAMATION);
								DoBadPassphraseShake(hDlg,gpp);

								LoadString (gPGPsdkUILibInst, IDS_WRONGDECRYPTPHRASE, 
									sz, sizeof (sz));
								SetDlgItemText (hDlg, IDC_PROMPTSTRING, sz);
								IBSetHighlightMode(GetDlgItem(hDlg,IDC_PROMPTSTRING),
									FALSE);
							}
						}
						// Bad passphrase/quality
						ClearPassphrases(hDlg,gpp);
						FreePassphrases(gpp);
						break;
					}
			
					// Couldn't allocate passphrases
					ClearPassphrases(hDlg,gpp);
					FreePassphrases(gpp);
					EndDialog (hDlg, kPGPError_OutOfMemory);
					break;
				}
			}
			break;
		}
	}
	return FALSE;
}

// Show the recipients
	PGPError
pgpDecryptionPassphraseDialogPlatform(
	PGPContextRef							context,
	CPGPDecryptionPassphraseDialogOptions	*options)
{
	PGPError err;
	GPP	gpp;

	memset(&gpp,0x00,sizeof(GPP));
	gpp.context=context;
	gpp.options=options;

	InitRandomKeyHook(&hhookKeyboard, &hhookMouse);
	InstallSecurityHooks();

	err = DialogBoxParam (gPGPsdkUILibInst, 
		MAKEINTRESOURCE (IDD_PASSPHRASEDECRYPTKEYS), 
		options->mHwndParent,
		(DLGPROC)pgpDecryptionPassphraseDlgProc, (LPARAM)&gpp);

	*(options->mPassphrasePtr)=gpp.pszPassPhrase;

	UninstallSecurityHooks();
	UninitRandomKeyHook(hhookKeyboard, hhookMouse);

	return(err);
}


	static VOID
sDrawComboItem (
		LPDRAWITEMSTRUCT	pdis)
{
	CHAR	sz[MAXUSERIDSTRING];
	WCHAR	wsz[MAXUSERIDSTRING];
	UINT	ulen;
	HFONT	hfont, hFontOld;

	SendMessage (pdis->hwndItem, CB_GETLBTEXT, pdis->itemID, (LPARAM)sz);

	pgpUTF8StringToUCS2 (sz, kPGPUnicodeNullTerminated, 
			wsz, MAXUSERIDSTRING, &ulen);

	hfont = (HFONT)GetStockObject (DEFAULT_GUI_FONT);
	hFontOld = (HFONT)SelectObject (pdis->hDC, hfont);

	if (pdis->itemState & ODS_SELECTED)
	{
		HBRUSH hbrush = CreateSolidBrush (GetSysColor (COLOR_HIGHLIGHT));
		FillRect (pdis->hDC, &pdis->rcItem, hbrush);
		DeleteObject (hbrush);
		SetTextColor (pdis->hDC, GetSysColor (COLOR_HIGHLIGHTTEXT));
		SetBkColor (pdis->hDC, GetSysColor (COLOR_HIGHLIGHT));
	}
	else
	{
		HBRUSH hbrush = CreateSolidBrush (GetSysColor (COLOR_WINDOW));
		FillRect (pdis->hDC, &pdis->rcItem, hbrush);
		DeleteObject (hbrush);
		SetTextColor (pdis->hDC, GetSysColor (COLOR_WINDOWTEXT));
		SetBkColor (pdis->hDC, GetSysColor (COLOR_WINDOW));
	}

	TextOutW (pdis->hDC, pdis->rcItem.left+2, 
			pdis->rcItem.top+2, wsz, ulen);

	SelectObject (pdis->hDC, hFontOld);
}

//	_________________________________________________________
//
//  Dialog Message procedure - get passphrase and signing key

BOOL CALLBACK 
pgpSigningPassphraseDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	CPGPSigningPassphraseDialogOptions *options;
	GPP				*gpp;
	INT				i;
	DWORD			Common;

	Common=DoCommonCalls (hDlg,uMsg,wParam,lParam); 

	if(Common)
		return Common;

	switch (uMsg) 
	{
		case WM_INITDIALOG:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPSigningPassphraseDialogOptions *)
				gpp->options;

			gpp->iNextTabControl = IDOK;

			SEInit(gpp->context,GetDlgItem(hDlg, IDC_PHRASE1),TRUE,
				SpaceEditCallback,gpp);

			if (InitSigningKeyComboBox (hDlg, options)) 
			{
				EnablePassPhraseControl (hDlg, gpp->context);
			}
			else 
			{
				EndDialog (hDlg, kPGPError_UserAbort);//kPGPError_Win32_NoSecretKeys);
			}

			gpp->hwndOptionsControl=DisplayOptions(hDlg,options->mDialogOptions,130);

			return FALSE;
		}

		case WM_DRAWITEM:
		{
			if (wParam == IDC_SIGNKEYCOMBO)
				sDrawComboItem ((LPDRAWITEMSTRUCT)lParam);
			return TRUE;
		}

		case WM_COMMAND:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPSigningPassphraseDialogOptions *)
				gpp->options;

			switch (LOWORD (wParam)) 
			{
				case IDOK:
				{
					int ComboSelection;

					FreePassphrases(gpp);

					ComboSelection = SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, 
						CB_GETCURSEL, 0, 0);

					if (ComboSelection == CB_ERR) 
					{
						PGPsdkUIMessageBox (hDlg, 
							IDS_PGPERROR, IDS_NOSIGNKEY, 
							MB_OK | MB_ICONEXCLAMATION);
						break;
					}

					i=SEGetTextLength(GetDlgItem(hDlg,IDC_PHRASE1))+1;

					gpp->pszPassPhrase = (char *)secAlloc (gpp->context, i);

					if (gpp->pszPassPhrase) 
					{
						PGPKeyDBObjRef	key;
						PGPError	err;
						PGPBoolean	bShared;

						SEGetText(GetDlgItem(hDlg,IDC_PHRASE1),gpp->pszPassPhrase,i);
							
						key = (PGPKeyDBObjRef)SendDlgItemMessage (hDlg, 
							IDC_SIGNKEYCOMBO, CB_GETITEMDATA, ComboSelection, 0);

						err=PGPGetKeyDBObjBooleanProperty( key, kPGPKeyProperty_IsSecretShared, &bShared);
	
						if(IsntPGPError(err) && bShared)
						{
							// So, they want to do a shared key....
							ClearPassphrases(hDlg,gpp);
							FreePassphrases(gpp);
							*(options->mPassphraseKeyPtr) = key;
							EndDialog (hDlg, kPGPError_KeyUnusableForSignature);
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -