pkkeyio.c

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

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
	
	PKKeyIO.c - implements various operations related to importing 
				and exporting keys  
	
	$Id: PKKeyIO.c,v 1.33 2002/08/06 20:09:46 dallen Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

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

// system header files
#include <commdlg.h>
#include <mapi.h>

// typedefs
typedef struct {
	PGPBoolean	bX509;
	PGPBoolean	bEnableExportPrivKeys;
	PGPBoolean	bExportPrivKeys;
	PGPBoolean	bEnableCompatible;
	PGPBoolean	bCompatible;
} EXPORTPRIVKEYSTRUCT, *PEXPORTPRIVKEYSTRUCT;

// external globals
extern HINSTANCE		g_hinst;
extern PGPContextRef	g_context;
extern PGPtlsContextRef	g_tlscontext;

// local globals
static BOOL s_bDraggingOut = FALSE;	//NB: valid across keymanagers!
									//prevents bonus selective import dialog

static DWORD aExportKeyIds[] = {			// Help IDs
    IDC_EXPORTPRIVATEKEYS,		IDH_PGPPK_EXPORTPRIVATEKEYS, 
    IDC_INCLUDEEXTENSIONS,		IDH_PGPPK_INCLUDEEXTENSIONS, 
    0,0 
}; 

//	_______________________________________________
//
//  Evaluate filename for PGP data vs. X.509 data

static PGPError 
sCreateFileImportOptions (
		PGPKEYSSTRUCT*		ppks,
		LPSTR				pszFilename,
		PGPFileSpecRef		fileref,
		BOOL				bFirst,
		PGPOptionListRef*	pOptions) 
{
	PGPInputFormat	format			= kPGPInputFormat_Unknown;
	CHAR			szPrompt[64];
	LPSTR			p;
	UINT			u;
	LPSTR			psz;
	PGPError		err;

	u = lstrlen (pszFilename);

	if (u > 4)
	{
		p = &pszFilename[u-4];

		if (stricmp (p, ".pem") == 0)
			format = kPGPInputFormat_PEMEncodedX509Cert;
		else if ((stricmp (p, ".pfx") == 0) ||
			(stricmp (p, ".p12") == 0))
		{
			format = kPGPInputFormat_PKCS12;
		}
	}

	err = PGPBuildOptionList (g_context, pOptions,
					PGPOInputFile (g_context, fileref),
					PGPOInputFormat (g_context, format),
					PGPOLastOption (g_context));

	// if format is PKCS-12 and first time, try w/o passphrase
	// if PKCS-12 and not first time, then we need a passphrase
	if ((format == kPGPInputFormat_PKCS12) && !bFirst)
	{
		LoadString (g_hinst, IDS_PKCS12PROMPT, szPrompt, sizeof(szPrompt));
		p = strrchr (pszFilename, '\\');
		if (p)
			p++;
		else
			p = pszFilename;

		lstrcat (szPrompt, p);

		err = PGPclGetConventionalPhrase (
					g_context, ppks->hwndMain, szPrompt, &psz);

		if (IsntPGPError (err))
		{
			err = PGPAppendOptionList (*pOptions, 
					PGPOPassphrase (g_context, psz),
					PGPOLastOption (g_context));
		}

		PGPclFreePhrase (psz);
	}

	return err;
}


//	_______________________________________________
//
//  Evaluate pasted buffer for PGP data vs. X.509 data

static PGPInputFormat 
sEvaluateBuffer (
		LPSTR	pszOrig,
		LPSTR*	ppszBegin) 
{
	CHAR	szBegin[]		= "-----BEGIN";
	CHAR	szBeginPGP[]	= "-----BEGIN PGP";

	PGPInputFormat	format	= kPGPInputFormat_Unknown;

	*ppszBegin = strstr (pszOrig, szBegin);
	if (*ppszBegin)
	{
		if (!strncmp (*ppszBegin, szBeginPGP, sizeof(szBeginPGP)-1))
			format = kPGPInputFormat_PGP;
		else
			format = kPGPInputFormat_PEMEncodedX509Cert;
	}
	else
		*ppszBegin = pszOrig;

	return format;
}


//	_______________________________________________
//
//  Import key from text file
//
//	hDrop	== NULL	=> prompt user for file name
//			!= NULL => hDrop is a handle passed in from 
//						the WM_DROPFILE message

