pkgenwiz.c

vc环境下的pgp源码

	return ulActualBits;
}


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

static BOOL
sStartKeyGenAVI (HWND hwnd)
{
	CHAR	szFile[32];
	CHAR	szAnimationFile[MAX_PATH];

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

	if (Animate_Open (hwnd, szAnimationFile))
	{
		Animate_Play (hwnd, 0, -1, -1);
		return TRUE;
	}
	else
		return FALSE;
}


//	____________________________________
//
//  Draw the "LED" progress indicator

static VOID
sInvalidateLEDs (
		HWND		hwnd,
		UINT		idc)
{
	RECT	rc;

	GetWindowRect (GetDlgItem (hwnd, idc), &rc);
	MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
	InvalidateRect (hwnd, &rc, FALSE);
}

//	____________________________________
//
//  Draw the "LED" progress indicator

static VOID
sDrawSendStatus (
		HWND		hwnd,
		PKEYGENINFO	pkgi) 
{
	HBRUSH			hBrushLit, hBrushUnlit, hBrushOld;
	HPEN			hPen, hPenOld;
	INT				i;
	INT				itop, ibot, ileft, iright, iwidth;
	RECT			rc;
	HDC				hdc;
	PAINTSTRUCT		ps;

	if (pkgi->iStatusValue < -1) return;

	hdc = BeginPaint (hwnd, &ps);

	// draw 3D shadow
	GetClientRect (hwnd, &rc);
	itop = rc.top+1;
	ibot = rc.bottom-2;

	iwidth = (rc.right-rc.left) / NUMLEDS;
	iwidth -= LEDSPACING;

	ileft = rc.left + 4;
	for (i=0; i<NUMLEDS; i++) 
	{
		iright = ileft + iwidth;

		MoveToEx (hdc, ileft, ibot, NULL);
		LineTo (hdc, iright, ibot);
		LineTo (hdc, iright, itop);

		ileft += iwidth + LEDSPACING;
	}

	hPen = CreatePen (PS_SOLID, 0, RGB (128, 128, 128));
	hPenOld = SelectObject (hdc, hPen);
	hBrushLit = CreateSolidBrush (RGB (0, 255, 0));
	hBrushUnlit = CreateSolidBrush (RGB (0, 128, 0));

	ileft = rc.left + 4;

	// draw "Knight Rider" LEDs
	if (pkgi->iStatusDirection) 
	{
		hBrushOld = SelectObject (hdc, hBrushUnlit);
		for (i=0; i<NUMLEDS; i++) 
		{
			iright = ileft + iwidth;
	
			if (i == pkgi->iStatusValue) 
			{
				SelectObject (hdc, hBrushLit);
				Rectangle (hdc, ileft, itop, iright, ibot);
				SelectObject (hdc, hBrushUnlit);
			}
			else
				Rectangle (hdc, ileft, itop, iright, ibot);
	
			ileft += iwidth + LEDSPACING;
		}
	}

	// draw "progress bar" LEDs
	else 
	{ 
		if (pkgi->iStatusValue >= 0) 
			hBrushOld = SelectObject (hdc, hBrushLit);
		else
			hBrushOld = SelectObject (hdc, hBrushUnlit);

		for (i=0; i<NUMLEDS; i++) 
		{
			iright = ileft + iwidth;
	
			if (i > pkgi->iStatusValue)
				SelectObject (hdc, hBrushUnlit);

			Rectangle (hdc, ileft, itop, iright, ibot);
	
			ileft += iwidth + LEDSPACING;
		}
	}

	SelectObject (hdc, hBrushOld);
	SelectObject (hdc, hPenOld);
	DeleteObject (hPen);
	DeleteObject (hBrushLit);
	DeleteObject (hBrushUnlit);

	EndPaint (hwnd, &ps);
}

//	____________________________________
//
//  find key with specified user id, if it exists

