clprops.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 2,600 行 · 第 1/5 页

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
	
	CLprops.c - handle Key properties dialogs

	$Id: CLprops.c,v 1.57 2002/10/31 04:13:35 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "PGPclx.h"
#include "TreeList.h"
#include "pgpImageList.h"
#include "pgpHashWords.h"
#include "UTF8Edit.h"

// system header files
#include <process.h>

// constant definitions
#define ENFORCELISTWIDTH	52

#define MAXSHEETS			16		// max number of simultaneous dialogs

#define MINSUBKEYSIZE		1024
#define MAXSUBKEYSIZE		4096
#define DEFAULTSUBKEYSIZE	2048
#define ECSUBKEYSIZE		283

#define PROGRESS_TIMER		5432L
#define PROGRESS_TIMER_MS	100
#define NUMLEDS				10
#define LEDSPACING			2

#define NOTIFYTIMER			1111L
#define NOTIFYTIMEMS		100

#define NUMHASHWORDCOLS		4

#define TREELISTOFFSET		8

// external globals
extern HINSTANCE	g_hInst;
extern HIMAGELIST	g_hilKeys;
extern BOOL			g_bUnicodeOS;
// typedefs
typedef struct {
	PGPContextRef		context;
	PGPtlsContextRef	tlscontext;
	HWND				hwndParent;
	WNDPROC				wpOrigProcPhoto;
	WNDPROC				wpOrigProcBox;
	PGPKeyDBObjRef		key;
	PGPKeyDBObjRef		userid;
	PGPKeyDBObjRef		cert;
	PGPKeyDBRef			keydbBacking;
	PGPKeyDBRef			keydbAlt;

	PGPInt32			iValidityThreshold;
	PGPBoolean			bReadOnly;
	PGPBoolean			bNeedsCentering;
	PGPBoolean			bSubkeyOpsDisabled;
	PGPBoolean			bSubkeyGenEnabled;

	PGPUInt32			uKeyAlg;
	PGPUInt32			uKeyVer;
	PGPUInt32			uTrust;
	PGPUInt32			uValidity;
	PGPInt32			iExpireDays;
	PGPUInt32			uNumberADKs;
	PGPUInt32			uNumberRevokers;

	PGPBoolean			bSecret;
	PGPBoolean			bSplit;
	PGPBoolean			bDisabled;
	PGPBoolean			bAxiomatic;
	PGPBoolean			bOnToken;
	PGPBoolean			bInvalid;
	PGPBoolean			bRevoked;
	PGPBoolean			bExpired;
	PGPBoolean			bPhotoInvalid;
	PGPBoolean			bX509;
	PGPBoolean			bShowHexFingerprint;
	PGPBoolean			bReadyToPaint;

	HWND				hwndValidity;
	HWND				hwndStartDate;
	HWND				hwndExpireDate;
	HWND				hwndSubKeys;
	HWND				hwndADKs;
	HWND				hwndRevokers;
	HWND				hwndRevokerDlg;

	HTLITEM				hTSelectedADK;
	HTLITEM				hTSelectedRevoker;

	PGPInt32			iNumPhotoIDs;
	PGPInt32			iImageIndex;
	HBITMAP				hbitmapPhotoID;
	HPALETTE			hpalettePhotoID;
	PGPInt32			iwidthPhotoID;
	PGPInt32			iheightPhotoID;
	PGPByte*			pPhotoBuffer;
	PGPSize				iPhotoBufferLength;

} CLPROPSHEETSTRUCT, *PCLPROPSHEETSTRUCT;

typedef struct {
	PGPKeyDBObjRef		subkey;
	PGPTime				timeStart;
	INT					iExpireDays;
	BOOL				bNeverExpires;
	UINT				uSize;
} SUBKEYSTRUCT, *PSUBKEYSTRUCT;

typedef struct {
	PCLPROPSHEETSTRUCT	pclpss;
	PSUBKEYSTRUCT		psks;
	PGPError			err;
	LPSTR				pszPhrase;
	PGPByte*			pPasskey;
	PGPSize				sizePasskey;
	HWND				hwndProgress;
	BOOL				bCancelPending;
	BOOL				bGenDone;
	BOOL				bGenOK;
	INT					iStatusValue;
	INT					iStatusDirection;
} SUBKEYGENSTRUCT, *PSUBKEYGENSTRUCT;

