pwgeneratorexdlg.cpp

一款密码保险箱源码

	m_bBlockUIUpdate = TRUE;

	this->UpdateData(TRUE);

	if(bSelectCustom)
		m_cmbProfile.SelectString(-1, STR_CUSTOM_PROFILE);

	BOOL bCharSetBased = ((m_rbCharSetBased.GetCheck() == BST_CHECKED) ? TRUE : FALSE);

	ENSURE_ENABLED_STATE(m_stcLength, bCharSetBased);
	ENSURE_ENABLED_STATE(m_tbLength, bCharSetBased);
	ENSURE_ENABLED_STATE(m_spinNumChars, bCharSetBased);

	ENSURE_ENABLED_STATE(m_cbUpperCase, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbLowerCase, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbNumeric, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbMinus, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbUnderline, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbSpace, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbBrackets, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbSpecial, bCharSetBased);
	ENSURE_ENABLED_STATE(m_cbHighAnsi, bCharSetBased);

	ENSURE_ENABLED_STATE(m_stcCustomCharSet, bCharSetBased);
	ENSURE_ENABLED_STATE(m_tbCustomCharSet, bCharSetBased);

	BOOL bPattern = (bCharSetBased == TRUE) ? FALSE : TRUE;

	ENSURE_ENABLED_STATE(m_tbPattern, bPattern);
	ENSURE_ENABLED_STATE(m_cbPatternPermute, bPattern);

	CString strCurrentName = GetCurrentGenProfile();
	BOOL bDelete = (((strCurrentName != STR_CUSTOM_PROFILE) &&
		(strCurrentName != STR_AUTO_PROFILE)) ? TRUE : FALSE);
	ENSURE_ENABLED_STATE(m_btnProfileDelete, bDelete);

	BOOL bNoAutoProfile = ((strCurrentName != STR_AUTO_PROFILE) ? TRUE : FALSE);

	ENSURE_ENABLED_STATE(m_cbCollectEntropy, bNoAutoProfile);

	LPTSTR lpPassword = m_cEditPw.GetPassword();
	NewGUI_ShowQualityMeter(&m_cPassQuality, GetDlgItem(IDC_STATIC_PASSBITS), lpPassword);

	if(m_dwRequestedPasswords > 0)
	{
		ENSURE_VISIBLE_STATE(m_btnOK, TRUE);
		ENSURE_ENABLED_STATE(m_btnOK, ((lpPassword[0] != 0) ? TRUE : FALSE) &
			bNoAutoProfile);
	}
	else // Can't accept
	{
		ENSURE_ENABLED_STATE(m_btnOK, FALSE);
		ENSURE_VISIBLE_STATE(m_btnOK, FALSE);
	}

	CSecureEditEx::DeletePassword(lpPassword); lpPassword = NULL;

	if(m_dwPasswordLength > PWGD_MAX_PASSWORD_LENGTH)
	{
		m_dwPasswordLength = PWGD_MAX_PASSWORD_LENGTH;
		this->UpdateData(FALSE);
	}

	m_bBlockUIUpdate = FALSE;
}

void CPwGeneratorExDlg::OnRadioCharsetBased()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnRadioPatternBased()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedBtnHelp()
{
	WU_OpenAppHelp(PWM_HELP_PWGEN);
}

void CPwGeneratorExDlg::LoadGenProfiles()
{
	TCHAR szTemp[SI_REGSIZE];
	CPrivateConfigEx cConfig(FALSE);
	CString strProfileKey;

	m_vProfiles.clear();

	for(int nProfile = 0; true; ++nProfile)
	{
		strProfileKey.Format(_T("%s%d"), PWMKEY_GENPROFILE, nProfile);
		cConfig.Get(strProfileKey, szTemp);

		if(szTemp[0] == 0) break;
		if(_tcscmp(szTemp, _T("0")) == 0) break;

		std::basic_string<TCHAR> tstr = szTemp;

		PW_GEN_SETTINGS_EX s;
		PwgStringToProfile(tstr, &s);

		m_vProfiles.push_back(s);
	}

	cConfig.Get(PWMKEY_GENPROFILELASTPR, szTemp);
	if((szTemp[0] != 0) && (_tcscmp(szTemp, _T("0")) != 0))
	{
		std::basic_string<TCHAR> strLast = szTemp;
		PwgStringToProfile(strLast, &m_pgsLast);
	}
}

