cconfirmpassphrasedialog.cpp

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

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CConfirmPassphraseDialog.cpp,v 1.14 2002/10/16 00:38:33 wjb Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"
#include "pgpBuild.h"
#include "pgpPassphraseUtils.h"

#include "CArray.h"
#include "CFile.h"

#include "CMessageBox.h"
#include "CRect.h"
#include "CWaitCursor.h"
#include "UModuleInstance.h"
#include "UWinVersion.h"

#include "CPGPdiskEngine.h"
#include "UCommonStrings.h"
#include "CPGPclPrefs.h"

#include "CConfirmPassphraseDialog.h"
#include "CHelpShower.h"
#include "PGPdiskHelp.h"
#include "PGPdiskUIPriv.h"
#include "Resource.h"

_USING_PGP

_UNNAMED_BEGIN

// Constants

enum 
{
	kDLUMarginControl		= 4, 
	kDLUMarginDialog		= 7, 
	kDLUStartYForInfoBar	= 115, 

	kCapsLockStringId	= 0
};

DWORD	ConfirmPassDlgHelpIDs[]	= 
{
	IDC_MESSAGE_TEXT,		-1, 
	IDC_PHRASELENGTH_TEXT,	-1, 
	IDC_HIDETYPE_CHECK,		IDH_PGPDISKUI_CONFIRMPASSDLG_HIDETYPING, 
	IDC_PASSPHRASE_CAPTION,	IDH_PGPDISKUI_CONFIRMPASSDLG_PASSPHRASE, 
	IDC_PASSPHRASE_EDIT,	IDH_PGPDISKUI_CONFIRMPASSDLG_PASSPHRASE, 
	IDC_QUALITY_CAPTION,	IDH_PGPDISKUI_CONFIRMPASSDLG_QUALITYBAR, 
	IDC_QUALITY_BAR,		IDH_PGPDISKUI_CONFIRMPASSDLG_QUALITYBAR, 
	IDC_MINQUALITY_CAPTION,	IDH_PGPDISKUI_CONFIRMPASSDLG_MINQUALITYBAR, 
	IDC_MINQUALITY_BAR,		IDH_PGPDISKUI_CONFIRMPASSDLG_MINQUALITYBAR, 
	IDC_CONFIRM_CAPTION,	IDH_PGPDISKUI_CONFIRMPASSDLG_CONFIRMPHRASE, 
	IDC_CONFIRM_EDIT,		IDH_PGPDISKUI_CONFIRMPASSDLG_CONFIRMPHRASE, 
	IDOK,					IDH_PGPDISKUI_CONFIRMPASSDLG_OK, 
	IDCANCEL,				IDH_PGPDISKUI_CONFIRMPASSDLG_CANCEL, 
	0,						0
};

_UNNAMED_END


// Class CConfirmPassphraseDialog member functions

PGPUInt16 
CConfirmPassphraseDialog::GetDialogId() const
{
	return IDD_CONFIRMPASS_DLG;
}

void 
CConfirmPassphraseDialog::AskPassphrase(
	const CPGPdiskContext&	context, 
	HWND					parentWnd, 
	const char				*passText, 
	const char				*passSubString)
{
	char localSub[kPGPMaxUserIDSize];
	PGPSize usedLength;

	pgpAssert(CWindow::IsWindow(parentWnd));
	pgpAssertStrValid(passText);
	pgpAssertStrValid(passSubString);

	mPContext = &context;

	mFormatText = passText;

	pgpUTF8StringToLocal (
		0, 0, passSubString, strlen(passSubString), 
		localSub, 
		kPGPMaxUserIDSize, &usedLength);
	mFormatSubString	= localSub;

	CreateModal(parentWnd);
}

void 
CConfirmPassphraseDialog::CreateCapsLockBar()
{
	// Create caps lock info bar.
	CRect	qualityRect;

	mQualityBar.GetWindowRect(qualityRect);
	ScreenToClient(qualityRect);

	CPoint	origin(qualityRect.Left(), VertDLUToPixel(kDLUStartYForInfoBar));
	PGPUInt32	width	= qualityRect.Right() - qualityRect.Left();

	mCapsLockBar.Create(UModuleInstance::Get(), Handle(), origin, width);
}

void 
CConfirmPassphraseDialog::InitDialogText()
{
	using namespace UCommonStrings;

	mMessageText.FitFormattedTextToWindow(mFormatText, mFormatSubString);
	SetWindowText(Get(kConfirmPassDialogTitle));
	
	CString	lengthText;

	if (mEnforceMinLength)
		lengthText.Format(Get(kNewUserPassTellMinLengthText), mMinPassLength);
	else
		lengthText.Format(Get(kNewUserPassSugMinLengthText), mMinPassLength);

	mPhraseLengthText.SetWindowText(lengthText);
}