static VOID 
sGetOldKey (PGPContextRef	context, 
		   LPSTR			szUserID, 
		   PGPKeyRef*		pOldKey) 
{
	PGPFilterRef	filter		= kInvalidPGPFilterRef;
	PGPKeySetRef	KeySet		= kInvalidPGPKeySetRef;
	PGPKeyListRef	KeyList;
	PGPKeyIterRef	KeyIter;
	PGPKeyRef		Key;
	PGPBoolean		bSecret;
	PGPError		err;
	PGPUInt32		uAlg;

	*pOldKey = NULL;

	err	= PGPNewUserIDStringFilter (context, 
					szUserID, kPGPMatchEqual, &filter);
	if (IsPGPError (err)) 
		return;

	err	= PGPFilterKeySet (KeySetMain, filter, &KeySet);	
	PGPFreeFilter (filter);

	if (IsntPGPError (err) && PGPKeySetRefIsValid (KeySet))
	{
		err = PGPOrderKeySet (KeySet, kPGPCreationOrdering, &KeyList);
		if (IsntPGPError (err))
		{
			err = PGPNewKeyIter (KeyList, &KeyIter);
			if (IsntPGPError (err)) 
			{
				PGPKeyIterNext (KeyIter, &Key);
				while (PGPKeyRefIsValid (Key) && !*pOldKey) 
				{
					PGPGetKeyBoolean (Key, kPGPKeyPropIsSecret, &bSecret);
					if (bSecret) 
					{
						PGPGetKeyNumber (Key, kPGPKeyPropAlgID, &uAlg);
						if (uAlg == kPGPPublicKeyAlgorithm_RSA)
							*pOldKey = Key;
					}
					PGPKeyIterNext (KeyIter, &Key);
				}
				PGPFreeKeyIter (KeyIter);
			}
			PGPFreeKeyList (KeyList);
		}
		PGPFreeKeySet(KeySet);
	}
}


//	______________________________________________
//
//  create standard PGP userid from name and email address

static ULONG 
sCreatePGPUserID (
		LPSTR*	pszUserID, 
		LPSTR	szFullName, 
		LPSTR	szEmail)
{
	INT iReturnCode = kPGPError_NoErr;
	UINT uUserIDLen = 0;
	BOOL bEmail = FALSE;

	/*+4 is:  1 for the \0, one for the space, two for the broquets.*/
	uUserIDLen = lstrlen (szFullName) +1;
	if (lstrlen (szEmail)) 
	{
		bEmail = TRUE;
		uUserIDLen += lstrlen (szEmail) +3;
	}

	*pszUserID = pkAlloc (sizeof(char) * uUserIDLen);
	if (*pszUserID) 
	{
		if (bEmail)
			wsprintf (*pszUserID, "%s <%s>", szFullName, szEmail);
		else 
			lstrcpy (*pszUserID, szFullName);
	}
	else
		iReturnCode = kPGPError_OutOfMemory;

	return (iReturnCode);
}


//	______________________________________________
//
//  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 
sKeyGenCallback (
		PGPContextRef	context, 
		PGPEvent*		event,
		PGPUserValue	userValue)
{
	INT					iReturnCode = kPGPError_NoErr;
	UINT				uOriginalPhase;
	PKEYGENINFO			pkgi;
	PGPEventKeyGenData* pkgd;

	switch (event->type) {
	case kPGPEvent_KeyGenEvent:
		pkgd = &event->data.keyGenData;
		pkgi = (PKEYGENINFO) userValue;
		uOriginalPhase = pkgi->uWorkingPhase;

		if (!pkgi->bCancelPending) 
		{
			if (pkgd->state == ' ') 
			{
				if (pkgi->uWorkingPhase == IDS_KEYGENPHASE1)
					pkgi->uWorkingPhase = IDS_KEYGENPHASE2;
				else
					pkgi->uWorkingPhase = IDS_KEYGENPHASE1;
			}
			if (uOriginalPhase != pkgi->uWorkingPhase)
				PostMessage (pkgi->hWndWiz, 
							KM_M_CHANGEPHASE, 
							0, (LPARAM) pkgi->uWorkingPhase);
		}
		else //Let the sdk know we're canceling
			iReturnCode = kPGPError_UnknownError;
	}	
	
	return (iReturnCode);
}


//	______________________________________________
//
//  thread for actually creating key

