pgppassphrasedialog.cpp

pgp soucecode pgp soucecode

	l = lstrlen (pszOrig);
	if (l < 3) {
		if (iW > iXmax) lstrcpy (pszTrunc, "");
	}
	else {
		l = lstrlen (pszOrig) - 3;
		while ((iW > iXmax) && (l >= 0)) {
			lstrcpy (&pszTrunc[l], "...");
			GetTextExtentPoint32 (hdc, pszTrunc, lstrlen (pszTrunc), &s);
			iW = s.cx + 4;
			l--;
		}	
		if (l < 0) lstrcpy (pszTrunc, "");
	}

	lstrcat (pszTrunc, szInfo);
	
}

void GetKeyString(HDC hdc,INT iComboWidth,PGPKeyRef Key,char *szNameFinal)
{
	CHAR			sz1[32],sz2[32];
	CHAR			szName[kPGPMaxUserIDSize];
	PGPUInt32		uAlgorithm,uKeyBits;
	UINT			u;

	PGPGetKeyNumber (Key, kPGPKeyPropAlgID, (int *)&uAlgorithm);

	// get key type / size info to append to name
	lstrcpy (sz2, "   (");
	switch (uAlgorithm) 
	{
		case kPGPPublicKeyAlgorithm_RSA :
			LoadString (gPGPsdkUILibInst, IDS_RSA, sz1, sizeof(sz1));
			lstrcat (sz2, sz1);
			lstrcat (sz2, "/");
			PGPGetKeyNumber (Key, kPGPKeyPropBits, (int *)&uKeyBits);
			wsprintf (sz1, "%i", uKeyBits);
			lstrcat (sz2, sz1);
			break;

		case kPGPPublicKeyAlgorithm_DSA :
			LoadString (gPGPsdkUILibInst, IDS_DSS, sz1, sizeof(sz1));
			lstrcat (sz2, sz1);
			lstrcat (sz2, "/");
			PGPGetKeyNumber (Key, kPGPKeyPropBits, (int *)&uKeyBits);
			wsprintf (sz1, "%i", uKeyBits);
			lstrcat (sz2, sz1);
			break;

		default :
			LoadString (gPGPsdkUILibInst, IDS_UNKNOWN, sz1, sizeof(sz1));
			lstrcat (sz2, sz1);
			lstrcat (sz2, "/");
			lstrcat (sz2, sz1);
			break;
	}
		
	lstrcat (sz2, ")");

	// get name on key
	PGPGetPrimaryUserIDNameBuffer (Key, sizeof(szName),szName, &u);
	TruncateKeyText (hdc, szName, sz2, iComboWidth, szNameFinal);
}