void 
CConfirmPassphraseDialog::InitControls()
{
	mHideTypingCheck.SetCheck(BST_CHECKED);
	mPassphraseEdit.SetHideTypingPref(TRUE);
	mConfirmEdit.SetHideTypingPref(TRUE);

	mPassphraseEdit.SetMaxSizeContents(kPGPdiskMaxPassLength);
	mConfirmEdit.SetMaxSizeContents(kPGPdiskMaxPassLength);

	mIHadFocus = &mPassphraseEdit;
	
	mQualityBar.SetRange(0, 100);
	mQualityBar.SetPos(0);

	if (mEnforceMinQuality)
	{
		mMinQualityBar.SetRange(0, 100);
		mMinQualityBar.SetPos(mMinPassQuality);
	}
	else
	{
		mMinQualityBar.ShowWindow(SW_HIDE);
		mMinQualityText.ShowWindow(SW_HIDE);
	}

	CreateCapsLockBar();
	SetCapsLockMessageState();
}

void 
CConfirmPassphraseDialog::InitQualityPrefs()
{
	mEnforceMinLength = mEnforceMinQuality = FALSE;

	mMinPassLength = PGPdiskUIPriv::kDiskSugMinPassLength;
	mMinPassQuality = 0;

	if(PGPclEnterprise())
	{
		// Minimum passphrase length and quality.
		CPGPclPrefs	clPrefs(mPContext->PGPclPrefs());

		if (clPrefs.GetBoolean(kPGPPrefEnforceMinChars))
		{
			mEnforceMinLength = TRUE;
			mMinPassLength = clPrefs.GetNumber(kPGPPrefMinChars);
		}

		if (clPrefs.GetBoolean(kPGPPrefEnforceMinQuality))
		{
			mEnforceMinQuality = TRUE;
			mMinPassQuality = clPrefs.GetNumber(kPGPPrefMinQuality);
		}
	}
}

void 
CConfirmPassphraseDialog::UpdatePassphraseQuality()
{
	CSecureArray<char>	passphrase;
	mPassphraseEdit.Contents().Extract(passphrase);

	PGPUInt32	quality	= pgpEstimatePassphraseQuality(passphrase.Get());
	mQualityBar.SetPos(quality);
}

void 
CConfirmPassphraseDialog::SetCapsLockMessageState()
{
	if (GetKeyState(VK_CAPITAL) & 1)
		WarnCapsLock(TRUE);
	else
		WarnCapsLock(FALSE);
}

void 
CConfirmPassphraseDialog::WarnCapsLock(PGPBoolean warn)
{
	PGPInt32	curIndex	= mCapsLockBar.GetIndexOfId(kCapsLockStringId);

	if (warn && (curIndex == -1))
	{
		mCapsLockBar.AddString(0, UCommonStrings::Get(
			UCommonStrings::kWarnCapsLockDown), kCapsLockStringId);
		mCapsLockBar.ResizeRedraw();
	}
	else if (!warn && (curIndex != -1))
	{
		mCapsLockBar.RemoveString(curIndex);
		mCapsLockBar.ResizeRedraw();
	}
}

void 
CConfirmPassphraseDialog::OnHideTypeCheck()
{
	PGPBoolean	hideTyping	= (mHideTypingCheck.GetCheck() == BST_CHECKED);

	mPassphraseEdit.SetHideTypingPref(hideTyping);
	mConfirmEdit.SetHideTypingPref(hideTyping);

	mIHadFocus->SetFocus();
}

void 
CConfirmPassphraseDialog::OnOk()
{
	using namespace UCommonStrings;

	CString		badPassString;
	PGPBoolean	shouldFail		= FALSE;
	PGPBoolean	usesTemplate	= TRUE;

	// Must have a passphrase.
	if (mPassphraseEdit.Contents().Length() == 0)
	{
		badPassString = Get(kTellPassphraseEmpty);

		usesTemplate = FALSE;
		shouldFail = TRUE;
	}

	// Check that confirmation matches.
	if (!shouldFail && 
		(mPassphraseEdit.Contents() != mConfirmEdit.Contents()))
	{
		badPassString = Get(kConfirmPassBadPassConfirm);
		shouldFail = TRUE;
	}

	// Check that length is valid.
	if (!shouldFail && mEnforceMinLength && 
		(mPassphraseEdit.Contents().Length() < mMinPassLength))
	{
		badPassString.Format(Get(kConfirmPassBadPassMinLengthReject), 
			mMinPassLength);

		shouldFail = TRUE;
	}

	// Check minimum quality.
	if (!shouldFail && mEnforceMinQuality &&
		(static_cast<PGPUInt32>(mQualityBar.GetPos()) < mMinPassQuality))
	{
		badPassString.Format(Get(kConfirmPassBadPassMinQualityReject), 
			mMinPassQuality);

		shouldFail = TRUE;
	}

	if (shouldFail)
	{
		CString	failString;

		if (usesTemplate)
		{
			failString.Format(Get(kConfirmPassBadPassTemplate), 
				badPassString.Get());
		}
		else
		{
			failString = badPassString;
		}

		CMessageBox	messageBox;
		messageBox.Display(failString, Get(kConfirmPassMsgBoxTitle), 
			Handle());

		mPassphraseEdit.ClearContents();
		mConfirmEdit.ClearContents();
		mPassphraseEdit.SetFocus();
	}
	else
	{
		CDialog::OnOk();
	}
}

