keysplit.c

vc环境下的pgp源码

typedef struct {
	PGPContextRef		context;
	PGPtlsContextRef	tlsContext;
	HWND				hwndDlg;
	HWND				hwndList;
	HIMAGELIST			hIml;
	PGPKeySetRef		keyset;
	PGPKeyRef			keyToReconstitute;
	PGPKeyID			keyidToReconstitute;
	PGPKeyRef			keyAuthenticating;
	PGPKeySetRef		keysetDecryption;
	PGPUInt32			iKeyIDCount;
	PGPKeyID*			keyidsDecryption;
	PGPKeySetRef		keysetToAdd;
	CHAR				szAuthUserID[kPGPMaxUserIDSize+1];
	LPSTR				pszPhraseAuth;
	PGPByte*			pPasskeyAuth;
	PGPSize				sizePasskeyAuth;
	UINT				uNeededShares;
	UINT				uCollectedShares;
	PGPShareRef			sharesCombined;
	PGPskepRef			skep;
	INT					iIconIndex;
	BOOL				bServerMode;
	BOOL				bStop;
	BOOL				bUserCancel;
	BOOL				bUserOK;
	BOOL				bBadPassphrase;
	CRITICAL_SECTION	critsecAddShare;
} RECONKEYSTRUCT, *PRECONKEYSTRUCT;


//	______________________________________________
//
//  Reconstitute specified key

PGPError PGPclExport
PGPclReconstituteKey (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwnd,
		PGPKeySetRef		keyset,
		PGPKeyRef			key,
		PGPByte**			ppPasskey,
		PGPUInt32*			piPasskeyLength) 
{
	RECONKEYSTRUCT		rks;
	PGPError			err;

	// initialize struct
	rks.context				= context;
	rks.tlsContext			= tlsContext;
	rks.keyset				= keyset;
	rks.keyToReconstitute	= key;
	PGPGetKeyIDFromKey (key, &(rks.keyidToReconstitute));
	rks.uCollectedShares	= 0;
	rks.uNeededShares		= UNKNOWN_SHARES_NEEDED;
	rks.sharesCombined		= NULL;
	rks.bServerMode			= FALSE;
	rks.bUserCancel			= FALSE;
	rks.bUserOK				= FALSE;
	rks.bBadPassphrase		= FALSE;
	rks.pszPhraseAuth		= NULL;
	rks.pPasskeyAuth		= NULL;
	rks.skep				= NULL;
	rks.iIconIndex			= -1;

	InitializeCriticalSection (&rks.critsecAddShare);

	do {
		if (DialogBoxParam (g_hInst, MAKEINTRESOURCE (IDD_RECONSTITUTEKEY), 
			hwnd, sReconKeyDlgProc, (LPARAM)&rks)) {
			err = PGPGetPasskeyFromShares (rks.sharesCombined, 
							ppPasskey, piPasskeyLength);
			PGPclErrorBox (hwnd, err);

			if (!PGPPassphraseIsValid (key, 
					PGPOPasskeyBuffer (context, 
								*ppPasskey, *piPasskeyLength),
					PGPOLastOption (context))) {
				PGPclMessageBox (hwnd, IDS_CAPTION, IDS_BADPASSKEY, 
									MB_OK|MB_ICONSTOP);
				err = kPGPError_BadPassphrase;
			}
		}
		else {
			*ppPasskey = NULL;
			*piPasskeyLength = 0;
			err = kPGPError_UserAbort;
		}
	} while (err == kPGPError_BadPassphrase);

	DeleteCriticalSection (&rks.critsecAddShare);

	if (rks.sharesCombined)
		PGPFreeShares (rks.sharesCombined);

	if (rks.pszPhraseAuth)
		KMFreePhrase (rks.pszPhraseAuth);

	if (rks.pPasskeyAuth)
		KMFreePasskey (rks.pPasskeyAuth, rks.sizePasskeyAuth);

	return err;
}


//	______________________________________________
//
//  add share file to list


