createwiz.cpp

vc环境下的pgp源码

	pspWiz[Wiz_ADKOutSelect].pfnDlgProc = (DLGPROC) ADKOutSelectDlgProc;
	
	// Set up the additional decryption key enforcement page

	pspWiz[Wiz_ADKEnforce].pszTemplate = 
										MAKEINTRESOURCE(IDD_ADK_ENFORCE);
	pspWiz[Wiz_ADKEnforce].pfnDlgProc = (DLGPROC) ADKEnforceDlgProc;
	
	// Set up the PGPdisk additional decryption key page

	pspWiz[Wiz_ADKDisk].pszTemplate = MAKEINTRESOURCE(IDD_ADK_DISK);
	pspWiz[Wiz_ADKDisk].pfnDlgProc  = (DLGPROC) ADKDiskDlgProc;
	
	// Set up the PGPdisk additional decryption key selection page

	pspWiz[Wiz_ADKDiskSelect].pszTemplate = 
										MAKEINTRESOURCE(IDD_ADK_DISKSEL);
	pspWiz[Wiz_ADKDiskSelect].pfnDlgProc = (DLGPROC) ADKDiskSelectDlgProc;
	
	// Set up the pass phrase page

	pspWiz[Wiz_PassPhrase].pszTemplate	= MAKEINTRESOURCE(IDD_PASSPHRASE);
	pspWiz[Wiz_PassPhrase].pfnDlgProc	= (DLGPROC) PassPhraseDlgProc;
	
	// Set up the corporate key page

	pspWiz[Wiz_CorpKey].pszTemplate = MAKEINTRESOURCE(IDD_CORPKEY);
	pspWiz[Wiz_CorpKey].pfnDlgProc	= (DLGPROC) CorpKeyDlgProc;
	
	// Set up the corporate key selection page

	pspWiz[Wiz_CorpKeySelect].pszTemplate	= MAKEINTRESOURCE(IDD_CORPKEYSEL);
	pspWiz[Wiz_CorpKeySelect].pfnDlgProc	= (DLGPROC) CorpKeySelectDlgProc;
	
	// Set up the revoker key page

	pspWiz[Wiz_Revoker].pszTemplate = MAKEINTRESOURCE(IDD_REVOKER);
	pspWiz[Wiz_Revoker].pfnDlgProc	= (DLGPROC) RevokerDlgProc;
	
	// Set up the revoker key selection page

	pspWiz[Wiz_RevokerSelect].pszTemplate	= MAKEINTRESOURCE(IDD_REVOKERSEL);
	pspWiz[Wiz_RevokerSelect].pfnDlgProc	= (DLGPROC) RevokerSelectDlgProc;
	
	// Set up the X.509 certificate settings page

	pspWiz[Wiz_X509].pszTemplate	= MAKEINTRESOURCE(IDD_X509);
	pspWiz[Wiz_X509].pfnDlgProc		= (DLGPROC) X509DlgProc;
	
	// Set up the key generation page

	pspWiz[Wiz_KeyGen].pszTemplate	= MAKEINTRESOURCE(IDD_KEYGEN);
	pspWiz[Wiz_KeyGen].pfnDlgProc	= (DLGPROC) KeyGenDlgProc;
	
	// Set up the default key selection page

	pspWiz[Wiz_DefaultKeys].pszTemplate = MAKEINTRESOURCE(IDD_DEFKEYSEL);
	pspWiz[Wiz_DefaultKeys].pfnDlgProc	= (DLGPROC) DefaultKeysDlgProc;
	
	// Set up the server updates page

	pspWiz[Wiz_ServerUpdates].pszTemplate = 
										MAKEINTRESOURCE(IDD_SERVERUPDATES);
	pspWiz[Wiz_ServerUpdates].pfnDlgProc  = (DLGPROC) ServerUpdatesDlgProc;
	
	// Set up the miscellaneous page

	pspWiz[Wiz_Misc].pszTemplate	= MAKEINTRESOURCE(IDD_MISC);
	pspWiz[Wiz_Misc].pfnDlgProc		= (DLGPROC) MiscDlgProc;
	
	// Set up the review page

	pspWiz[Wiz_Review].pszTemplate	= MAKEINTRESOURCE(IDD_REVIEW);
	pspWiz[Wiz_Review].pfnDlgProc	= (DLGPROC) ReviewDlgProc;
	
	// Set up the client prefs page

	pspWiz[Wiz_ClientPrefs].pszTemplate	= MAKEINTRESOURCE(IDD_CLIENTPREFS);
	pspWiz[Wiz_ClientPrefs].pfnDlgProc	= (DLGPROC) ClientPrefsDlgProc;
	
	// Set up the install options page

	pspWiz[Wiz_InstallOptions].pszTemplate =
										MAKEINTRESOURCE(IDD_INSTALLOPTIONS);
	pspWiz[Wiz_InstallOptions].pfnDlgProc  = (DLGPROC) InstallOptionsDlgProc;
	
	// Set up the installer page

	pspWiz[Wiz_Installer].pszTemplate	= MAKEINTRESOURCE(IDD_INSTALLER);
	pspWiz[Wiz_Installer].pfnDlgProc	= (DLGPROC) InstallerDlgProc;
	
	// Set up the finishing page

	pspWiz[Wiz_Finish].pszTemplate	= MAKEINTRESOURCE(IDD_FINISH);
	pspWiz[Wiz_Finish].pfnDlgProc	= (DLGPROC) FinishDlgProc;
	
	// Create the header

	pshWiz.dwSize		= sizeof(PROPSHEETHEADER);
	pshWiz.dwFlags		= PSH_WIZARD | PSH_PROPSHEETPAGE;
	pshWiz.hwndParent	= hwndMain;
	pshWiz.hInstance	= g_hInstance;
	pshWiz.hIcon		= NULL;
	pshWiz.pszCaption	= NULL;
	pshWiz.nPages		= NUM_WIZ_PAGES;
	pshWiz.nStartPage	= Wiz_Start;
	pshWiz.ppsp			= pspWiz;
	pshWiz.pfnCallback	= NULL;

	// Execute the Wizard - doesn't return until Cancel or Save

	PropertySheet(&pshWiz);

	// Save settings

	if (Config.bSave)
	{
		PGPPrefRef		clientPrefs;
		PGPPrefRef		netPrefs;
		PGPKeyID		keyID;
		PGPByte			exportedKeyID[kPGPMaxExportedKeyIDSize];
		PGPSize			keyIDSize;
		char			szSetupIni[MAX_PATH];
		char *			szAdminBuffer = NULL;
		char *			szClientBuffer = NULL;
		char *			szNetBuffer = NULL;
		char *			szSetupBuffer = NULL;
		PGPSize			nAdminBufferSize = 0;
		PGPSize			nClientBufferSize = 0;
		PGPSize			nNetBufferSize = 0;
		PGPSize			nSetupBufferSize = 0;
		HWND			hwndDlg;
		HANDLE			hFile;

		// Show the "wait" dialog box while this is being executed

		hwndDlg = CreateDialog(g_hInstance, MAKEINTRESOURCE(IDD_WAIT), 
					hwndMain, (DLGPROC) WaitProc);
		ShowWindow(hwndDlg, SW_SHOW);

		// Save the admin prefs

		PGPclOpenAdminPrefs(Config.memoryMgr, &adminPrefs, TRUE);

		PGPSetPrefBoolean(adminPrefs, kPGPPrefUseOutgoingADK, 
			Config.bUseOutgoingADK);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefUseDHADK, 
			Config.bUseIncomingADK);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefUsePGPdiskADK, 
			Config.bUseDiskADK);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefEnforceIncomingADK, 
			Config.bEnforceIncomingADK);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefEnforceOutgoingADK, 
			Config.bEnforceOutgoingADK);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefEnforceRemoteADKClass, 
			Config.bEnforceRemoteADK);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefEnforceMinChars,
			Config.bEnforceMinChars);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefEnforceMinQuality,
			Config.bEnforceMinQuality);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefWarnNotCertByCorp,
			Config.bWarnNotCertByCorp);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAutoSignTrustCorp,
			Config.bAutoSignTrustCorp);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefMetaIntroducerCorp,
			Config.bMetaIntroducerCorp);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAllowKeyGen,	
			Config.bAllowKeyGen);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAllowRSAKeyGen,
			Config.bAllowRSAKeyGen);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAllowConventionalEncryption,
			Config.bAllowConventionalEncryption);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefUpdateAllKeys,
			Config.bUpdateAllKeys);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefUpdateTrustedIntroducers,
			Config.bUpdateTrustedIntroducers);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAutoAddRevoker,
			Config.bAutoAddRevoker);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefKeyGenX509CertRequest,
			Config.bKeyGenCertRequest);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAllowManualX509CertRequest,
			Config.bAllowManualCertRequest);
		PGPSetPrefBoolean(adminPrefs, kPGPPrefAutoUpdateX509CRL,
			Config.bAutoUpdateCRL);

		PGPSetPrefNumber(adminPrefs, kPGPAdminPrefVersion, 
			PGP_ADMINPREFVERSION);
		PGPSetPrefNumber(adminPrefs, kPGPPrefMinChars, Config.nMinChars);
		PGPSetPrefNumber(adminPrefs, kPGPPrefMinQuality, Config.nMinQuality);
		PGPSetPrefNumber(adminPrefs, kPGPPrefMinimumKeySize, 
			Config.nMinKeySize);
		PGPSetPrefNumber(adminPrefs, kPGPPrefCorpKeyPublicKeyAlgorithm,
			Config.corpKeyType);
		PGPSetPrefNumber(adminPrefs, kPGPPrefOutADKPublicKeyAlgorithm,
			Config.outgoingADKKeyType);
		PGPSetPrefNumber(adminPrefs, kPGPPrefPGPdiskADKPublicKeyAlgorithm,
			Config.diskADKKeyType);
		PGPSetPrefNumber(adminPrefs, kPGPPrefDaysUpdateAllKeys,
			Config.nDaysUpdateAllKeys);
		PGPSetPrefNumber(adminPrefs, kPGPPrefDaysUpdateTrustedIntroducers,
			Config.nDaysUpdateTrustedIntroducers);
		PGPSetPrefNumber(adminPrefs, kPGPPrefRevokerPublicKeyAlgorithm,
			Config.revokerKeyType);

		if (Config.szLicenseNum != NULL)
			PGPSetPrefString(adminPrefs, kPGPPrefAdminCompanyName, 
				Config.szLicenseNum);
		else
			PGPSetPrefString(adminPrefs, kPGPPrefAdminCompanyName, "");

		if (Config.szComments != NULL)
			PGPSetPrefString(adminPrefs, kPGPPrefComments, Config.szComments);
		else
			PGPSetPrefString(adminPrefs, kPGPPrefComments,	"");

		if ((Config.szOutgoingADKID != NULL) && (Config.bUseOutgoingADK))
		{
			PGPGetKeyIDFromString(Config.szOutgoingADKID, &keyID);
			PGPExportKeyID(&keyID, exportedKeyID, &keyIDSize);
			PGPSetPrefData(adminPrefs, kPGPPrefOutgoingADKID, keyIDSize, 
				exportedKeyID);
		}

		if ((Config.szIncomingADKID != NULL) && (Config.bUseIncomingADK))
		{
			PGPGetKeyIDFromString(Config.szIncomingADKID, &keyID);
			PGPExportKeyID(&keyID, exportedKeyID, &keyIDSize);
			PGPSetPrefData(adminPrefs, kPGPPrefDHADKID, keyIDSize, 
				exportedKeyID);
		}
		
		if ((Config.szDiskADKID != NULL) && (Config.bUseDiskADK))
		{
			PGPGetKeyIDFromString(Config.szDiskADKID, &keyID);
			PGPExportKeyID(&keyID, exportedKeyID, &keyIDSize);
			PGPSetPrefData(adminPrefs, kPGPPrefPGPdiskADKKeyID, keyIDSize, 
				exportedKeyID);
		}
		
		if ((Config.szCorpKeyID != NULL) && (Config.bAutoSignTrustCorp))
		{
			PGPGetKeyIDFromString(Config.szCorpKeyID, &keyID);
			PGPExportKeyID(&keyID, exportedKeyID, &keyIDSize);
			PGPSetPrefData(adminPrefs, kPGPPrefCorpKeyID, keyIDSize, 
				exportedKeyID);
		}

		if ((Config.szRevokerKeyID != NULL) && (Config.bAutoAddRevoker))
		{
			PGPGetKeyIDFromString(Config.szRevokerKeyID, &keyID);
			PGPExportKeyID(&keyID, exportedKeyID, &keyIDSize);
			PGPSetPrefData(adminPrefs, kPGPPrefRevokerKeyID, keyIDSize, 
				exportedKeyID);
		}

		// Save the AV list, if specified

		if (Config.nCAType != kPGPKeyServerClass_Invalid)
		{
			PGPByte *data;
			PGPSize dataSize;

			PGPSetPrefNumber(adminPrefs, kPGPPrefAdminCAType, Config.nCAType);

			if ((Config.pAVList != NULL) && (Config.nNumAVs > 0))
			{
				PGPAVPairsToData(Config.memoryMgr, Config.pAVList, 
					Config.nNumAVs, &data, &dataSize);
				PGPSetPrefData(adminPrefs, kPGPPrefExtraAVPairs, dataSize,
					data);
				PGPFreeData(data);
			}
		}

		// Save the default keys if any were specified

		if (Config.defaultKeySet != NULL)
		{
			char *				szKeyBlock;
			PGPSize				nKeyBlockSize;
			PGPOptionListRef	comments;
			char				szComment[255];

			if (GetCommentString(Config.memoryMgr, szComment, 
					sizeof(szComment)))
				PGPBuildOptionList(Config.pgpContext, &comments,
					PGPOCommentString(Config.pgpContext, szComment),
					PGPOLastOption(Config.pgpContext));
			else
				PGPBuildOptionList(Config.pgpContext, 
					&comments, 
					PGPOLastOption(Config.pgpContext));

			err = PGPExportKeySet(Config.defaultKeySet,
					PGPOAllocatedOutputBuffer(Config.pgpContext,
						(void **) &szKeyBlock, INT_MAX, &nKeyBlockSize),
					PGPOVersionString(Config.pgpContext, 
						pgpVersionHeaderString),
					comments,
					PGPOLastOption(Config.pgpContext));

			PGPFreeOptionList(comments);

			if (IsPGPError(err))
			{
				PGPclErrorBox(hwndMain, err);
				goto error;
			}

			PGPSetPrefString(adminPrefs, kPGPPrefDefaultKeys, szKeyBlock);
			PGPFreeData(szKeyBlock);
		}
		else
			PGPSetPrefString(adminPrefs, kPGPPrefDefaultKeys, "");

		// Store the admin prefs to a buffer

		PGPExportPrefFileToBuffer(adminPrefs, &nAdminBufferSize,
			(void **) &szAdminBuffer);

		// Save and close the admin prefs file

		PGPclCloseAdminPrefs(adminPrefs, TRUE);

		// Load client, PGPnet, and PGPdisk prefs into a buffer, if needed
			
		if (Config.bCopyClientPrefs)
		{
			char szNetPrefFile[256];
			PFLFileSpecRef netPrefFile;

			PGPclOpenClientPrefs(Config.memoryMgr, &clientPrefs);
			PGPExportPrefFileToBuffer(clientPrefs, &nClientBufferSize,
				(void **) &szClientBuffer);
			PGPclCloseClientPrefs(clientPrefs, FALSE);

			if (IsntPGPError(PGPnetGetPrefsFullPath(szNetPrefFile, 255)))
			{
				err = PFLNewFileSpecFromFullPath(Config.memoryMgr, 
						szNetPrefFile, &netPrefFile);
				
				if (IsPGPError(err))
				{
					PGPclErrorBox(hwndMain, err);
					goto error;
				}
				
				err = PFLFileSpecCreate(netPrefFile);
				if (IsPGPError(err))
				{
					PFLFreeFileSpec(netPrefFile);
					PGPclErrorBox(hwndMain, err);
					goto error;
				}

				PGPOpenPrefFile(netPrefFile, NULL, 0, &netPrefs);
				PGPExportPrefFileToBuffer(netPrefs, &nNetBufferSize,
					(void **) &szNetBuffer);
				PGPClosePrefFile(netPrefs);
				PFLFreeFileSpec(netPrefFile);
			}
		}

		// Now create the client installer

		if (GetTempPath(MAX_PATH-1, szSetupIni))
		{
			char szLicNum[3];
			char szVersion[256];
			DWORD dwBytesRead;