// local globals
static UINT uSubkeySizes[] = {1024, 1536, 2048, 3072};

static DWORD aKeyPropIds[] = {
	IDC_CHANGEPHRASE,		IDH_PGPCL_CHANGEPHRASE,	// this must be first item
	IDC_KEYID,				IDH_PGPCL_KEYID,
	IDC_KEYTYPE,			IDH_PGPCL_KEYTYPE,
	IDC_KEYSIZE,			IDH_PGPCL_KEYSIZE,
	IDC_CREATEDATE,			IDH_PGPCL_CREATEDATE,
	IDC_EXPIREDATE,			IDH_PGPCL_KEYEXPIRES,
	IDC_CIPHER,				IDH_PGPCL_CIPHER,
	IDC_HEXFINGERPRINT,		IDH_PGPCL_HEXFINGERPRINT,
	IDC_FINGERPRINT1,		IDH_PGPCL_FINGERPRINT,
	IDC_FINGERPRINT2,		IDH_PGPCL_FINGERPRINT,
	IDC_FINGERPRINT3,		IDH_PGPCL_FINGERPRINT,
	IDC_FINGERPRINT4,		IDH_PGPCL_FINGERPRINT,
	IDC_USEHEXFINGERPRINT,	IDH_PGPCL_DISPLAYHEXFINGERPRINT,
	IDC_ENABLED,			IDH_PGPCL_ENABLED,
	IDC_ONTOKEN,			IDH_PGPCL_ONTOKEN,
	IDC_PHOTOID,			IDH_PGPCL_PHOTOID,
	IDC_VALIDITYBAR,		IDH_PGPCL_VALIDITYBAR,
	IDC_TRUSTSLIDER,		IDH_PGPCL_TRUSTSLIDER,
	IDC_AXIOMATIC,			IDH_PGPCL_AXIOMATIC,
	0,0 
}; 

static DWORD aNewSubkeyIds[] = {
	IDC_SUBKEYSIZE,		IDH_PGPCL_NEWSUBKEYSIZE,
	IDC_STARTDATE,		IDH_PGPCL_NEWSUBKEYSTARTDATE,
	IDC_NEVEREXPIRES,	IDH_PGPCL_NEWSUBKEYNEVEREXPIRES,
	IDC_EXPIRESON,		IDH_PGPCL_NEWSUBKEYEXPIRES,
	IDC_EXPIRATIONDATE,	IDH_PGPCL_NEWSUBKEYEXPIREDATE,
	0,0 
}; 

static DWORD aSubkeyIds[] = {
	IDC_SUBKEYLIST,		IDH_PGPCL_SUBKEYLIST,
	IDC_NEWSUBKEY,		IDH_PGPCL_SUBKEYCREATE,
	IDC_REVOKESUBKEY,	IDH_PGPCL_SUBKEYREVOKE,
	IDC_REMOVESUBKEY,	IDH_PGPCL_SUBKEYREMOVE,
	IDC_STATICTEXT1,	-1,
	IDC_STATICTEXT2,	-1,
	0,0 
}; 

static DWORD aADKIds[] = {
	IDC_FRAME,			IDH_PGPCL_ADKLIST,
	IDC_ADKTREELIST,	IDH_PGPCL_ADKLIST,
	IDC_UPDATE,			IDH_PGPCL_UPDATEADK,
	0,0 
}; 

static DWORD aRevokerIds[] = {
	IDC_FRAME,			IDH_PGPCL_REVOKERLIST,
	IDC_REVOKERTREELIST,IDH_PGPCL_REVOKERLIST,
	IDC_UPDATE,			IDH_PGPCL_UPDATEREVOKER,
	0,0 
}; 