void CPwGeneratorExDlg::SaveGenProfiles()
{
	CPrivateConfigEx cConfig(TRUE);
	CString strProfileKey;

	for(unsigned int uProfile = 0; uProfile < m_vProfiles.size(); ++uProfile)
	{
		strProfileKey.Format(_T("%s%u"), PWMKEY_GENPROFILE, uProfile);

		std::basic_string<TCHAR> str = PwgProfileToString(&m_vProfiles[uProfile]);

		cConfig.Set(strProfileKey, str.c_str());
	}

	strProfileKey.Format(_T("%s%u"), PWMKEY_GENPROFILE, m_vProfiles.size());
	cConfig.Set(strProfileKey, _T("0"));

	UpdateDialogDataEx(TRUE, &m_pgsLast);
	m_pgsLast.strName = (LPCTSTR)GetCurrentGenProfile();
	std::basic_string<TCHAR> strLast = PwgProfileToString(&m_pgsLast);
	cConfig.Set(PWMKEY_GENPROFILELASTPR, strLast.c_str());
}

PW_GEN_SETTINGS_EX* CPwGeneratorExDlg::FindGenProfile(CString strProfileName)
{
	if(strProfileName == STR_AUTO_PROFILE) return &CPwSafeDlg::m_pgsAutoProfile;

	for(DWORD i = 0; i < m_vProfiles.size(); ++i)
	{
		if(m_vProfiles[i].strName == (LPCTSTR)strProfileName)
			return &m_vProfiles[i];
	}

	return NULL;
}

void CPwGeneratorExDlg::ShowGenProfile(CString strProfileName)
{
	PW_GEN_SETTINGS_EX* pProfile = FindGenProfile(strProfileName);
	if(pProfile == NULL) { EnableControlsEx(FALSE); return; }

	UpdateDialogDataEx(FALSE, pProfile);
	EnableControlsEx(FALSE);
}

void CPwGeneratorExDlg::OnCbnSelChangeComboProfiles()
{
	CString strProfile = GetCurrentGenProfile();
	ShowGenProfile(strProfile);
	EnableControlsEx(FALSE);
}

void CPwGeneratorExDlg::OnBnClickedBtnProfileCreate()
{
	this->UpdateData(TRUE);

	std::vector<std::basic_string<TCHAR> > vSelectable;

	vSelectable.push_back(STR_AUTO_PROFILE);
	for(DWORD i = 0; i < m_vProfiles.size(); ++i)
		vSelectable.push_back(m_vProfiles[i].strName);

	CSingleLineEditDlg dlg;
	dlg.InitEx(TRL("Save as Profile"), TRL("Save current settings as password generator profile."),
		TRL("Please enter a name for the new password generator profile, or select an existing profile to overwrite it:"),
		PWGD_MAX_PROFILE_NAME_LENGTH, _T(""), vSelectable);

	if(dlg.DoModal() == IDOK)
	{
		CString strName = dlg.GetEnteredText();

		if(strName == STR_CUSTOM_PROFILE)
		{
			MessageBox(TRL("Path is invalid"), TRL("Password Safe"), MB_OK | MB_ICONWARNING);
			return;
		}

		PW_GEN_SETTINGS_EX s;
		UpdateDialogDataEx(TRUE, &s);
		s.strName = strName;

		if(strName == STR_AUTO_PROFILE)
		{
			s.bCollectUserEntropy = FALSE;
			CPwSafeDlg::m_pgsAutoProfile = s;
		}
		else
		{
			BOOL bExists = FALSE;
			for(DWORD i = 0; i < m_vProfiles.size(); ++i)
			{
				if(m_vProfiles[i].strName == (LPCTSTR)strName)
				{
					m_vProfiles[i] = s;
					bExists = TRUE;
					break;
				}
			}

			if(bExists == FALSE) m_vProfiles.push_back(s);
		}

		RecreateProfilesList();
		m_cmbProfile.SelectString(-1, strName);
		ShowGenProfile(strName);
	}
}

CString CPwGeneratorExDlg::GetCurrentGenProfile()
{
	CString strProfile;
	int nSel = m_cmbProfile.GetCurSel();
	if(nSel < 0) m_cmbProfile.GetWindowText(strProfile);
	else m_cmbProfile.GetLBText(nSel, strProfile);
	return strProfile;
}

