pgppassphrasedialog.cpp

可以实现对邮件的加密解密以及签名

							break;
						}

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

							err=ValidateSigningPhrase(hDlg,gpp,gpp->pszPassPhrase,key);

							if(IsntPGPError(err))
							{
								ClearPassphrases(hDlg,gpp);
								SaveOptionSettings(gpp->hwndOptionsControl);
								EndDialog (hDlg, kPGPError_NoErr);
								break;
							}
						}

						// Bad passphrase/quality
						ClearPassphrases(hDlg,gpp);
						FreePassphrases(gpp);
						break;
					}
					

					// Couldn't allocate passphrases
					ClearPassphrases(hDlg,gpp);
					FreePassphrases(gpp);
					EndDialog (hDlg, kPGPError_OutOfMemory);
					break;
				}

				case IDC_SIGNKEYCOMBO :
				{
					if(HIWORD(wParam)==CBN_SELCHANGE)
						EnablePassPhraseControl (hDlg, gpp->context);
					break;
				}
			}
		}
		break;
	}
	return FALSE;
}

// Signer combo box
	PGPError
pgpSigningPassphraseDialogPlatform(
	PGPContextRef						context,
	CPGPSigningPassphraseDialogOptions 	*options)
{
	// check for UI option if not set the assume Graphical
	// else use command line UI
	if (options->mTextUI) {
		return pgpSigningPassphraseCL(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_PASSPHRASEOPTIONS), 
							 options->mHwndParent,
							 (DLGPROC)pgpSigningPassphraseDlgProc,
							 (LPARAM)&gpp);
		
		*(options->mPassphrasePtr)=gpp.pszPassPhrase;
		
		UninstallSecurityHooks();
		UninitRandomKeyHook(hhookKeyboard, hhookMouse);
		return(err);
	}
}

//	___________________________________________________
//
//  check for non-ASCII chars

static BOOL
sStringContainsNonASCII (
		LPSTR	psz)
{
	while (*psz)
	{
		if (*psz & 0x80)
			return TRUE;
		psz++;
	}
	return FALSE;
}

//	________________________
//
//  Dialog Message procedure

BOOL CALLBACK 
pgpConfirmationDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	CPGPConfirmationPassphraseDialogOptions *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 = (CPGPConfirmationPassphraseDialogOptions *)
				gpp->options;

			gpp->iNextTabControl = IDC_PHRASE2;
			gpp->hwndQuality = GetDlgItem (hDlg, IDC_PHRASEQUALITY);
			gpp->hwndMinQuality = GetDlgItem (hDlg, IDC_MINQUALITY);

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

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

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

			// If we aren't showing quality, don't show either bar
			if(!options->mShowPassphraseQuality)
			{
				EnableWindow (GetDlgItem (hDlg, IDC_STATICPASSQUAL), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_STATICPASSQUAL), SW_HIDE);
				EnableWindow (GetDlgItem (hDlg, IDC_STATICMINQUAL), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_STATICMINQUAL), SW_HIDE);

				EnableWindow (GetDlgItem (hDlg, IDC_MINQUALITY), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_MINQUALITY), SW_HIDE);
				EnableWindow (GetDlgItem (hDlg, IDC_PHRASEQUALITY), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_PHRASEQUALITY), SW_HIDE);
			}

			// If we don't give a min quality, don't show bar
			if(options->mMinPassphraseQuality==0)
			{
				EnableWindow (GetDlgItem (hDlg, IDC_STATICMINQUAL), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_STATICMINQUAL), SW_HIDE);

				EnableWindow (GetDlgItem (hDlg, IDC_MINQUALITY), FALSE);
				ShowWindow (GetDlgItem (hDlg, IDC_MINQUALITY), SW_HIDE);
			}

			// Set our min quality benchmark
			SendMessage (gpp->hwndMinQuality, PBM_SETPOS, 
				options->mMinPassphraseQuality, 0);

			// Disable OK till we get a good passphrase if mins are active
			if(options->mMinPassphraseQuality!=0)