BOOL 
PKInputFile (
		PGPKEYSSTRUCT*	ppks,
		HDROP			hDrop) 
{
	PGPOptionListRef	optionsImport		= kInvalidPGPOptionListRef;
	PGPError			err					= kPGPError_NoErr;
	BOOL				bImport				= FALSE;
	BOOL				bImported			= FALSE;

	OPENFILENAME		OpenFileName;
	CHAR				szFile[MAX_PATH];
	CHAR				szInitDir[MAX_PATH];
	CHAR				szFilter[256];
	CHAR				szTitle[64];
	CHAR*				p;
	INT					iIndex;
	BOOL				bFirst;
	PGPFileSpecRef		fileref;
	PGPKeyDBRef			keydb;
	UINT				uType;

	// files have been dropped
	if (hDrop) 
	{
		iIndex = 0;

		while (DragQueryFile (hDrop, iIndex, szFile, sizeof(szFile))) 
		{
			if (PKFileIsForImporting (szFile, &uType, NULL))
			{
				if (uType == PK_EXPORTEDGROUPFILE)
				{
					if (IsntPGPError (PGPgmImportGroups (ppks->hGM, szFile)))
					{
						bImported = TRUE;
						ppks->bGroupsVisible = FALSE;
						PostMessage (ppks->hwndMain, WM_COMMAND,
								MAKEWPARAM (IDM_VIEWGROUPS, 0), 0);
					}
				}
				else
				{
					PGPNewFileSpecFromFullPath (g_context, szFile, &fileref);
					if (PGPFileSpecRefIsValid (fileref))
					{
						bFirst = TRUE;
						do 
						{
							if (PGPOptionListRefIsValid (optionsImport))
								PGPFreeOptionList (optionsImport);

							err = sCreateFileImportOptions (ppks,
									szFile, fileref, bFirst, &optionsImport);

							if (IsntPGPError (err))
							{
								err = PGPImport (g_context, 
										&keydb, optionsImport,
										PGPOLastOption (g_context));
							}

							if (!bFirst || (err != kPGPError_BadPassphrase))
								PGPclErrorBox (ppks->hwndMain, err);

							bFirst = FALSE;

						} while (err == kPGPError_BadPassphrase);

						if (IsntPGPError (err) && PGPKeyDBRefIsValid (keydb))
						{
							PGPUInt32	uNumKeys;

							PGPCountKeys (
									PGPPeekKeyDBRootKeySet (keydb), &uNumKeys);
							if (uNumKeys > 0) 
							{
								bImported = TRUE;

								if (s_bDraggingOut) 
								{
									if (IsntPGPError (PGPclErrorBox (NULL, 
											PGPCopyKeys (
												PGPPeekKeyDBRootKeySet (keydb), 
												ppks->keydbMain, NULL))))
									{
										bImport = TRUE;
									}
								}
								else 
								{
									if (PGPclImportKeys (g_context, 
											g_tlscontext, ppks->hwndMain, 
											PGPPeekKeyDBRootKeySet (keydb), 
											ppks->keydbMain, 
											kPGPclDefaultImportFlags) 
										== kPGPError_NoErr) 
									{
										bImport = TRUE;
									}
								}
							}
							if (PGPKeyDBRefIsValid (keydb))
								PGPFreeKeyDB (keydb);
						}

						if (PGPOptionListRefIsValid (optionsImport))
						{
							PGPFreeOptionList (optionsImport);
							optionsImport = kInvalidPGPOptionListRef;
						}

						PGPFreeFileSpec (fileref);
					}
				}
			}
			else
			{
				bImported = TRUE;
				PKNewWindowForFile (ppks->hwndMain, ppks, FALSE, szFile);
			}
			iIndex++;
		}

		if (IsntPGPError (err) && !bImported) 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_NOIMPORTKEYS, MB_OK|MB_ICONINFORMATION);
		}
	}

	// files weren't dropped, query user for file to import
	else 
	{
		lstrcpy (szFile, "");
		LoadString (g_hinst, IDS_IMPORTFILTER, szFilter, sizeof(szFilter));
		while (p = strrchr (szFilter, '@')) *p = '\0';
		LoadString (g_hinst, IDS_IMPORTCAPTION, szTitle, sizeof(szTitle));
		PGPclGetPath (kPGPclDefaultOpenFolder, szInitDir, sizeof(szInitDir));

		OpenFileName.lStructSize       = sizeof (OPENFILENAME);
		OpenFileName.hwndOwner         = ppks->hwndMain;
		OpenFileName.hInstance         = (HANDLE)g_hinst;
		OpenFileName.lpstrFilter       = szFilter;
		OpenFileName.lpstrCustomFilter = (LPTSTR)NULL;
		OpenFileName.nMaxCustFilter    = 0L;
		OpenFileName.nFilterIndex      = 1L;
		OpenFileName.lpstrFile         = szFile;
		OpenFileName.nMaxFile          = sizeof (szFile);
		OpenFileName.lpstrFileTitle    = NULL;
		OpenFileName.nMaxFileTitle     = 0;
		OpenFileName.lpstrInitialDir   = szInitDir;
		OpenFileName.lpstrTitle        = szTitle;
		OpenFileName.Flags			   = OFN_HIDEREADONLY|OFN_NOCHANGEDIR;
		OpenFileName.nFileOffset       = 0;
		OpenFileName.nFileExtension    = 0;
		OpenFileName.lpstrDefExt       = "";
		OpenFileName.lCustData         = 0;

		if (GetOpenFileName (&OpenFileName)) 
		{
			PGPNewFileSpecFromFullPath (g_context, szFile, &fileref);
			if (PGPFileSpecRefIsValid (fileref)) 
			{
				bFirst = TRUE;
				do 
				{
					if (PGPOptionListRefIsValid (optionsImport))
						PGPFreeOptionList (optionsImport);

					err = sCreateFileImportOptions (ppks,
							szFile, fileref, bFirst, &optionsImport);

					if (IsntPGPError (err))
					{
						err = PGPImport (g_context, &keydb, 
								optionsImport, PGPOLastOption (g_context));
					}

					if (!bFirst || (err != kPGPError_BadPassphrase))
						PGPclErrorBox (ppks->hwndMain, err);

					bFirst = FALSE;
				} while (err == kPGPError_BadPassphrase);

				if (IsntPGPError (err) && PGPKeyDBRefIsValid (keydb))
				{
					PGPUInt32	uNumKeys;
					
					PGPCountKeys (PGPPeekKeyDBRootKeySet (keydb), &uNumKeys);
					if (uNumKeys > 0) 
					{
						bImported = TRUE;

						if (PGPclImportKeys (g_context, 
								g_tlscontext, ppks->hwndMain, 
								PGPPeekKeyDBRootKeySet (keydb), 
								ppks->keydbMain, 
								kPGPclDefaultImportFlags) 
							== kPGPError_NoErr) 
						{
							bImport = TRUE;
						}
					}
					if (PGPKeyDBRefIsValid (keydb))
						PGPFreeKeyDB (keydb);
				}

				if (PGPOptionListRefIsValid (optionsImport))
				{
					PGPFreeOptionList (optionsImport);
					optionsImport = kInvalidPGPOptionListRef;
				}

				PGPFreeFileSpec (fileref);
			}
			if (IsntPGPError (err) && !bImported) 
			{
				PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
						IDS_NOIMPORTKEYS, MB_OK|MB_ICONINFORMATION);
			}
		}
	}

	if (bImport) 
	{
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PGPclKeyListReloadKeys (ppks->hKL, TRUE);
	}

	return bImport;
}