//	____________________________
//
//  setup keyselection combo box

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

	PGPOrderKeySet (options->mKeySet, kPGPValidityOrdering, &KeyList);
	PGPNewKeyIter (KeyList, &KeyIter);
	PGPGetDefaultPrivateKey (options->mKeySet, &KeyDefault);

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

	iKeySelected = -1;
	iKeyDefault = 0;

	bAtLeastOneSecretKey = FALSE;

	PGPKeyIterNext (KeyIter, &Key);
	while (Key) {
		PGPGetKeyBoolean (Key, kPGPKeyPropIsSecret, &bSecret);
		if (bSecret) {
			PGPGetKeyBoolean (Key, kPGPKeyPropIsRevoked, (unsigned char *)&bRevoked);
			PGPGetKeyBoolean (Key, kPGPKeyPropIsExpired, (unsigned char *)&bExpired);
			PGPGetKeyBoolean (Key, kPGPKeyPropCanSign, (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;
					}
					if (Key == KeyDefault) iKeyDefault = uIndex;
				}
			}
		}
		PGPKeyIterNext (KeyIter, &Key);
	}
	PGPFreeKeyIter (KeyIter);
	PGPFreeKeyList (KeyList);

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

	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) 
{
	PGPKeyRef	Key;
	PGPBoolean	bNeedsPhrase,bShared;
	BOOL		bEnabled;
	INT			i;

	bEnabled = FALSE;

	i = SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, CB_GETCURSEL, 0, 0);
	if (i != CB_ERR) 
	{					
		Key = (PGPKeyRef)SendDlgItemMessage (hDlg, IDC_SIGNKEYCOMBO, 
											CB_GETITEMDATA, i, 0);
		if (Key) 
		{
			PGPGetKeyBoolean(Key, kPGPKeyPropNeedsPassphrase, &bNeedsPhrase);
			PGPGetKeyBoolean(Key, kPGPKeyPropIsSecretShared, &bShared);

			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);
			}
			else
			{
				if (bNeedsPhrase) bEnabled = TRUE;

				if (!bEnabled) 
					SetDlgItemText (hDlg, IDC_PHRASE1, "");

				EnableWindow (GetDlgItem (hDlg, IDC_PHRASE1), bEnabled);
				ShowWindow (GetDlgItem (hDlg, IDC_PHRASE1), SW_SHOW);
				EnableWindow (GetDlgItem (hDlg, IDC_HIDETYPING), bEnabled);
				ShowWindow (GetDlgItem (hDlg, IDC_HIDETYPING), SW_SHOW);
				ShowWindow (GetDlgItem (hDlg, IDC_PROMPTSTRING), SW_SHOW);
				ShowWindow (GetDlgItem (hDlg, IDC_SPLITINFO),SW_HIDE);
			}
		}
	}
}

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

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

	options=(CPGPSigningPassphraseDialogOptions *)gpp->options;

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

	if(options->mFindMatchingKey)
	{
		// does phrase match any private key ?
		key=GetKeyForPassphrase(options->mKeySet,pszPhrase,TRUE);

		if (key!=NULL) 
		{
			// ask user to use other key
			LoadString (gPGPsdkUILibInst, IDS_FOUNDMATCHFORPHRASE, sz, sizeof(sz));
			PGPGetPrimaryUserIDNameBuffer (key, sizeof(szName), szName, &size);
			wsprintf (sz2, sz, szName);
			LoadString (gPGPsdkUILibInst, IDS_PGP, sz, sizeof(sz));
			if (MessageBox (hDlg, sz2, sz, MB_ICONQUESTION|MB_YESNO) == IDYES) 
			{
				*(options->mPassphraseKeyPtr) = key;
				return kPGPError_NoErr;
			}
			return kPGPError_BadPassphrase;
		}
	}

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

	LoadString (gPGPsdkUILibInst, IDS_WRONGPHRASE, sz, sizeof (sz));
	SetDlgItemText (hDlg, IDC_PROMPTSTRING, sz);
	
	return kPGPError_BadPassphrase;

}

CommonPhraseMsgProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
    switch (uMsg) 
	{
		case WM_CONTEXTMENU:
		{
			char szHelpFile[MAX_PATH+1];

			GetHelpDir(szHelpFile);

			WinHelp ((HWND) wParam, szHelpFile, HELP_CONTEXTMENU, 
				(DWORD) (LPVOID) aIds); 
			return TRUE;
		}

		case WM_KEYUP:
		{
			SetCapsLockMessageState(GetParent(hwnd));
			break;
		}

//		case WM_RBUTTONDOWN :
//		case WM_CONTEXTMENU :
		case WM_LBUTTONDBLCLK :
		case WM_MOUSEMOVE :
		case WM_COPY :
		case WM_CUT :
		case WM_PASTE :
		case WM_CLEAR :
			return TRUE;

		case WM_LBUTTONDOWN :
			if (GetKeyState (VK_SHIFT) & 0x8000) return TRUE;
			break;

		case WM_PAINT :
		{
			GPP *gpp;

			gpp=(GPP *)GetWindowLong (GetParent(hwnd), GWL_USERDATA);

			if (wParam) 
			{
				SetBkColor ((HDC)wParam, GetSysColor (COLOR_WINDOW));
				if (gpp->bHideText) 
					SetTextColor ((HDC)wParam, GetSysColor (COLOR_WINDOW));
				else 
					SetTextColor ((HDC)wParam, GetSysColor (COLOR_WINDOWTEXT));
			}
			break; 
		}

		case WM_KEYDOWN :
			if (GetKeyState (VK_SHIFT) & 0x8000) 
			{
				switch (wParam) 
				{
					case VK_HOME :
					case VK_END :
					case VK_UP :
					case VK_DOWN :
					case VK_LEFT :
					case VK_RIGHT :
					case VK_NEXT :
					case VK_PRIOR :
						return TRUE;
				}
			}
			break;

		case WM_SETFOCUS :
			SendMessage (hwnd, EM_SETSEL, 0xFFFF, 0xFFFF);
			break;
	}
    return FALSE; 
} 