//			  (options->mMinPassphraseLength!=0))
				EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);

			return FALSE;
		}

		case WM_COMMAND:
		{
			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPConfirmationPassphraseDialogOptions *)
				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);

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

						gpp->pszPassPhraseConf = (char *)secAlloc (gpp->context, i);
						if (gpp->pszPassPhraseConf) 
						{
							SEGetText(GetDlgItem(hDlg,IDC_PHRASE2),gpp->pszPassPhraseConf,i);

							if(PassphraseLengthAndQualityOK(hDlg,options,gpp->pszPassPhrase))
							{
								if (!lstrcmp (gpp->pszPassPhrase, gpp->pszPassPhraseConf))
								{
									if (sStringContainsNonASCII (gpp->pszPassPhrase))
									{
										if (PGPsdkUIMessageBox (hDlg, 
												IDS_PGPWARNING, IDS_NEWNONASCIIPHRASE, 
												MB_OKCANCEL|MB_ICONEXCLAMATION) != IDOK)
										{
											break;
										}
									}

									ClearPassphrases(hDlg,gpp);
									if(gpp->pszPassPhraseConf)
									{
										secFree(gpp->pszPassPhraseConf);
										gpp->pszPassPhraseConf=NULL;
									}
									SaveOptionSettings(gpp->hwndOptionsControl);
									EndDialog (hDlg, kPGPError_NoErr);
									break;
								}
								else
								{
									char sz[100];
									HWND hwndStatic;

									DoBadPassphraseShake(hDlg,gpp);

									hwndStatic=GetDlgItem(hDlg,IDC_PROMPTSTRING);

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

									IBSetHighlightMode(hwndStatic,FALSE);
								}
							}
							// Badpassphrase/quality
							ClearPassphrases(hDlg,gpp);
							FreePassphrases(gpp);
							SendMessage (gpp->hwndQuality, PBM_SETPOS, 0, 0);
							if(options->mMinPassphraseQuality!=0)
								EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
							break;
						}
					}
					
					// Couldn't allocate passphrases
					ClearPassphrases(hDlg,gpp);
					FreePassphrases(gpp);
					EndDialog (hDlg, kPGPError_OutOfMemory);
					break;
				}
			}
			break;
		}
	}
	return FALSE;
}

// Double edit window
	PGPError
pgpConfirmationPassphraseDialogPlatform(
	PGPContextRef								context,
	CPGPConfirmationPassphraseDialogOptions 	*options)
{
	PGPError err;
	GPP	gpp;

	if (options->mTextUI) {
		return pgpConfirmationPassphraseDialogCL(context, options);
	}
	else {
		memset(&gpp,0x00,sizeof(GPP));
		gpp.context=context;
		gpp.options=options;

		InitRandomKeyHook(&hhookKeyboard, &hhookMouse);
		InstallSecurityHooks();
		
		err = DialogBoxParam (gPGPsdkUILibInst, 
			MAKEINTRESOURCE (IDD_PASSPHRASEENCRYPT),
			options->mHwndParent,
			(DLGPROC)pgpConfirmationDlgProc, (LPARAM)&gpp);

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

		UninstallSecurityHooks();
		UninitRandomKeyHook(hhookKeyboard, hhookMouse);

		return(err);
	}
}


//	_________________________________________________________
//
//  create a non-UTF-8 version of the phrase and see if it works