BOOL 
CConfirmPassphraseDialog::OnCommand(
	PGPUInt16	notifyCode, 
	PGPUInt16	itemId, 
	HWND		ctrl)
{
	switch (notifyCode)
	{
	case BN_CLICKED:
		switch (itemId)
		{
		case IDC_HIDETYPE_CHECK:
			OnHideTypeCheck();
			return TRUE;
		}
		break;

	case EN_CHANGE:
		UpdatePassphraseQuality();
		break;

	case EN_KILLFOCUS:
		switch (itemId)
		{
		case IDC_PASSPHRASE_EDIT:
			mIHadFocus = &mPassphraseEdit;
			break;

		case IDC_CONFIRM_EDIT:
			mIHadFocus = &mConfirmEdit;
			break;
		}
		break;

	case EN_SETFOCUS:
		SetCapsLockMessageState();
		break;
	}

	return CDialog::OnCommand(notifyCode, itemId, ctrl);
}

void 
CConfirmPassphraseDialog::OnContextMenu(HWND menuWnd, CPoint coords)
{
	CHelpShower::ShowContextMenu(menuWnd, ConfirmPassDlgHelpIDs);
}

void 
CConfirmPassphraseDialog::OnHelp(HELPINFO *pInfo)
{
	CHelpShower::ShowForControl(static_cast<HWND>(pInfo->hItemHandle), 
		ConfirmPassDlgHelpIDs);
}

BOOL 
CConfirmPassphraseDialog::OnInitDialog(HWND focusCtrl)
{
	CDialog::OnInitDialog(focusCtrl);

	// Attach controls.
	mHideTypingCheck.Subclass(GetDlgItem(IDC_HIDETYPE_CHECK));
	mMinQualityBar.Subclass(GetDlgItem(IDC_MINQUALITY_BAR));
	mQualityBar.Subclass(GetDlgItem(IDC_QUALITY_BAR));
	mPassphraseEdit.Subclass(GetDlgItem(IDC_PASSPHRASE_EDIT),mPContext->PGPContext());
	mConfirmEdit.Subclass(GetDlgItem(IDC_CONFIRM_EDIT),mPContext->PGPContext());
	mMessageText.Subclass(GetDlgItem(IDC_MESSAGE_TEXT));
	mMinQualityText.Subclass(GetDlgItem(IDC_MINQUALITY_CAPTION));
	mPhraseLengthText.Subclass(GetDlgItem(IDC_PHRASELENGTH_TEXT));

	// Initialize page.
	InitQualityPrefs();
	InitControls();
	InitDialogText();

	mPassphraseEdit.SetFocus();

	Center();
	SetForegroundWindow();

	return FALSE;
}

void 
CConfirmPassphraseDialog::OnKeyUp(PGPUInt32 vKey, PGPUInt32 keyData)
{
	SetCapsLockMessageState();
	CDialog::OnKeyUp(vKey, keyData);
}

PGPUInt32 
CConfirmPassphraseDialog::OnSecureEditEvent(HWND view, PGPUInt32 event)
{
	switch (event)
	{
	case CSecureRichEdit::kContentsChangedEvent:
		UpdatePassphraseQuality();
		break;

	case CSecureRichEdit::kSawCapsLockKeyEvent:
		SetCapsLockMessageState();
		break;

	case CSecureRichEdit::kSawReturnKeyEvent:
		OnOk();
		break;
	}

	return TRUE;
}

PGPBoolean 
CConfirmPassphraseDialog::PreProcess(const CMessage& msg, LRESULT& result)
{
	if (msg.Message() == CSecureRichEdit::WM_SECUREEDIT_EVENT)
	{
		result = OnSecureEditEvent(reinterpret_cast<HWND>(msg.WParam()), 
			msg.LParam());
		return TRUE;
	}

	return FALSE;
}