kmprops.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1998 Network Associates, Inc.
	All rights reserved.
	
	KMProps.c - handle Key properties dialogs

	$Id: KMProps.c,v 1.100.2.1 1999/06/11 06:14:47 heller Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "pgpkmx.h"
#include "pgpclx.h"
#include "..\include\treelist.h"
#include "pgpHashWords.h"

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

// constant definitions
#define ENFORCELISTWIDTH	52

#define MAXSHEETS			16		// max number of simultaneous dialogs

#define MINSUBKEYSIZE		768
#define MAXSUBKEYSIZE		4096
#define DEFAULTSUBKEYSIZE	2048

#define SERIALIZE			1
#define NOSERIALIZE			0

#define AVI_TIMER			4321L
#define AVI_RUNTIME			11000L

#define NOTIFYTIMER			1111L
#define NOTIFYTIMEMS		100

#define NUMHASHWORDCOLS		4

// typedefs
typedef struct {
	PKEYMAN			pKM;
	WNDPROC			wpOrigPhotoIDProc;
	HIMAGELIST		hIml;
	PGPKeyRef		key;
	PGPKeySetRef	keyset;
	PGPUserIDRef	userid;
	PGPSigRef		cert;
	UINT			algKey;
	INT				iIndex;
	UINT			uTrust;
	UINT			uValidity;
	INT				iExpireDays;
	UINT			uNumberADKs;
	UINT			uNumberRevokers;
	PGPBoolean		bX509;
	PGPBoolean		bReadOnly;
	PGPBoolean		bShowHexFingerprint;
	PGPBoolean		bSecret;
	PGPBoolean		bSplit;
	PGPBoolean		bDisabled;
	PGPBoolean		bAxiomatic;
	PGPBoolean		bInvalid;
	PGPBoolean		bRevoked;
	PGPBoolean		bExpired;
	PGPBoolean		bPhotoInvalid;
	PGPBoolean		bKeyGenEnabled;
	BOOL			bReadyToPaint;
	BOOL			bNeedsCommit;
	HWND			hwndValidity;
	HWND			hwndStartDate;
	HWND			hwndExpireDate;
	HWND			hwndSubKeys;
	HWND			hwndADKs;
	HWND			hwndRevokers;
	HWND			hwndRevokerDlg;
	INT				iNumPhotoIDs;
	INT				iImageIndex;
	HBITMAP			hbitmapPhotoID;
	HPALETTE		hpalettePhotoID;
	INT				iwidthPhotoID;
	INT				iheightPhotoID;
	LPBYTE			pPhotoBuffer;
	PGPSize			iPhotoBufferLength;
	PGPUInt32		uMinSubkeySize;
} KMPROPSHEETSTRUCT;

typedef struct {
	FARPROC			lpfnCallback;
	PKEYMAN			pKM;
	BOOL			bCertProps;
} PROPSTRUCT;

typedef struct {
	PKEYMAN			pKM;
	PGPKeyRef		key;
	PGPSigRef		cert;
	PGPKeySetRef	keyset;
	PGPUserIDRef	userid;
} THREADSTRUCT;

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

typedef struct {
	KMPROPSHEETSTRUCT*	pkmpss;
	PSUBKEYSTRUCT		psks;
	LPSTR				pszPhrase;
	PGPByte*			pPasskey;
	PGPSize				sizePasskey;
	HWND				hwndProgress;
	BOOL				bCancelPending;
	BOOL				bGenDone;
	BOOL				bGenOK;
	BOOL				bAVIStarted;
	BOOL				bAVIFinished;
} SUBKEYGENSTRUCT, *PSUBKEYGENSTRUCT;

// external globals
extern HINSTANCE g_hInst;

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

static DWORD aKeyPropIds[] = {
	IDC_CHANGEPHRASE,		IDH_PGPKM_CHANGEPHRASE,	// this must be first item
	IDC_KEYID,				IDH_PGPKM_KEYID,
	IDC_KEYTYPE,			IDH_PGPKM_KEYTYPE,
	IDC_KEYSIZE,			IDH_PGPKM_KEYSIZE,
	IDC_CREATEDATE,			IDH_PGPKM_CREATEDATE,
	IDC_EXPIREDATE,			IDH_PGPKM_KEYEXPIRES,
	IDC_CIPHER,				IDH_PGPKM_CIPHER,
	IDC_HEXFINGERPRINT,		IDH_PGPKM_HEXFINGERPRINT,
	IDC_FINGERPRINT1,		IDH_PGPKM_FINGERPRINT,
	IDC_FINGERPRINT2,		IDH_PGPKM_FINGERPRINT,
	IDC_FINGERPRINT3,		IDH_PGPKM_FINGERPRINT,
	IDC_FINGERPRINT4,		IDH_PGPKM_FINGERPRINT,
	IDC_USEHEXFINGERPRINT,	IDH_PGPKM_DISPLAYHEXFINGERPRINT,
	IDC_ENABLED,			IDH_PGPKM_ENABLED,
	IDC_PHOTOID,			IDH_PGPKM_PHOTOID,
	IDC_VALIDITYBAR,		IDH_PGPKM_VALIDITYBAR,
	IDC_TRUSTSLIDER,		IDH_PGPKM_TRUSTSLIDER,
	IDC_AXIOMATIC,			IDH_PGPKM_AXIOMATIC,
    0,0 
}; 