static DWORD aPGPcertIds[] = {
	IDC_NAME,			IDH_PGPCL_PGPCERTNAME,
	IDC_KEYID,			IDH_PGPCL_PGPCERTKEYID,
	IDC_CREATIONDATE,	IDH_PGPCL_PGPCERTCREATION,
	IDC_EXPIRATIONDATE,	IDH_PGPCL_PGPCERTEXPIRATION,
	IDC_EXPORTABLE,		IDH_PGPCL_PGPCERTEXPORTABLE,
	IDC_EXPIRED,		IDH_PGPCL_PGPCERTEXPIRED,
	IDC_REVOKED,		IDH_PGPCL_PGPCERTREVOKED,
	IDC_SHOWSIGNER,		IDH_PGPCL_PGPCERTSHOWSIGNER,
	IDC_DOMAIN,			IDH_PGPCL_PGPCERTDOMAIN,
	IDC_ICONFRAME,		-1,
	0,0 
}; 

static DWORD aX509certIds[] = {
	IDC_NAME,			IDH_PGPCL_X509CERTNAME,
	IDC_ISSUER,			IDH_PGPCL_X509CERTISSUER,
	IDC_LASTCRL,		IDH_PGPCL_X509CERTLASTCRL,
	IDC_NEXTCRL,		IDH_PGPCL_X509CERTNEXTCRL,
	IDC_CREATIONDATE,	IDH_PGPCL_X509CERTCREATION,
	IDC_EXPIRATIONDATE,	IDH_PGPCL_X509CERTEXPIRATION,
	IDC_EXPORTABLE,		IDH_PGPCL_X509CERTEXPORTABLE,
	IDC_EXPIRED,		IDH_PGPCL_X509CERTEXPIRED,
	IDC_REVOKED,		IDH_PGPCL_X509CERTREVOKED,
	IDC_SHOWSIGNER,		IDH_PGPCL_X509CERTSHOWSIGNER,
	IDC_ICONFRAME,		-1,
	0,0 
}; 

//	___________________________________________________
//
//	copy the appropriate hash word to the string buffer

static VOID
sGetHashWord (
		PGPByte		bIndex,
		PGPBoolean	bEven,
		LPSTR		psz)
{
	if (bEven)
		lstrcpy (psz, &hashWordListEven[bIndex][0]);
	else
		lstrcpy (psz, &hashWordListOdd[bIndex][0]);
}

//	___________________________________________________
//
//	set the fingerprint controls on basis of "usehex" flag

static VOID
sSetFingerprintControls (
		 HWND			hwnd,
		 PGPBoolean		bUseHex,
		 PGPKeyDBObjRef	key,
		 PGPUInt32		uKeyVer)
{
	UINT		u, uWordsTotal;
	PGPBoolean	bEven;
	CHAR		sz[64];
	CHAR		sz1[64];
	CHAR		sz2[256];

	if (bUseHex) 
	{
		ShowWindow (GetDlgItem (hwnd, IDC_HEXFINGERPRINT), TRUE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT1), FALSE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT2), FALSE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT3), FALSE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT4), FALSE);

		PGPGetKeyDBObjDataProperty (key, 
				kPGPKeyProperty_Fingerprint, sz, sizeof(sz), &u);
		PGPclConvertFingerprintToString (uKeyVer, sz);
		SetDlgItemText (hwnd, IDC_HEXFINGERPRINT, sz);
	}
	else 
	{
		ShowWindow (GetDlgItem (hwnd, IDC_HEXFINGERPRINT), FALSE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT1), TRUE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT2), TRUE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT3), TRUE);
		ShowWindow (GetDlgItem (hwnd, IDC_FINGERPRINT4), TRUE);

		PGPGetKeyDBObjDataProperty (key, 
				kPGPKeyProperty_Fingerprint, sz1, sizeof(sz1), &u);

		if (uKeyVer > kPGPKeyVersion_V3) 
			uWordsTotal = 20;
		else
			uWordsTotal = 16;

		sz2[0] = '\0';
		bEven = TRUE;
		for (u=0; u<uWordsTotal; u+=NUMHASHWORDCOLS) 
		{
			sGetHashWord (sz1[u], bEven, sz);
			lstrcat (sz2, sz);
			lstrcat (sz2, "\n");
		}
		SetDlgItemText (hwnd, IDC_FINGERPRINT1, sz2);

		sz2[0] = '\0';
		bEven = !bEven;
		for (u=1; u<uWordsTotal; u+=NUMHASHWORDCOLS) 
		{
			sGetHashWord (sz1[u], bEven, sz);
			lstrcat (sz2, sz);
			lstrcat (sz2, "\n");
		}
		SetDlgItemText (hwnd, IDC_FINGERPRINT2, sz2);

		sz2[0] = '\0';
		bEven = !bEven;
		for (u=2; u<uWordsTotal; u+=NUMHASHWORDCOLS) 
		{
			sGetHashWord (sz1[u], bEven, sz);
			lstrcat (sz2, sz);
			lstrcat (sz2, "\n");
		}
		SetDlgItemText (hwnd, IDC_FINGERPRINT3, sz2);

		sz2[0] = '\0';
		bEven = !bEven;
		for (u=3; u<uWordsTotal; u+=NUMHASHWORDCOLS) 
		{
			sGetHashWord (sz1[u], bEven, sz);
			lstrcat (sz2, sz);
			lstrcat (sz2, "\n");
		}
		SetDlgItemText (hwnd, IDC_FINGERPRINT4, sz2);
	}
}