static PGPBoolean
sCheckNonUTF8VersionOfPhrase (
		GPP*	gpp,
		HWND	hwnd)
{
	PGPSize		size				= 0;
	PGPUInt32	uLen				= 0;
	char*		passphraseNonUTF8	= NULL;
	PGPBoolean	bValid				= FALSE;

	CPGPKeyPassphraseDialogOptions *options;
	options = (CPGPKeyPassphraseDialogOptions *)(gpp->options);

	// make a non-UTF8 copy of the passphrase
	size = strlen( gpp->pszPassPhrase );
	passphraseNonUTF8 = (char*) PGPNewSecureData(
			PGPPeekContextMemoryMgr( gpp->context ), size +1, 0 );

	if (passphraseNonUTF8)
	{
		pgpUTF8StringToLocal( kPGPUnicodeFlag_Secure,
				pgpGetCodePageFromWindow (hwnd),
				gpp->pszPassPhrase, size, 
				passphraseNonUTF8, size, &uLen );
		passphraseNonUTF8[uLen] = '\0';

		bValid=PGPPassphraseIsValid (options->mDefaultKey, 
			PGPOPassphrase (gpp->context, passphraseNonUTF8),
				options->mCache ?
					PGPOCachePassphrase(gpp->context,
						options->mCacheTimeout, 
						options->mCacheGlobal ) :
					PGPONullOption( gpp->context ),
			PGPOLastOption (gpp->context));

		if (bValid)
			strcpy (gpp->pszPassPhrase, passphraseNonUTF8);

		PGPFreeData (passphraseNonUTF8);
	}

	return bValid;
}


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

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

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

	if(Common)
		return Common;

	switch (uMsg) 
	{
		case WM_INITDIALOG:
		{
			RECT rc;
			int iTextWidth;
			HDC hdc;
			char szNameFinal[MAXUSERIDSTRING];

			gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
			options = (CPGPKeyPassphraseDialogOptions *)
				gpp->options;

			gpp->iNextTabControl = IDOK;

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

			UTF8EditInit(GetDlgItem(hDlg,IDC_KEYNAME));
			GetClientRect(GetDlgItem(hDlg,IDC_KEYNAME), &rc);

			iTextWidth = rc.right-rc.left;
			hdc = GetDC (GetDlgItem(hDlg,IDC_KEYNAME));
			GetKeyString(hdc,iTextWidth,options->mDefaultKey,szNameFinal);
			UTF8EditSetText(GetDlgItem(hDlg,IDC_KEYNAME),szNameFinal);
			ReleaseDC (GetDlgItem (hDlg, IDC_KEYNAME), hdc);

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

			return FALSE;
		}

		case WM_DESTROY:
			UTF8EditDestroy(GetDlgItem(hDlg,IDC_KEYNAME));
			break;

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

			switch (LOWORD (wParam)) 
			{
				case IDOK:
				{
					PGPBoolean PassValid = FALSE;

					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))
						{
							if(!options->mVerifyPassphrase)
							{
								ClearPassphrases(hDlg,gpp);
								SaveOptionSettings(gpp->hwndOptionsControl);
								EndDialog (hDlg, kPGPError_NoErr);
								break;
							}

							// Since we previously checked whether this key actually
							// needs a passphrase with the kPGPKeyPropNeedsPassphrase
							// property, we can now reject empty strings out-of-hand.
							// This prevents the problem of permitting an empty
							// string as a valid phrase when the passphrase is cached.
							if (i > 1)
							{
								PassValid=PGPPassphraseIsValid (options->mDefaultKey, 
									PGPOPassphrase (gpp->context, gpp->pszPassPhrase),
										options->mCache ?
											PGPOCachePassphrase(gpp->context,
												options->mCacheTimeout, 
												options->mCacheGlobal ) :
											PGPONullOption( gpp->context ),
									PGPOLastOption (gpp->context));

								// now we must check for non-UTF-8 encoding
								if (!PassValid)
								{
									PassValid = sCheckNonUTF8VersionOfPhrase (gpp,
											GetDlgItem(hDlg,IDC_PHRASE1));

									if (PassValid)
									{
										PGPsdkUIMessageBox (hDlg, IDS_PGP, 
												IDS_PHRASENOTUTF8,
												MB_OK|MB_ICONINFORMATION);
									}
								}
							}

							if(PassValid)
							{
								ClearPassphrases(hDlg,gpp);
								SaveOptionSettings(gpp->hwndOptionsControl);
								EndDialog (hDlg, kPGPError_NoErr);
								break;
							}
							else
							{
//								PGPsdkUIMessageBox (hDlg,
//									IDS_PGPERROR,IDS_BADPASSREENTER,
//									MB_OK|MB_ICONSTOP);
								char sz[100];
								HWND hwndStatic;

								DoBadPassphraseShake(hDlg,gpp);

								hwndStatic=GetDlgItem(hDlg,IDC_PROMPTSTRING);

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

								IBSetHighlightMode(hwndStatic,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;
}


	PGPError
pgpKeyPassphraseDialogPlatform(
	PGPContextRef					context,
	CPGPKeyPassphraseDialogOptions 	*options)
{
	PGPError err;
	PGPBoolean bShared,bNeedsPhrase;
	
	err=PGPGetKeyDBObjBooleanProperty( options->mDefaultKey,
						  kPGPKeyProperty_IsSecretShared,
						  &bShared);
	
	if(IsntPGPError(err) && bShared)
	{
		// So, they want to do a shared key....
		return(kPGPError_KeyUnusableForSignature);
	}
		
	err=PGPGetKeyDBObjBooleanProperty (options->mDefaultKey,
						  kPGPKeyProperty_NeedsPassphrase,
						  &bNeedsPhrase);
	
	if(IsntPGPError(err) && !bNeedsPhrase)
	{
		*(options->mPassphrasePtr)=(char *)secAlloc (context, 1);
		if(*(options->mPassphrasePtr)==0)
			return(kPGPError_OutOfMemory);
		
		// Doesn't need a passphrase
		strcpy(*(options->mPassphrasePtr),"");
		return(kPGPError_NoErr);
	}
		
	if (options->mTextUI) {
		return pgpKeyPassphraseCL(context, options);
	} else {
		GPP	gpp;
		
		memset(&gpp,0x00,sizeof(GPP));
		gpp.context=context;
		gpp.options=options;
		
		InitRandomKeyHook(&hhookKeyboard, &hhookMouse);
		InstallSecurityHooks();
		
		err = DialogBoxParam (gPGPsdkUILibInst, 
							  MAKEINTRESOURCE (IDD_KEYPASSPHRASE), 
							  options->mHwndParent,
							  (DLGPROC)pgpKeyPassphraseDlgProc, (LPARAM)&gpp);
		
		*(options->mPassphrasePtr)=gpp.pszPassPhrase;
		
		UninstallSecurityHooks();
		UninitRandomKeyHook(hhookKeyboard, hhookMouse);
		
		return(err);
	}
}