pktoken.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
	
	PKToken.c - GUI routines for smart card support
	
	$Id: PKToken.c,v 1.18 2002/08/06 20:09:46 dallen Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"	/* or pgpConfig.h in the CDK */

// project header files
#include "PGPkeysx.h"

// typedefs
typedef struct {
	PGPKEYSSTRUCT*		ppks;
	HWND				hwndParent;
	BOOL				bNeedsCentering;
	BOOL				bModified;
	PGPContextRef		context;
	PGPtlsContextRef	tlscontext;
	PGPKeySetRef		keysetToDisplay;
	HKEYLIST			hKL;
	PGPclKeyListConfig	klConfig;
	HWND				hwndTree;
	UINT				uFlags;
} TOKENDLGSTRUCT;


// external global variables
extern HINSTANCE		g_hinst;
extern PGPContextRef	g_context;
extern PGPtlsContextRef	g_tlscontext;

#define IDC_TOKENKEYLIST		0x0101
#define YOFFSET					6

static	HWND	s_hwndProperties	= NULL;
static	HWND	s_hwndContents		= NULL;

static DWORD aTokenIds[] = {			// Help IDs
	IDC_MANUFACTURER,		IDH_PGPPKTOKEN_MANUFACTURER,
	IDC_MODEL,				IDH_PGPPKTOKEN_MODEL,
	IDC_SERIAL,				IDH_PGPPKTOKEN_SERIALNUMBER,
	IDC_KEYSUPPORT,			IDH_PGPPKTOKEN_KEYSUPPORT,
	IDC_PINLENGTH,			IDH_PGPPKTOKEN_PINLENGTH,
	IDC_NUMPRIVKEYS,		IDH_PGPPKTOKEN_NUMPRIVKEYS,
	IDC_TOKENKEYLIST,		IDH_PGPPKTOKEN_CONTENTSKEYS,
	IDC_WIPETOKEN,			IDH_PGPPKTOKEN_WIPECONTENTS,
	0,0
};


// prototypes
PGPError PGPFormatToken ( 
		PGPContextRef	context, 
		PGPUInt32		tokNumber,
		PGPByte const * adminPin, 
		PGPSize			adminPinLen, 
		PGPByte const * newUserPin, 
		PGPSize			newUserPinLen);


//	____________________________________
//
//  Look for keys on token

PGPBoolean 
sGetKeysOnToken (
		PGPKeyDBRef		keydb,
		PGPKeySetRef*	pkeyset) 
{
	PGPKeyIterRef	keyiter;
	PGPKeyDBObjRef	key;
	PGPBoolean		b, bOnToken;

	if (IsntNull (pkeyset))
		PGPNewEmptyKeySet (keydb, pkeyset);

	PGPNewKeyIterFromKeySet (PGPPeekKeyDBRootKeySet (keydb), &keyiter);

	bOnToken = FALSE;
	PGPKeyIterNextKeyDBObj (keyiter, kPGPKeyDBObjType_Key, &key);

	while (key) 
	{
		PGPGetKeyDBObjBooleanProperty (key, 
				kPGPKeyProperty_IsOnToken, &b);

		if (b)
		{
			bOnToken = TRUE;
			if (IsntNull (pkeyset))
				PGPAddKey (key, *pkeyset);
			else
				break;
		}

		PGPKeyIterNextKeyDBObj (keyiter, kPGPKeyDBObjType_Key, &key);
	}

	PGPFreeKeyIter (keyiter);

	return bOnToken;
}


//	___________________________________________________
//
//  query user then wipe token