//	______________________________________
//
//  Passphrase edit box subclass procedure

LRESULT APIENTRY 
PhraseSubclassProc (
		HWND	hWnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	UINT				uQuality;
	CHAR *				szBuf;
	LRESULT				lResult;
	BOOL				OKactive;
	GPP					 *gpp;

	gpp=(GPP *)GetWindowLong (GetParent(hWnd), GWL_USERDATA);

	if (CommonPhraseMsgProc (hWnd, uMsg, wParam, lParam)) return 0;

	switch (uMsg) 
	{
		case WM_GETTEXT :
		{
			if (!gpp->pszPassPhrase) return 0;
			lParam = (LPARAM)gpp->pszPassPhrase;
			break;
		}

		case WM_CHAR :
		{
			if (wParam == VK_TAB) 
			{
				if (GetKeyState (VK_SHIFT) & 0x8000) 
					SetFocus (GetDlgItem (GetParent (hWnd), IDC_HIDETYPING));
				else 
					SetFocus (GetDlgItem (GetParent (hWnd), gpp->iNextTabControl));
			}
			else 
			{
				OKactive=TRUE;

				lResult = CallWindowProc (gpp->wpOrigPhrase1Proc, 
					hWnd, uMsg, wParam, lParam); 

				// Get our passphrase in secure memory
				szBuf=(char *)secAlloc(gpp->context,1024);
				CallWindowProc (gpp->wpOrigPhrase1Proc, 
					hWnd, WM_GETTEXT, 1024, (LPARAM)szBuf); 

				// Estimate its quality
				uQuality=pgpEstimatePassphraseQuality(szBuf);
/*
				// Check length for setting OK to TRUE
				if(options->mMinPassphraseLength!=0)
				{
					if(strlen(szBuf)<options->mMinPassphraseLength)
					{
						OKactive=FALSE;
					}
				}
*/
				// Free the passphrase
				memset (szBuf, 0, sizeof(szBuf));
				secFree(szBuf);

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

				// Enable/disable OK
				EnableWindow (GetDlgItem (GetParent(hWnd), IDOK), OKactive);
				return lResult;
			}
			break;
		}
	}
    return CallWindowProc (gpp->wpOrigPhrase1Proc, 
		hWnd, uMsg, wParam, lParam); 
} 

//	______________________________________
//
//  Passphrase edit box subclass procedure

LRESULT APIENTRY 
PhraseConfirmSubclassProc (
		HWND	hWnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	GPP *gpp;

	gpp=(GPP *)GetWindowLong (GetParent(hWnd), GWL_USERDATA);

	if (CommonPhraseMsgProc (hWnd, uMsg, wParam, lParam)) return 0;

	switch (uMsg) 
	{
		case WM_GETTEXT :
			if (!gpp->pszPassPhraseConf) return 0;
			lParam = (LPARAM)gpp->pszPassPhraseConf;
			break;

		case WM_CHAR :
			if (wParam == VK_TAB) 
			{
				if (GetKeyState (VK_SHIFT) & 0x8000) 
					SetFocus (GetDlgItem (GetParent (hWnd), IDC_PHRASE2));
				else SetFocus (GetDlgItem (GetParent (hWnd), IDOK));
			}
			break;
	}

    return CallWindowProc(gpp->wpOrigPhrase2Proc, 
		hWnd, uMsg, wParam, lParam); 
} 

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);