static VOID 
sAddShareFile (
		HWND			hwnd, 
		PRECONKEYSTRUCT	prks)
{
	PFLFileSpecRef		fileref				= NULL;
	PGPShareFileRef		sharefileref		= NULL;
	PGPOptionListRef	optionsDecode		= NULL;
	PGPShareRef			shares				= NULL;
	PGPShareRef			sharesTemp			= NULL;
	PGPError			err					= kPGPError_NoErr;

	OPENFILENAME	ofn;
	LPSTR			p;
	CHAR			szFile[MAX_PATH];
	CHAR			szName[kPGPMaxUserIDSize+1];
	CHAR			sz[256];
	CHAR			szTitle[64];
	PGPUInt32		size;
	PGPUInt32		uNumShares;
	UINT			uThreshold;
	PGPKeyID		keyid;

	// initialize
	prks->keysetToAdd		= kInvalidPGPKeySetRef;
	prks->keysetDecryption	= kInvalidPGPKeySetRef;
	prks->iKeyIDCount		= 0;
	prks->keyidsDecryption	= NULL;

	// prompt user for name of share file to send
	szFile[0] = '\0';
	LoadString (g_hInst, IDS_SHAREFILEFILTER, sz, sizeof(sz));
	while (p = strrchr (sz, '@')) *p = '\0';
	LoadString (g_hInst, IDS_SHAREFILECAPTION, szTitle, sizeof(szTitle));

	ofn.lStructSize       = sizeof (OPENFILENAME);
	ofn.hwndOwner         = hwnd;
	ofn.hInstance         = (HANDLE)g_hInst;
	ofn.lpstrFilter       = sz;
	ofn.lpstrCustomFilter = (LPTSTR)NULL;
	ofn.nMaxCustFilter    = 0L;
	ofn.nFilterIndex      = 1L;
	ofn.lpstrFile         = szFile;
	ofn.nMaxFile          = sizeof (szFile);
	ofn.lpstrFileTitle    = NULL;
	ofn.nMaxFileTitle     = 0;
	ofn.lpstrInitialDir   = NULL;
	ofn.lpstrTitle        = szTitle;
	ofn.Flags			  = OFN_HIDEREADONLY;
	ofn.nFileOffset       = 0;
	ofn.nFileExtension    = 0;
	ofn.lpstrDefExt       = "";
	ofn.lCustData         = 0;

	EnterCriticalSection (&prks->critsecAddShare);

	if (GetOpenFileName (&ofn)) {
		err = PFLNewFileSpecFromFullPath (
				PGPGetContextMemoryMgr (prks->context), szFile, &fileref);
		if (IsPGPError (err)) goto AddCleanup;
 
		err = PGPOpenShareFile (fileref, &sharefileref);
		if (IsPGPError (err)) goto AddCleanup;

		err = PGPGetShareFileSharedKeyID (sharefileref, &keyid);
		if (IsPGPError (err)) goto AddCleanup;

		if (PGPCompareKeyIDs (&keyid, &(prks->keyidToReconstitute))) {
			PGPclMessageBox (prks->hwndDlg, IDS_CAPTION, 
						IDS_SHAREKEYMISMATCH, MB_OK|MB_ICONEXCLAMATION);
			goto AddCleanup;
		}

		// check that threshold corresponds to other share files
		uThreshold = PGPGetShareThresholdInFile (sharefileref);
		if (prks->uNeededShares != UNKNOWN_SHARES_NEEDED) {
			if (uThreshold != prks->uNeededShares) {
				PGPclMessageBox (prks->hwndDlg, IDS_CAPTION, 
						IDS_SHARENUMMISMATCH, MB_OK|MB_ICONEXCLAMATION);
				goto AddCleanup;
			}
		}

		err = PGPGetShareFileUserID (sharefileref,
									sizeof(szName), szName, &size);
		if (IsPGPError (err)) goto AddCleanup;

		uNumShares = PGPGetNumSharesInFile (sharefileref);

		// decrypt specified share file
		prks->bBadPassphrase = FALSE;
		PGPBuildOptionList (prks->context, &optionsDecode,
					PGPOKeySetRef (prks->context, prks->keyset),
					PGPOEventHandler (prks->context, sHandlerDecode, prks),
					PGPOLastOption (prks->context));
		err = PGPCopySharesFromFile (prks->context, sharefileref, 
						optionsDecode, &shares);
		if (IsPGPError (err)) goto AddCleanup;

		// add shares to collection
		if (prks->sharesCombined) {
			err = PGPCombineShares (shares, 
									prks->sharesCombined, &sharesTemp);
			if (IsPGPError (err)) 
				goto AddCleanup;
			PGPFreeShares (prks->sharesCombined);
			prks->sharesCombined = sharesTemp;
		}
		else {
			prks->sharesCombined = shares;
			shares = NULL;
		}

		// share is OK, add it to list
		prks->uNeededShares = uThreshold;
		SetDlgItemInt (prks->hwndDlg, IDC_SHARESNEEDED, 
					prks->uNeededShares, FALSE);

		prks->uCollectedShares += uNumShares;
		SetDlgItemInt (hwnd, IDC_SHARESCOLLECTED, 
								prks->uCollectedShares, FALSE);
		sAddShareHolderToList (prks, szName, uNumShares);
	}

AddCleanup :
	LeaveCriticalSection (&prks->critsecAddShare);

	if (shares) 
		PGPFreeShares (shares);

	if (sharefileref)
		PGPFreeShareFile (sharefileref);

	if (fileref)
		PFLFreeFileSpec (fileref);

	if (optionsDecode)
		PGPFreeOptionList(optionsDecode);

	if (PGPKeySetRefIsValid (prks->keysetDecryption))
		PGPFreeKeySet (prks->keysetDecryption);

	if (prks->keyidsDecryption)
		clFree (prks->keyidsDecryption);

	switch (err) {
		case kPGPClientError_IdenticalShares :
			PGPclMessageBox (hwnd, IDS_CAPTION, IDS_DUPLICATESHARES,
					MB_OK|MB_ICONEXCLAMATION);
			break;

		case kPGPClientError_DifferentSharePool :
			PGPclMessageBox (hwnd, IDS_CAPTION, IDS_SHARENUMMISMATCH, 
					MB_OK|MB_ICONEXCLAMATION);
			break;

		case kPGPClientError_DifferentSplitKeys :
			PGPclMessageBox (hwnd, IDS_CAPTION, IDS_SHAREKEYMISMATCH, 
					MB_OK|MB_ICONEXCLAMATION);
			break;

		default:
			PGPclErrorBox (hwnd, err);
	}

	if (PGPKeySetRefIsValid (prks->keysetToAdd)) {
		if (IsntPGPError (err)) {
			PGPclQueryAddKeys (prks->context, prks->tlsContext, hwnd,
					prks->keysetToAdd, prks->keyset);
		}
		PGPFreeKeySet (prks->keysetToAdd);
	}
}