static DWORD aNewSubkeyIds[] = {
	IDC_SUBKEYSIZE,		IDH_PGPKM_NEWSUBKEYSIZE,
	IDC_STARTDATE,		IDH_PGPKM_NEWSUBKEYSTARTDATE,
	IDC_NEVEREXPIRES,	IDH_PGPKM_NEWSUBKEYNEVEREXPIRES,
	IDC_EXPIRESON,		IDH_PGPKM_NEWSUBKEYEXPIRES,
	IDC_EXPIRATIONDATE,	IDH_PGPKM_NEWSUBKEYEXPIREDATE,
    0,0 
}; 

static DWORD aSubkeyIds[] = {
	IDC_SUBKEYLIST,		IDH_PGPKM_SUBKEYLIST,
	IDC_NEWSUBKEY,		IDH_PGPKM_SUBKEYCREATE,
	IDC_REVOKESUBKEY,	IDH_PGPKM_SUBKEYREVOKE,
	IDC_REMOVESUBKEY,	IDH_PGPKM_SUBKEYREMOVE,
    0,0 
}; 

static DWORD aADKIds[] = {
	IDC_FRAME,			IDH_PGPKM_ADKLIST,
	IDC_ADKTREELIST,	IDH_PGPKM_ADKLIST,
    0,0 
}; 

static DWORD aRevokerIds[] = {
	IDC_FRAME,			IDH_PGPKM_REVOKERLIST,
	IDC_REVOKERTREELIST,IDH_PGPKM_REVOKERLIST,
    0,0 
}; 

static DWORD aPGPcertIds[] = {
	IDC_NAME,			IDH_PGPKM_PGPCERTNAME,
	IDC_KEYID,			IDH_PGPKM_PGPCERTKEYID,
	IDC_CREATIONDATE,	IDH_PGPKM_PGPCERTCREATION,
	IDC_EXPIRATIONDATE,	IDH_PGPKM_PGPCERTEXPIRATION,
	IDC_EXPORTABLE,		IDH_PGPKM_PGPCERTEXPORTABLE,
	IDC_EXPIRED,		IDH_PGPKM_PGPCERTEXPIRED,
	IDC_REVOKED,		IDH_PGPKM_PGPCERTREVOKED,
	IDC_SHOWSIGNER,		IDH_PGPKM_PGPCERTSHOWSIGNER,
    0,0 
}; 

static DWORD aX509certIds[] = {
	IDC_NAME,			IDH_PGPKM_X509CERTNAME,
	IDC_ISSUER,			IDH_PGPKM_X509CERTISSUER,
	IDC_LASTCRL,		IDH_PGPKM_X509CERTLASTCRL,
	IDC_NEXTCRL,		IDH_PGPKM_X509CERTNEXTCRL,
	IDC_CREATIONDATE,	IDH_PGPKM_X509CERTCREATION,
	IDC_EXPIRATIONDATE,	IDH_PGPKM_X509CERTEXPIRATION,
	IDC_EXPORTABLE,		IDH_PGPKM_X509CERTEXPORTABLE,
	IDC_EXPIRED,		IDH_PGPKM_X509CERTEXPIRED,
	IDC_REVOKED,		IDH_PGPKM_X509CERTREVOKED,
	IDC_SHOWSIGNER,		IDH_PGPKM_X509CERTSHOWSIGNER,
    0,0 
}; 

// prototypes
static VOID 
sSingleKeyProperties (
		PKEYMAN			pKM,
		PGPKeyRef		key,
		PGPKeySetRef	keyset,
		PGPUserIDRef	userid,
		PBOOL			pbContinue);

static VOID 
sSingleCertProperties (
		PKEYMAN			pKM,
		PGPSigRef		cert,
		PGPKeyRef		key,
		PGPKeySetRef	keyset,
		PGPUserIDRef	userid,
		PBOOL			pbContinue);