void CPwGeneratorExDlg::RecreateProfilesList()
{
	CString strPrevText = GetCurrentGenProfile();

	m_cmbProfile.ResetContent();

	m_cmbProfile.AddString(STR_CUSTOM_PROFILE);
	m_cmbProfile.AddString(STR_AUTO_PROFILE);

	for(DWORD i = 0; i < m_vProfiles.size(); ++i)
		m_cmbProfile.AddString(m_vProfiles[i].strName.c_str());

	if(m_cmbProfile.SelectString(-1, strPrevText) == CB_ERR)
		m_cmbProfile.SelectString(-1, STR_CUSTOM_PROFILE);

	EnableControlsEx(FALSE);
}

void CPwGeneratorExDlg::OnBnClickedBtnProfileDelete()
{
	this->UpdateData(TRUE);

	CString strProfile = GetCurrentGenProfile();

	for(std::vector<PW_GEN_SETTINGS_EX>::iterator it = m_vProfiles.begin();
		it != m_vProfiles.end(); ++it)
	{
		if(it->strName == (LPCTSTR)strProfile)
		{
			m_vProfiles.erase(it);

			RecreateProfilesList();
			break;
		}
	}
}

void CPwGeneratorExDlg::OnBnClickedGenerateBtn()
{
	PW_GEN_SETTINGS_EX pws;
	this->UpdateDialogDataEx(TRUE, &pws);

	CNewRandom randomSource;

	if(m_bCollectEntropy == TRUE)
	{
		CGetRandomDlg dlg;
		if(dlg.DoModal() == IDCANCEL) return;

		randomSource.AddToUserEntropyPool(dlg.m_pFinalRandom, 32);
	}

	std::vector<TCHAR> strPassword;
	USHORT uError = PwgGenerateEx(strPassword, &pws, &randomSource);

	if(uError != PWGE_SUCCESS)
	{
		std::basic_string<TCHAR> strError = _TRL(PwgErrorToString(uError));
		strError += _T(".");
		MessageBox(strError.c_str(), TRL("Password Safe"), MB_OK | MB_ICONWARNING);

		EraseTCharVector(strPassword);
	}

	if(strPassword.size() > PWGD_MAX_PASSWORD_LENGTH)
		strPassword[PWGD_MAX_PASSWORD_LENGTH] = 0; // Truncate

	if(strPassword.size() > 0) m_cEditPw.SetPassword(&strPassword[0]);
	else m_cEditPw.SetPassword(_T(""));

	EraseTCharVector(strPassword);

	this->EnableControlsEx(FALSE);
}

void CPwGeneratorExDlg::OnCheckHidePw()
{
	UpdateData(TRUE);

	if(m_bHidePw == FALSE)
	{
		m_cEditPw.EnableSecureMode(FALSE);
		m_cEditPw.SetPasswordChar(0);
		m_cEditPw.SetFont(&m_fStyle, TRUE);
	}
	else
	{
		// TCHAR tchDot = (TCHAR)(_T('z') + 27);
		TCHAR tchDot = CPwSafeApp::GetPasswordCharacter();
		m_cEditPw.EnableSecureMode(CPwSafeDlg::m_bSecureEdits);
		m_cEditPw.SetPasswordChar(tchDot);
		m_cEditPw.SetFont(&m_fSymbol, TRUE);
	}

	m_tipSecClear.Activate(m_cEditPw.IsSecureModeEnabled());

	UpdateData(FALSE);
	m_cEditPw.RedrawWindow();
	m_cEditPw.SetFocus();
}

void CPwGeneratorExDlg::OnDeltaPosSpinLength(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
	*pResult = 0;

	UpdateData(TRUE);

	int nPos = (int)m_dwPasswordLength;
	nPos += pNMUpDown->iDelta;
	if(nPos < 0) nPos = 0;
	m_dwPasswordLength = static_cast<DWORD>(nPos);

	m_spinNumChars.SetPos(512);

	UpdateData(FALSE);
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnEnChangeEditPw()
{
	this->EnableControlsEx(FALSE);
}

BOOL CPwGeneratorExDlg::PreTranslateMessage(MSG* pMsg)
{
	m_tipSecClear.RelayEvent(pMsg);

	return CDialog::PreTranslateMessage(pMsg);
}

void CPwGeneratorExDlg::OnEnChangeEditLength()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnEnChangeEditCustomCharSet()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnEnChangeEditPattern()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsUppercase()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsLowercase()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsNumeric()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsMinus()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsUnderline()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsSpace()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsSpecial()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsBrackets()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCsHighansi()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckNoConfusing()
{
	this->EnableControlsEx(TRUE);
}

void CPwGeneratorExDlg::OnBnClickedCheckCollectEntropy()
{
	this->EnableControlsEx(TRUE);
}