static VOID 
sKeyGenerationThread (void *pArgs)
{
	PKEYGENINFO			pkgi			= NULL;
	BOOL				bNewDefaultKey	= TRUE;
	PGPUInt32			AlgFlags		= 0;
	PGPSize				prefDataSize	= 0;
	PGPKeySetRef		keysetADK		= kInvalidPGPKeySetRef;
	PGPKeySetRef		keysetRevoker	= kInvalidPGPKeySetRef;
	PGPOptionListRef	optionlist		= kInvalidPGPOptionListRef;
	PGPCipherAlgorithm*	pAlgs			= NULL;

	PGPKeyRef			keyDefault;
	PGPSubKeyRef		subkey;
	PGPUserIDRef		useridCorp;
	PGPBoolean			bFastGen;
	PGPContextRef		ctx;
	PGPByte				enforce;
	PGPError			err;
	INT					iTrustLevel;
	PGPUInt32			numAlgs;

	pkgi = (PKEYGENINFO) pArgs;
	ctx = pkgi->Context;

	PGPGetDefaultPrivateKey (KeySetMain, &keyDefault);
	if (PGPRefIsValid (keyDefault)) 
		bNewDefaultKey = FALSE;

	// construct userid and check for existing key with same userid
	err = sCreatePGPUserID (&pkgi->pszUserID, pkgi->pszFullName, 
											pkgi->pszEmail); CKERR;

	if (pkgi->uKeyType == kPGPPublicKeyAlgorithm_DSA)
		sGetOldKey (ctx, pkgi->pszUserID, &pkgi->OldKey);

	// get client preferences
	PGPGetPrefBoolean (pkgi->PrefRefClient, kPGPPrefFastKeyGen, &bFastGen);
	PGPGetPrefData (pkgi->PrefRefClient, kPGPPrefAllowedAlgorithmsList,
							  &prefDataSize, &pAlgs);

	// build list of common options
	numAlgs	= prefDataSize / sizeof(PGPCipherAlgorithm);
	err = PGPBuildOptionList (ctx, &optionlist,
			PGPOKeySetRef (ctx, KeySetMain),
			PGPOKeyGenParams (ctx, pkgi->uKeyType, pkgi->uKeySize),
			PGPOKeyGenFast (ctx, bFastGen),
			PGPOKeyGenName (ctx, pkgi->pszUserID, lstrlen (pkgi->pszUserID)),
			PGPOPassphrase (ctx, pkgi->pszPassPhrase),
			PGPOExpiration (ctx, pkgi->uExpireDays),
			PGPOPreferredAlgorithms (ctx, pAlgs, numAlgs),
			PGPOEventHandler (ctx, sKeyGenCallback, pkgi),
			PGPOLastOption (ctx)); CKERR;

	// add ADK option
	if (PGPKeyRefIsValid (pkgi->ADK)) 
	{
		if (pkgi->bEnforceADK) enforce = 0x80;
		else enforce = 0x00;
		err = PGPNewSingletonKeySet (pkgi->ADK, &keysetADK); CKERR;
		err = PGPAppendOptionList (optionlist,
			PGPOAdditionalRecipientRequestKeySet (ctx, keysetADK, enforce),
			PGPOLastOption (ctx)); CKERR;
	}

	// add revoker key option
	if ((PGPKeyRefIsValid (pkgi->RevokerKey)) &&
		(pkgi->uKeyType != kPGPPublicKeyAlgorithm_RSA)) 
	{
		err = PGPNewSingletonKeySet (pkgi->RevokerKey, &keysetRevoker); CKERR;
		err = PGPAppendOptionList (optionlist,
				PGPORevocationKeySet (ctx, keysetRevoker),
				PGPOLastOption (ctx)); CKERR;
	}

	// generate key using specified options
	err = PGPGenerateKey (ctx, &(pkgi->Key), 
							optionlist,
							PGPOLastOption (ctx)); 

	// note: PGPGenerateKey returns kPGPError_OutOfMemory when user aborts!
	if (err == kPGPError_OutOfMemory) 
		err = kPGPError_UserAbort;
	CKERR;

	if (pkgi->uKeyType == kPGPPublicKeyAlgorithm_DSA) 
	{
		err = PGPGenerateSubKey (
			ctx, &subkey,
			PGPOKeyGenMasterKey (ctx, pkgi->Key),
			PGPOKeyGenParams (ctx, kPGPPublicKeyAlgorithm_ElGamal, 
										pkgi->uSubKeySize),
			PGPOKeyGenFast (ctx, bFastGen),
			PGPOPassphrase (ctx, pkgi->pszPassPhrase),
			PGPOExpiration (ctx, pkgi->uExpireDays),
			PGPOEventHandler (ctx, sKeyGenCallback, pkgi),
			PGPOLastOption (ctx));

			// note: PGPGenerateSubKey returns kPGPError_OutOfMemory 
			// when user aborts!
			if (err == kPGPError_OutOfMemory) 
				err = kPGPError_UserAbort;
	}

	if (IsntPGPError (err) && !pkgi->bCancelPending) 
	{
		// sign and trust corporate key
		if (PGPKeyRefIsValid (pkgi->CorpKey)) 
		{
			err = PGPGetPrimaryUserID (pkgi->CorpKey, &useridCorp);
			if (IsntPGPError (err)) 
			{
				if (pkgi->bMetaCorpKey) iTrustLevel = 2;
				else iTrustLevel = 0;

				// make sure we have enough entropy
				PGPclRandom (ctx, pkgi->hWndWiz, 0);

				err = PGPSignUserID (useridCorp, pkgi->Key, 
					PGPOPassphrase (ctx, pkgi->pszPassPhrase),
					PGPOExpiration (ctx, 0),
					PGPOExportable (ctx, FALSE),
					PGPOSigTrust (ctx, iTrustLevel, kPGPKeyTrust_Complete),
					PGPOLastOption (ctx));
				if (IsntPGPError (err)) 
				{
					err = PGPSetKeyTrust (pkgi->CorpKey, 
											kPGPKeyTrust_Complete);
					// ignore errors here.  If key is axiomatic, 
					// setting trust will cause an error.
					err = kPGPError_NoErr; 
				}
			}
		}

		// commit everything now so if there is a problem
		// during keyserver stuff, at least the key is saved
		if (IsntPGPError (PGPclErrorBox (pkgi->hWndWiz, err))) 
		{
			err = PGPCommitKeyRingChanges (KeySetMain);
			PGPclErrorBox (pkgi->hWndWiz, err);
			pkgi->iFinalResult = KCD_NEWKEY;
			if (bNewDefaultKey)
				pkgi->iFinalResult |= KCD_NEWDEFKEY;
		}
	}

done :
	if (IsntNull (pAlgs))
		PGPDisposePrefData (pkgi->PrefRefClient, pAlgs);
	if (PGPKeySetRefIsValid (keysetADK))
		PGPFreeKeySet (keysetADK);
	if (PGPKeySetRefIsValid (keysetRevoker))
		PGPFreeKeySet (keysetRevoker);
	if (PGPOptionListRefIsValid (optionlist))
		PGPFreeOptionList (optionlist);

	pkgi->bInGeneration = FALSE;

	PGPclErrorBox (pkgi->hWndWiz, err);

	if (pkgi->bCancelPending)
		PropSheet_PressButton (GetParent (pkgi->hWndWiz), PSBTN_CANCEL);
	else 
		PostMessage (pkgi->hWndWiz, KM_M_GENERATION_COMPLETE, 0, 0);
}