/* taken from clrecon.c */
//	______________________________________________
//
//  decode event handler

static PGPError
sHandlerDecode (
		PGPContextRef	context,
		PGPEvent*		event,
		PGPUserValue	userValue)
{
	PGPError		err		= kPGPError_NoErr;
	PRECONKEYSTRUCT	prks;

	switch (event->type) {
	case kPGPEvent_PassphraseEvent:
		{
			LPSTR		psz			= NULL;
			PGPByte*	pbyte		= NULL;
			PGPSize		size;
			UINT		uLen;
			CHAR		szPrompt[64];

			prks = (PRECONKEYSTRUCT)userValue;

			if (!prks->bBadPassphrase)
				LoadString (g_hInst, IDS_DECRYPTSHARESPROMPT, 
											szPrompt, sizeof(szPrompt));
			else
				LoadString (g_hInst, IDS_BADSHAREFILEPASSPHRASE, 
											szPrompt, sizeof(szPrompt));

			if (event->data.passphraseData.fConventional) {
				err = KMGetKeyPhrase (context, prks->tlsContext, 
								prks->hwndDlg, szPrompt, prks->keyset, 
								NULL, &psz, &pbyte, &size);
				prks->iIconIndex = IDX_HEAD;
			}
			else {
				err = KMGetDecryptionPhrase (context, prks->tlsContext, 
								prks->hwndDlg, szPrompt, prks->keyset, 
								NULL, prks->keysetDecryption,
								prks->iKeyIDCount, prks->keyidsDecryption,
								&prks->keysetToAdd, &psz, &pbyte, &size);
				prks->iIconIndex = IDX_DSAUSERID;
			}

			if (IsntPGPError (err)) {
				if (psz) {
					uLen = strlen (psz);
					PGPAddJobOptions (event->job, 
						PGPOPassphraseBuffer (context, psz, uLen),
						PGPOLastOption (context));
				}
				else {
					PGPAddJobOptions (event->job, 
						PGPOPasskeyBuffer (context, pbyte, size),
						PGPOLastOption (context));
				}
			}

			if (psz) 
				KMFreePhrase (psz);

			if (pbyte)
				KMFreePasskey (pbyte, size);

			// If passphrase event comes up again, the passphrase
			// must have been bad

			prks->bBadPassphrase = TRUE;
		}
		break;

	case kPGPEvent_RecipientsEvent:
		{
			PGPUInt32	i;

			PGPEventRecipientsData *pData = &event->data.recipientsData;
			prks = (PRECONKEYSTRUCT)userValue;
		
			// Save recipient key set for passphrase dialog
			prks->keysetDecryption = pData->recipientSet;
			PGPIncKeySetRefCount (prks->keysetDecryption);

			// Save unknown keyids
			if (pData->keyCount > 0) {
				prks->iKeyIDCount = pData->keyCount;
				prks->keyidsDecryption = 
					(PGPKeyID *)clAlloc (pData->keyCount * sizeof(PGPKeyID));

				for (i=0; i<pData->keyCount; i++) {
					prks->keyidsDecryption[i] = pData->keyIDArray[i];
				}
			}
		}
		break;
	}

	return err;
}