static PGPError
sWipeToken (
		HWND			hwnd,
		PGPKEYSSTRUCT*	ppks)
{
	PGPError	err				= kPGPError_UserAbort;
	CHAR*		pszPhrase		= NULL;
	CHAR*		pszAdminPhrase	= NULL;
	HCURSOR		hcursorOld;
	CHAR		sz[128];

	if (PKMessageBox (hwnd, IDS_CAPTIONWARNING, 
			IDS_CONFIRMWIPETOKEN, MB_OKCANCEL|MB_ICONWARNING) == IDOK)
	{
		LoadString (g_hinst, IDS_TOKENPHRASEPROMPT, sz, sizeof(sz));
		err = PGPclGetConventionalPhrase (g_context, 
				hwnd, sz, &pszPhrase);

		if (IsntPGPError (err))
		{
			hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
			if (IsntPGPError (err))
			{
				err = PGPWipeToken (g_context, 
						0, pszPhrase, lstrlen (pszPhrase));
			}
			SetCursor (hcursorOld);


			if (IsPGPError (err) && (err != kPGPError_BadPassphrase))
			{
				LoadString (g_hinst, IDS_TOKENWIPEFAILED, sz, sizeof(sz));
				if (PKMessageBox (hwnd, IDS_CAPTIONALERT, IDS_TOKENWIPEFAILED, 
						MB_ICONEXCLAMATION|MB_YESNO) == IDYES)
				{
					LoadString (g_hinst, 
							IDS_TOKENADMINPHRASEPROMPT, sz, sizeof(sz));

					err = PGPclGetConventionalPhrase (g_context, 
							hwnd, sz, &pszAdminPhrase);

					if (IsntPGPError (err))
					{
						if (IsntNull (pszPhrase))
							PGPclFreePhrase (pszPhrase);

						LoadString (g_hinst, 
								IDS_TOKENNEWPHRASEPROMPT, sz, sizeof(sz));

						err = PGPclGetConfirmationPhrase (g_context, hwnd, sz,
								kInvalidPGPKeyDBRef, 0, -1, &pszPhrase);
					}

					if (IsntPGPError (err))
					{
						hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
						if (IsntPGPError (err))
						{
							err = PGPFormatToken (g_context, 0, 
									pszAdminPhrase, lstrlen (pszAdminPhrase),
									pszPhrase, lstrlen (pszPhrase));
						}
						SetCursor (hcursorOld);
					}
				}
				else
					err = kPGPError_UserAbort;
			}
		}
	}

	if (IsntNull (pszPhrase))
		PGPclFreePhrase (pszPhrase);

	if (IsntNull (pszAdminPhrase))
		PGPclFreePhrase (pszAdminPhrase);

	return err;
}


//	___________________________________________________
//
//  copy the selected key to the token

BOOL
PKSendToToken (
		PGPKEYSSTRUCT*	ppks)
{
	PGPError			err				= kPGPError_NoErr;
	char*				pszPhrase		= NULL;
	PGPByte*			pPasskey		= NULL;
	char*				pszPIN			= NULL;
	PGPSize				sizePasskey		= 0;
	PGPByte*			pExport			= NULL;
	PGPKeyDBRef			keydb			= kInvalidPGPKeyDBRef;
	const				tokenNum		= 0; // always token 0

	PGPKeyDBObjRef		key;
	PGPSize				sizeExport;
	HCURSOR				hcursorOld;
	char				szPrompt[64];

	PKMessageBox (ppks->hwndMain, 
			IDS_CAPTIONINFO, IDS_SENDTOTOKENINFO, MB_OK|MB_ICONINFORMATION);

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, NULL, NULL);

	err = PGPclGetKeyPhrase (g_context, g_tlscontext, ppks->hwndMain,
			NULL, ppks->keydbMain, key, 
			&pszPhrase, &pPasskey, &sizePasskey); CKERR;

	LoadString (g_hinst, IDS_TOKENPHRASEPROMPT, szPrompt, sizeof(szPrompt));
	err = PGPclGetConventionalPhrase (g_context, 
			ppks->hwndMain, szPrompt, &pszPIN); CKERR;

	hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));

	{
		PGPTokenInfo pti = { sizeof(pti) };
		char *conts1=NULL, *conts2=NULL;
		int conts1_n=0, conts2_n=0;
		char CSP[80];

		PGPGetTokenInfo (g_context, tokenNum, &pti);
		PGPclIETokenProvToCSP( pti.manufacturerID, CSP, sizeof(CSP) );

		if( pti.numPrivKeys > 0 )  
			PGPclIEGetExistingKeyContainersRemote( CSP, &conts1, &conts1_n );

		// copy Master key
		err = PGPExport( g_context, 
            PGPOExportKeyDBObj( g_context, key ),
            PGPOOutputToken(g_context,tokenNum), 
			PGPOPassphrase (g_context, pszPhrase),
			PGPOPassphrase (g_context, pszPIN),
			PGPOLastOption (g_context));

		if( IsntPGPError(err) )  
			PGPclIEGetExistingKeyContainersRemote( CSP, &conts2, &conts2_n );

		// copy subkey
		if( IsntPGPError(err) ) {
			PGPUInt32 uVer=0;

			PGPGetKeyDBObjNumericProperty (key,
				kPGPKeyProperty_Version, &uVer);
			if( uVer == kPGPKeyVersion_V4 )   {
				err = PGPExport( g_context, 
					PGPOExportKeyDBObj( g_context, key ),
					PGPOOutputToken(g_context,tokenNum), 
					PGPOExportPrivateSubkeys(g_context, TRUE),
					PGPOPassphrase (g_context, pszPhrase),
					PGPOPassphrase (g_context, pszPIN),
					PGPOLastOption (g_context)); 
			}
		}

		if( IsntPGPError(err) )  {
			if( conts2 ) 
				PGPclProcessKeyConts( g_context, key, pszPhrase,
					CSP, &pti, conts1, conts1_n, conts2, conts2_n );
		}

		PGPclIEFreeMem( conts1 );
		PGPclIEFreeMem( conts2 );
	}

	SetCursor (hcursorOld);
	CKERR;

	if (PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
			IDS_QUERYREMOVEKEY, MB_YESNO|MB_ICONINFORMATION) == IDYES)
	{
		err = PGPExport (g_context,
				PGPOExportKeyDBObj (g_context, key), 
				PGPOAllocatedOutputBuffer (g_context,
						&pExport, 0x40000000, &sizeExport),
				PGPOExportFormat (g_context, 
						kPGPExportFormat_Complete),
				PGPOLastOption (g_context));  CKERR;

		PGPclKeyListUpdateTree (ppks->hKL,
				kPGPclKeyListRemoveObject, key, FALSE);
		err = PGPDeleteKeyDBObj (key); CKERR;
		PKDeletePropertiesWindowForObject (key);
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PGPclKeyListSetTree (ppks->hKL, kPGPclDeselectAll, NULL);

		err = PGPImport (g_context, &keydb, 
				PGPOInputBuffer (g_context, pExport, sizeExport),
				PGPOInputFormat (g_context, kPGPInputFormat_PGP),
				PGPOLastOption (g_context)); CKERR;

		err = PGPclImportKeys (g_context, g_tlscontext, ppks->hwndMain,
				PGPPeekKeyDBRootKeySet (keydb), ppks->keydbMain,
				kPGPclNoImportDialog|kPGPclNoTrustWarningMessage);
	}

	PGPclKeyListReloadKeys (ppks->hKL, TRUE);