//	_______________________________________________
//
//  Get appropriate comment string

static VOID 
sGetCommentString (
		PGPMemoryMgrRef	memMgr,
		LPSTR			psz, 
		UINT			uLen) 
{
	PGPPrefRef	prefref;

	psz[0] = '\0';

	if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		PGPGetPrefStringBuffer (prefref, kPGPPrefComment, uLen, psz);
}

//	_______________________________________________
//
//  Get export format based on prefs

static PGPExportFormat 
sGetExportFormat (PGPMemoryMgrRef	memMgr)
{
	PGPBoolean	bCompatible		= TRUE;
	PGPPrefRef	prefref			= kInvalidPGPPrefRef;

	if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		PGPGetPrefBoolean (prefref, kPGPPrefExportKeysCompatible, &bCompatible);

	if (bCompatible) 
		return kPGPExportFormat_Basic;
	else
		return kPGPExportFormat_Complete;
}


//	_______________________________________________
//
//  Export key(s) to text file

static BOOL 
sExportKeys (
		PGPKEYSSTRUCT*	ppks,
		PGPKeySetRef	keyset,
		PGPKeyDBObjRef	key,
		LPSTR			szFile,
		PGPBoolean		bExportPrivateKeys,
		PGPBoolean		bX509cert,
		PGPBoolean		bCompatible) 
{
	BOOL			bRetVal				= FALSE;
	PGPByte*		pPasskey			= NULL;
	LPSTR			pszPhrase			= NULL;
	PGPFileSpecRef	fileref;
	CHAR			szComment[256];
	PGPExportFormat	exportformat;
	PGPSize			sizePasskey;
	PGPError		err;

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

		if (IsPGPError (PGPclErrorBox (ppks->hwndMain, err)))
			return FALSE;
	}

	PGPNewFileSpecFromFullPath (g_context, szFile, &fileref);
	if (PGPFileSpecRefIsValid (fileref))
	{	
		sGetCommentString (PGPPeekContextMemoryMgr (g_context), 
				szComment, sizeof(szComment));

		if (bX509cert)
			exportformat = kPGPExportFormat_X509Cert;
		else if (bCompatible)
			exportformat = kPGPExportFormat_Basic;
		else
			exportformat = kPGPExportFormat_Complete;

		if (IsntPGPError (PGPclErrorBox (NULL,
				PGPExport (g_context,
						PGPOExportKeySet (g_context, keyset), 
						PGPOOutputFile (g_context, fileref),
						PGPOExportFormat (g_context, 
								exportformat),
						PGPOVersionString (g_context, 
								pgpVersionHeaderString()),
						PGPOCommentString (g_context, szComment),
						PGPOExportPrivateKeys (g_context,
								bExportPrivateKeys),
						pszPhrase ?
							PGPOPassphrase (g_context, pszPhrase) :
							PGPONullOption (g_context),
						(bX509cert && !bExportPrivateKeys) ?
							PGPOArmorOutput (g_context, TRUE) :
							PGPONullOption (g_context),
						PGPOLastOption (g_context))))) 
		{
			bRetVal = TRUE;
		}
		PGPFreeFileSpec (fileref);
	}

	if (IsntNull (pszPhrase))
		PGPclFreePhrase (pszPhrase);
	if (IsntNull (pPasskey))
		PGPclFreePasskey (pPasskey, sizePasskey);

	return bRetVal;
}


//	___________________________