//	___________________________________________________
//
//	convert SYSTEMTIME structure to number of days from today

static PGPError
sSystemTimeToPGPTime (
		 SYSTEMTIME*	pst, 
		 PGPTime*		ptime) 
{
	struct tm	tmstruct;
	time_t		timeStd;

	pgpAssert (pst != NULL);
	pgpAssert (ptime != NULL);

	*ptime = 0;

	if (pst->wYear > 2037) 
		return kPGPError_BadParams;

	tmstruct.tm_mday = pst->wDay;
	tmstruct.tm_mon = pst->wMonth -1;
	tmstruct.tm_year = pst->wYear -1900;
	tmstruct.tm_hour = 0;
	tmstruct.tm_min = 0;
	tmstruct.tm_sec = 0;
	tmstruct.tm_isdst = -1;

	timeStd = mktime (&tmstruct);
	if (timeStd == (time_t)-1) return kPGPError_BadParams;

	*ptime = PGPGetPGPTimeFromStdTime (timeStd);

	return kPGPError_NoErr;
}


//	_____________________________________________________
//
//  attempt to update keyid from server

static BOOL 
sUpdateKeyIDFromServer (
		HWND				hwnd,
		PCLPROPSHEETSTRUCT	pclpss,
		PGPKeyID*			pkeyid)
{
	BOOL			bUpdated		= FALSE;
	PGPKeyDBRef		keydb			= kInvalidPGPKeyDBRef;
	PGPUInt32		uCount;
	PGPError		err;

	SendMessage (pclpss->hwndParent, PGPCL_M_PROPERTYMESSAGE, 
			kPGPclProperties_EnableWindows, (LPARAM)FALSE);

	err = PGPclSearchServerForKeyIDs (
			pclpss->context, pclpss->tlscontext, 
			hwnd, pkeyid, 1, kPGPclDefaultServer, 
			pclpss->keydbBacking, &keydb);

	if (IsntPGPError (err))
	{
		if (PGPKeyDBRefIsValid (keydb)) 
		{
			PGPCountKeys (PGPPeekKeyDBRootKeySet (keydb), &uCount);
			if (uCount > 0)
			{
				err = PGPCopyKeys (PGPPeekKeyDBRootKeySet (keydb), 
						pclpss->keydbBacking, NULL);

				if (IsntPGPError (err))
				{
					bUpdated = TRUE;

					SendMessage (pclpss->hwndParent, 
							PGPCL_M_PROPERTYMESSAGE, 
							kPGPclProperties_UpdateKeyring, 0);
				}
			}
			PGPFreeKeyDB (keydb);
		}
	}

	SendMessage (pclpss->hwndParent, PGPCL_M_PROPERTYMESSAGE, 
			kPGPclProperties_EnableWindows, (LPARAM)TRUE);

	return bUpdated;
}


//	______________________________________________
//
//  callback routine called by library key generation routine
//  every so often with status of keygen.  Returning a nonzero
//  value cancels the key generation.

static PGPError 
sSubkeyGenEventHandler (
		PGPContextRef	context, 
		PGPEvent*		event,
		PGPUserValue	userValue)
{
	INT					iReturnCode = kPGPError_NoErr;
	PSUBKEYGENSTRUCT	pskgs;

	pskgs = (PSUBKEYGENSTRUCT) userValue;

	if (pskgs->bCancelPending) 
		iReturnCode = kPGPError_UserAbort;
	
	return (iReturnCode);
}