done:
	if (IsntNull (pszPIN))
		PGPclFreePhrase (pszPIN);
	if (IsntNull (pszPhrase))
		PGPclFreePhrase (pszPhrase);
	if (IsntNull (pPasskey))
		PGPclFreePasskey (pPasskey, sizePasskey);
	if (IsntNull (pExport))
		PGPFreeData (pExport);
	if (PGPKeyDBRefIsValid (keydb))
		PGPFreeKeyDB (keydb);

	if (IsPGPError (err))
	{
		if (err == kPGPError_BadPassphrase)
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
					IDS_BADTOKENPHRASE, MB_OK|MB_ICONEXCLAMATION);
		}
		else
			PGPclErrorBox (ppks->hwndMain, err);

		return FALSE;
	}
	return TRUE;
}


//	___________________________________________________
//
//  Put up appropriate context menu on basis of selection flags.
//  Called in response to right mouse click.
//
//	hWnd		= handle of parent window
//	uSelFlags	= bits indicate what types of objects are selected
//	x, y		= mouse position when right button clicked (screen coords)

static VOID 
sTokenContextMenu (
		HWND		hWnd, 
		HKEYLIST	hKL, 
		UINT		uSelFlags, 
		INT			x, 
		INT			y) 
{
	HMENU		hMC;
	HMENU		hMenuTrackPopup;

	switch (uSelFlags) {
	case kPGPclKeyList_Key :
		hMC = LoadMenu (g_hinst, MAKEINTRESOURCE (IDR_MENUTOKEN));
		break;

	default :
		hMC = NULL;
		break;
	}

	if (!hMC) 
		return;

  	hMenuTrackPopup = GetSubMenu (hMC, 0);
	TrackPopupMenu (hMenuTrackPopup, TPM_LEFTALIGN|TPM_RIGHTBUTTON,
			x, y, 0, hWnd, NULL);

	DestroyMenu (hMC);
}


//	_____________________________________________________
//
//  Message processing function for Token property sheet

static LRESULT WINAPI
sTokenPropsDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	TOKENDLGSTRUCT*			ptds;