clrecip.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1998 Network Associates, Inc.
	All rights reserved.
	
	CLrecip.c - Glue code to allow clients to access
	            recipient dialog in PGPsdkUI

	$Id: CLrecip.c,v 1.47 1999/03/26 18:28:08 wjb Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

#include "pgpclx.h"
#include "pgpUserInterface.h"
extern HINSTANCE g_hInst;

#define SDKUITEST 0

/*
old RECIPIENTDIALOGSTRUCT for reference

typedef struct _recipientdialogstruct
{
	DWORD			Version;
	HWND			hwndParent;
	char *			szTitle;
	PGPContextRef	Context;
	PGPKeySetRef 	OriginalKeySetRef;
	PGPKeySetRef 	SelectedKeySetRef;
	char **			szRecipientArray;
	DWORD			dwNumRecipients;
	DWORD			dwOptions;
	DWORD			dwFlags;
	DWORD			dwDisableFlags;
} RECIPIENTDIALOGSTRUCT, *PRECIPIENTDIALOGSTRUCT;
*/

BOOL DefaultKeyCheck(HWND hwnd,
				PGPKeyRef DefaultKey,
				PGPKeySetRef SelectedKeySet)
{
    PGPKeyRef key;
	PGPError err;
 
	// We don't even know their default key!
	if(!PGPKeyRefIsValid(DefaultKey))
		return FALSE;

	err=PGPGetDefaultPrivateKey(SelectedKeySet,&key);

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

BOOL RSACheck(HWND hwnd,
			   PGPKeySetRef SelectedKeySet)
{
    PGPKeyListRef list;
    PGPKeyIterRef iter;
    PGPKeyRef key;
	PGPBoolean FoundRSAKey;
	PGPInt32 algorithm;
  
    PGPOrderKeySet(SelectedKeySet,kPGPReverseUserIDOrdering,&list);
    PGPNewKeyIter(list,&iter);

	FoundRSAKey=FALSE;

    while (IsntPGPError(PGPKeyIterNext(iter,&key)))
    {
		PGPGetKeyNumber( key, kPGPKeyPropAlgID, &algorithm );
		if(algorithm == kPGPPublicKeyAlgorithm_RSA)
			FoundRSAKey=TRUE;
	}

	PGPFreeKeyIter(iter);
    PGPFreeKeyList(list);
 
	return FoundRSAKey;
}

BOOL CorpCheck(HWND hwnd,
			   PGPKeySetRef MainKeySet,
			   PGPKeySetRef SelectedKeySet,
			   PGPKeyRef CorpKey)
{
    PGPUserIDRef userID;
    PGPKeyListRef list;
    PGPKeyIterRef iter;
    PGPKeyRef key;
	char UserIDStr[kPGPMaxUserIDSize];
	int len;
	PGPBoolean SignedByCorp;
	PGPError err;
  	PGPSigRef sig;
	PGPKeyRef certifierKey;
 
    PGPOrderKeySet(SelectedKeySet,kPGPReverseUserIDOrdering,&list);
    PGPNewKeyIter(list,&iter);

    while (IsntPGPError(PGPKeyIterNext(iter,&key)))
    {
		SignedByCorp=FALSE;
		strcpy(UserIDStr,"");

        while (IsntPGPError(PGPKeyIterNextUserID(iter, &userID)))
        {
			if(!strcmp(UserIDStr,""))
			{
				PGPGetUserIDStringBuffer(userID, kPGPUserIDPropName,
    				kPGPMaxUserIDSize-1, UserIDStr, &len);
			}

			while(IsntPGPError(err=PGPKeyIterNextUIDSig(iter,&sig)))
			{
				err = PGPGetSigCertifierKey(
					sig, MainKeySet, &certifierKey);

				if(IsntPGPError(err))
				{
					if(certifierKey == CorpKey)
						SignedByCorp=TRUE;
				}
			}
		}
		
		if(!SignedByCorp)
		{
			UINT msgrst;
			char StrRes[500];

			LoadString (g_hInst, IDS_KEYNOTSIGNEDBYCORP, 
											StrRes, sizeof(StrRes));

			msgrst=MessageBox(hwnd,StrRes,UserIDStr,
				MB_YESNO|MB_ICONEXCLAMATION|MB_SETFOREGROUND);

			if(msgrst==IDNO)
			{
				PGPFreeKeyIter(iter);
				PGPFreeKeyList(list);

				return FALSE;
			}
		}
	}

	PGPFreeKeyIter(iter);
    PGPFreeKeyList(list);
 
	return TRUE;
}

typedef struct 
{
	// Admins Prefs
	PGPBoolean allowConvEncrypt;
	PGPBoolean WarnNotCorpSigned;
	PGPBoolean haveOutgoingADK;
	PGPBoolean enforceOutgoingADK;
	PGPBoolean enforceRemoteADKClass;
	PGPKeyRef corpKey;
	PGPKeyRef outgoingADK;

	// Client Prefs
	PGPBoolean bWarnOnADK;
	PGPBoolean showMarginalValidity;
	PGPBoolean marginalIsInvalid;
	PGPBoolean encryptToSelf;
	PGPBoolean synchUnknown;
	PGPKeyRef defaultKey;

	// KeyServer (Client) Prefs
	PGPKeyServerEntry *ksEntries;
	PGPUInt32 numKSEntries;
	PGPKeyServerSpec *serverList;
	PCLIENTSERVERSTRUCT	pcss;
} APREF;

void NoDefaultKey(HWND hwnd)
{
	PGPclMessageBox(hwnd,IDS_CAPTIONERROR,IDS_NOVALIDDEFAULTKEY,
		MB_OK|MB_ICONEXCLAMATION);
}

void NoOutADKKey(HWND hwnd)
{
	PGPclMessageBox(hwnd,IDS_CAPTIONERROR,IDS_NOOUTADK,
		MB_OK|MB_ICONSTOP);
}

void NoCorpKey(HWND hwnd)
{
	PGPclMessageBox(hwnd,IDS_CAPTIONERROR,IDS_NOCORPSIGNKEY,
		MB_OK|MB_ICONSTOP);
}

PGPError GrabRecipClientPrefs(HWND hwndParent,
							  PGPContextRef context,
							  PGPKeySetRef keyset,
							  APREF *apref)
{
	PGPMemoryMgrRef	memMgr;
	PGPPrefRef	clientPrefsRef;
	PGPError	err;

	memMgr=PGPGetContextMemoryMgr(context);

	err=PGPclOpenClientPrefs (memMgr,&clientPrefsRef);

	if(IsntPGPError(err))
	{
		err=CLInitKeyServerPrefs(
			PGPCL_DEFAULTSERVER,NULL,
			hwndParent,
			context,
			keyset,
			clientPrefsRef,"",
			&(apref->pcss),
			&(apref->ksEntries),
			&(apref->serverList),
			&(apref->numKSEntries));

		PGPGetPrefBoolean( clientPrefsRef, kPGPPrefWarnOnADK, 
				&(apref->bWarnOnADK));
		PGPGetPrefBoolean( clientPrefsRef, kPGPPrefDisplayMarginalValidity,
				&(apref->showMarginalValidity));
		PGPGetPrefBoolean( clientPrefsRef, kPGPPrefMarginalIsInvalid,
				&(apref->marginalIsInvalid));
		PGPGetPrefBoolean( clientPrefsRef, kPGPPrefEncryptToSelf,
				&(apref->encryptToSelf));
		PGPGetPrefBoolean( clientPrefsRef, kPGPPrefKeyServerSyncUnknownKeys,
				&(apref->synchUnknown));
		PGPclCloseClientPrefs (clientPrefsRef, FALSE);
	}

	if(IsntPGPError(err))
	{
		err=PGPGetDefaultPrivateKey(keyset,&(apref->defaultKey));

		if(IsPGPError(err))
		{
			// Warning message here
			apref->defaultKey=NULL;
			err=kPGPError_NoErr;
		}
	}

	return err;
}

PGPError GrabRecipAdminPrefs(HWND hwndParent,
							 PGPContextRef context,
							 PGPKeySetRef keyset,
							 APREF *apref)
{
	PGPByte		*adKeyID;
	PGPSize		adKeyIDSize;
	PGPUInt32	adKeyAlgorithm;
	PGPByte		*corpKeyID;
	PGPSize		corpKeyIDSize;
	PGPUInt32	corpKeyAlgorithm;
	PGPMemoryMgrRef	memMgr;
	PGPPrefRef	adminPrefsRef;
	PGPError	err;

	memMgr=PGPGetContextMemoryMgr(context);

//>>>??? #if PGP_BUSINESS_SECURITY	
	err = PGPclOpenAdminPrefs (memMgr,&adminPrefsRef, PGPclIsAdminInstall());
//>>>??? #endif	// PGP_BUSINESS_SECURITY

	if(IsntPGPError(err))
	{
		// Allow Conventional
		PGPGetPrefBoolean( adminPrefsRef,
			kPGPPrefAllowConventionalEncryption,
			&(apref->allowConvEncrypt));

		// Warn if recipient not signed by corp key
		PGPGetPrefBoolean( adminPrefsRef,
			kPGPPrefWarnNotCertByCorp,
			&(apref->WarnNotCorpSigned));

		// Use an outgoing ADK
		PGPGetPrefBoolean( adminPrefsRef, 
			kPGPPrefUseOutgoingADK,
			&(apref->haveOutgoingADK));

		// Enforce this outgoing ADK
		PGPGetPrefBoolean( adminPrefsRef, 
			kPGPPrefEnforceOutgoingADK,
			&(apref->enforceOutgoingADK));

		// Enforce remote ADKs
		PGPGetPrefBoolean( adminPrefsRef,
			kPGPPrefEnforceRemoteADKClass,
			&(apref->enforceRemoteADKClass));

		// Get corp key ref
		PGPGetPrefData(adminPrefsRef, 
			kPGPPrefCorpKeyID, 
			&corpKeyIDSize, 
			&corpKeyID);

		PGPGetPrefNumber( adminPrefsRef,
			kPGPPrefCorpKeyPublicKeyAlgorithm, 
			&corpKeyAlgorithm);

		// Get outgoing adk key
		PGPGetPrefData( adminPrefsRef, 
			kPGPPrefOutgoingADKID,
			&adKeyIDSize, &adKeyID );

		PGPGetPrefNumber( adminPrefsRef,
			kPGPPrefOutADKPublicKeyAlgorithm,
			&adKeyAlgorithm );

		PGPclCloseAdminPrefs (adminPrefsRef, FALSE);
	}

	if((apref->haveOutgoingADK)&&(IsntPGPError(err)))
	{
		err=PGPclGetKeyFromKeyID (
			context,
			keyset,
			adKeyID,
			adKeyAlgorithm,
			&(apref->outgoingADK));

		if(IsPGPError(err))
		{
			// Warning message here
			apref->outgoingADK=NULL;
			err=kPGPError_NoErr;
		}
	}
	
	if(adKeyID)
		PGPDisposePrefData( adminPrefsRef, adKeyID);

	if((apref->WarnNotCorpSigned)&&(IsntPGPError(err)))
	{
		err=PGPclGetKeyFromKeyID (
			context,
			keyset,
			corpKeyID,
			corpKeyAlgorithm,
			&(apref->corpKey));

		if(IsPGPError(err))
		{
			// Warning message here
			apref->corpKey=NULL;
			err=kPGPError_NoErr;
		}
	}

	if(corpKeyID)
		PGPDisposePrefData( adminPrefsRef, corpKeyID);

	return err;
}

UINT PGPclExport PGPclRecipientDialog(PRECIPIENTDIALOGSTRUCT prds)
{
	PGPOptionListRef			rdoptionList;
	PGPOptionListRef			optionList;
	PGPUInt32					conventionalEncrypt,
								textOutput,
								wipeOriginal,
								fyeo,
								sda;
	Boolean						haveFileOptions;
	PGPclGROUPFILE				*pGroup;
	PGPKeySetRef				foundKeys;
	PGPUInt32					numKeys;
	APREF						apref;
	PGPUInt32					arrEnforcement;
	PGPError					err;
	char						StrRes1[100],StrRes2[300],StrRes3[100];

	memset(&apref,0x00,sizeof(APREF));
	apref.allowConvEncrypt = TRUE;

	pGroup=NULL;
	err=kPGPError_NoErr;
	foundKeys=kPGPInvalidRef;
	rdoptionList = kInvalidPGPOptionListRef;
	optionList = kInvalidPGPOptionListRef;
	haveFileOptions=FALSE;
	arrEnforcement = kPGPARREnforcement_Warn;
	textOutput=conventionalEncrypt=wipeOriginal=fyeo=sda=0;

	// Create Null Option List for recipient dialog
	err = PGPBuildOptionList( prds->Context, &rdoptionList,
		PGPOLastOption( prds->Context ) );

// ******************BUSINESS SECURITY***********************
#if PGP_BUSINESS_SECURITY 

	if(IsntPGPError(err))
	{
		err=GrabRecipAdminPrefs(prds->hwndParent,
					prds->Context,
					prds->OriginalKeySetRef,