//	___________________________________________________
//
//	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,
		 PGPKeyRef	key,
		 PGPUInt32	uAlg)
{
	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);

		PGPGetKeyPropertyBuffer (key, 
				kPGPKeyPropFingerprint, sizeof(sz), sz, &u);
		KMConvertStringFingerprint (uAlg, 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);

		PGPGetKeyPropertyBuffer (key, 
				kPGPKeyPropFingerprint, sizeof(sz1), sz1, &u);

		if (uAlg == kPGPPublicKeyAlgorithm_RSA) 
			uWordsTotal = 16;
		else
			uWordsTotal = 20;

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


//	____________________________________
//
//  display keygen AVI file in specified window

static VOID
sStartKeyGenAVI (HWND hwnd, LPSTR szHelpFile)
{
	CHAR	szFile[32];
	CHAR	szAnimationFile[MAX_PATH];
	LPSTR	p;

	lstrcpy (szAnimationFile, szHelpFile);

	p = strrchr (szAnimationFile, '\\');
	if (!p)
		p = szAnimationFile;
	else
		++p;
	*p = '\0';

	LoadString (g_hInst, IDS_ANIMATIONFILE, szFile, sizeof(szFile));
	lstrcat (szAnimationFile, szFile);

	Animate_Open (hwnd, szAnimationFile);
	Animate_Play (hwnd, 0, -1, -1);
}


//	______________________________________________
//
//  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;

	PGPBoolean		bFastGen;
	PGPPrefRef		prefref;
	PGPContextRef	ctx;
	UINT			uEntropyNeeded;
	PGPError		err;

	// get client preferences
	KMRequestSDKAccess (pskgs->pkmpss->pKM);
	PGPclOpenClientPrefs (
		PGPGetContextMemoryMgr (pskgs->pkmpss->pKM->Context), &prefref);
	PGPGetPrefBoolean (prefref, kPGPPrefFastKeyGen, &bFastGen);
	PGPclCloseClientPrefs (prefref, FALSE);

	// generate subkey
	ctx = pskgs->pkmpss->pKM->Context;
	uEntropyNeeded = PGPGetKeyEntropyNeeded (ctx,
			PGPOKeyGenParams (ctx, 
						kPGPPublicKeyAlgorithm_ElGamal, 
						pskgs->psks->uSize),
			PGPOKeyGenFast (ctx, bFastGen),
			PGPOLastOption (ctx));
	PGPclRandom (ctx, pskgs->hwndProgress, uEntropyNeeded);

	if (pskgs->pszPhrase) {
		err = PGPGenerateSubKey (
			ctx, &pskgs->psks->subkey,
			PGPOKeyGenMasterKey (ctx, pskgs->pkmpss->key),
			PGPOKeyGenParams (ctx, 
						kPGPPublicKeyAlgorithm_ElGamal, 
						pskgs->psks->uSize),
			PGPOKeyGenFast (ctx, bFastGen),
			PGPOPassphrase (ctx, pskgs->pszPhrase),
			PGPOCreationDate (ctx, pskgs->psks->timeStart),
			PGPOExpiration (ctx, pskgs->psks->iExpireDays),
			PGPOEventHandler (ctx, sSubkeyGenEventHandler, pskgs),
			PGPOLastOption (ctx));
	}
	else {
		err = PGPGenerateSubKey (
			ctx, &pskgs->psks->subkey,
			PGPOKeyGenMasterKey (ctx, pskgs->pkmpss->key),
			PGPOKeyGenParams (ctx, 
						kPGPPublicKeyAlgorithm_ElGamal, 
						pskgs->psks->uSize),
			PGPOKeyGenFast (ctx, bFastGen),
			PGPOPasskeyBuffer (ctx, pskgs->pPasskey, pskgs->sizePasskey),
			PGPOCreationDate (ctx, pskgs->psks->timeStart),
			PGPOExpiration (ctx, pskgs->psks->iExpireDays),
			PGPOEventHandler (ctx, sSubkeyGenEventHandler, pskgs),
			PGPOLastOption (ctx));
	}
	// note: PGPGenerateSubKey returns kPGPError_OutOfMemory 
	// when user aborts!
	if (err == kPGPError_OutOfMemory) 
		err = kPGPError_UserAbort;
	KMReleaseSDKAccess (pskgs->pkmpss->pKM);

	PGPclErrorBox (pskgs->hwndProgress, err);

	pskgs->bGenDone = TRUE;
	if (IsntPGPError (err))
		pskgs->bGenOK = TRUE;

	SendMessage (pskgs->hwndProgress, WM_CLOSE, 0, 0);