//	______________________________________________
//
//  Check if message is dangerous to pass to passphrase edit box

static BOOL 
sWizCommonNewKeyPhraseMsgProc (
		HWND	hWnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	switch (uMsg) {
	case WM_RBUTTONDOWN :
	case WM_LBUTTONDBLCLK :
	case WM_MOUSEMOVE :
	case WM_COPY :
	case WM_CUT :
	case WM_PASTE :
	case WM_CLEAR :
	case WM_CONTEXTMENU :
		return TRUE;

	case WM_LBUTTONDOWN :
		if (GetKeyState (VK_SHIFT) & 0x8000) return TRUE;
		break;

	case WM_PAINT :
		if (wParam) 
		{
			SetBkColor ((HDC)wParam, GetSysColor (COLOR_WINDOW));
			if (bHideTyping) 
				SetTextColor ((HDC)wParam, GetSysColor (COLOR_WINDOW));
			else 
				SetTextColor ((HDC)wParam, GetSysColor (COLOR_WINDOWTEXT));
		}
		break; 

	case WM_KEYDOWN :
		if (GetKeyState (VK_SHIFT) & 0x8000) 
		{
			switch (wParam) {
				case VK_HOME :
				case VK_END :
				case VK_UP :
				case VK_DOWN :
				case VK_LEFT :
				case VK_RIGHT :
				case VK_NEXT :
				case VK_PRIOR :
					return TRUE;
			}
		}
		break;

	case WM_SETFOCUS :
		SendMessage (hWnd, EM_SETSEL, 0xFFFF, 0xFFFF);
		break;

	case WM_KILLFOCUS :
		break;
	}
	return FALSE; 
} 


//	______________________________________________
//
//  New passphrase 1 edit box subclass procedure

static LRESULT APIENTRY 
sWizPhrase1SubclassProc (
		HWND	hWnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	UINT				uQuality;
	CHAR				szBuf[256];
	LRESULT				lResult;

	if (sWizCommonNewKeyPhraseMsgProc (hWnd, uMsg, wParam, lParam)) 
		return 0;