/* taken from KMUser.c */
//----------------------------------------------------|
// get passphrase for key from user

PGPError  
KMGetKeyPhrase (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwnd, 
		LPSTR				szPrompt,
		PGPKeySetRef		keyset,
		PGPKeyRef			key,
		LPSTR*				ppszPhrase,
		PGPByte**			ppPasskeyBuffer,
		PGPUInt32*			piPasskeyLength) 
{
	PGPError	err				= kPGPError_BadParams;
	PGPBoolean	bSplit			= FALSE;
	LPSTR		psz;
	UINT		uFlags;

	if (!ppPasskeyBuffer) return err;
	if (!piPasskeyLength) return err;

	psz = NULL;
	*ppPasskeyBuffer = NULL;
	*piPasskeyLength = 0;

	if (key) 
		PGPGetKeyBoolean (key, kPGPKeyPropIsSecretShared, &bSplit);

	do {
		if (bSplit) {
			err=PGPclReconstituteKey(
				context,			// in context
				tlsContext,			// in TLS context
				hwnd,				// in hwnd of parent
				keyset,				// in keyset
				key,				// in key
				ppPasskeyBuffer,	// out passkey buffer
				piPasskeyLength);	// out passkey length
		}
		else {
			if (key) uFlags = PGPCL_KEYPASSPHRASE;
			else uFlags = PGPCL_DECRYPTION;
			err = PGPclGetPhrase (
				context,			// in context
				keyset,				// in main keyset
				hwnd,				// in hwnd of parent
				szPrompt,			// in prompt
				&psz,				// out phrase
				NULL,				// in keyset
				NULL,				// in keyids
				0,					// in keyid count
				&key,				// in/out key
				NULL,				// out options
				uFlags,				// in flags
				ppPasskeyBuffer,	// out passkey buffer
				piPasskeyLength,	// out passkey length
				0,0,				// in min length/quality
				tlsContext,			// in tlsContext,
				NULL,				// out AddedKeys
				NULL);				

		}

		if (IsPGPError (err)) {
			if (psz) {
				PGPFreeData (psz);
				psz = NULL;
			}
			if (*ppPasskeyBuffer) {
				PGPFreeData (*ppPasskeyBuffer);
				*ppPasskeyBuffer = NULL;
			}
			PGPclErrorBox (hwnd, err);
		}
		else {
			if (ppszPhrase) *ppszPhrase = psz;
			else KMFreePhrase (psz);
		}

	} while (err == kPGPError_BadPassphrase);

	return err;
}

#endif 0

/*__________________________________________________________________________________________
*/