//	___________________________________________________
//
//  subkey generation thread

static VOID 
sSubkeyGenerationThread (void *pArgs)
{
	PSUBKEYGENSTRUCT	pskgs			= (PSUBKEYGENSTRUCT)pArgs;
	BOOL				bRetVal			= FALSE;
	PGPPrefRef			prefref			= kInvalidPGPPrefRef;
	UINT				uSubKeyAlg		= 0;

	PGPBoolean			bFastGen;
	PGPContextRef		ctx;
	UINT				uEntropyNeeded;

	if (pskgs->pclpss->uKeyAlg == kPGPPublicKeyAlgorithm_DSA)
		uSubKeyAlg = kPGPPublicKeyAlgorithm_ElGamal;
	else if (pskgs->pclpss->uKeyAlg == kPGPPublicKeyAlgorithm_ECSign)
		uSubKeyAlg = kPGPPublicKeyAlgorithm_ECEncrypt;
	else
		uSubKeyAlg = kPGPPublicKeyAlgorithm_RSA;

	// get client preferences
	pskgs->err = PGPclPeekClientLibPrefRefs (&prefref, NULL);
	if (IsntPGPError (pskgs->err))
	{
		ctx = pskgs->pclpss->context;
		PGPGetPrefBoolean (prefref, kPGPPrefFastKeyGen, &bFastGen);

		uEntropyNeeded = PGPGetKeyEntropyNeeded (ctx,	
				PGPOKeyGenParams (ctx, uSubKeyAlg, pskgs->psks->uSize),
				PGPOKeyFlags (ctx, kPGPKeyPropertyFlags_UsageEncrypt),
				PGPOKeyGenFast (ctx, bFastGen),
				PGPOLastOption (ctx));
		PGPclRandom (ctx, pskgs->hwndProgress, uEntropyNeeded);

		// generate subkey
		if (pskgs->pszPhrase) 
		{
			pskgs->err = PGPGenerateSubKey (
				ctx, &pskgs->psks->subkey,
				PGPOKeyGenMasterKey (ctx, pskgs->pclpss->key),
				PGPOKeyGenParams (ctx, uSubKeyAlg, pskgs->psks->uSize),
				PGPOKeyFlags (ctx, kPGPKeyPropertyFlags_UsageEncrypt),
				PGPOKeyGenFast (ctx, bFastGen),
				PGPOPassphrase (ctx, pskgs->pszPhrase),
				PGPOCreationDate (ctx, pskgs->psks->timeStart),
				PGPOExpiration (ctx, pskgs->psks->iExpireDays),
				PGPOEventHandler (ctx, sSubkeyGenEventHandler, pskgs),
				pskgs->pclpss->bOnToken ? 
					PGPOKeyGenOnToken (ctx, 0) :
					PGPONullOption (ctx),
				PGPOLastOption (ctx));
		}
		else 
		{
			pskgs->err = PGPGenerateSubKey (
				ctx, &pskgs->psks->subkey,
				PGPOKeyGenMasterKey (ctx, pskgs->pclpss->key),
				PGPOKeyGenParams (ctx, uSubKeyAlg, pskgs->psks->uSize),
				PGPOKeyFlags (ctx, kPGPKeyPropertyFlags_UsageEncrypt),
				PGPOKeyGenFast (ctx, bFastGen),
				PGPOPasskeyBuffer (ctx, pskgs->pPasskey, pskgs->sizePasskey),
				PGPOCreationDate (ctx, pskgs->psks->timeStart),
				PGPOExpiration (ctx, pskgs->psks->iExpireDays),
				PGPOEventHandler (ctx, sSubkeyGenEventHandler, pskgs),
				pskgs->pclpss->bOnToken ? 
					PGPOKeyGenOnToken (ctx, 0) :
					PGPONullOption (ctx),
				PGPOLastOption (ctx));
		}

		// note: PGPGenerateSubKey returns kPGPError_OutOfMemory 
		// when user aborts!
		if ((pskgs->err == kPGPError_OutOfMemory) ||
			(pskgs->bCancelPending))
		{
			pskgs->err = kPGPError_UserAbort;
		}
	}

	pskgs->bGenDone = TRUE;