clrecip.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 970 行 · 第 1/2 页

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	CLrecip.c - Glue code to allow clients to access
	            recipient dialog in PGPsdkUI

	$Id: CLrecip.c,v 1.26 2002/10/31 04:13:35 pbj 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,
				PGPKeyDBObjRef DefaultKey,
				PGPKeyDBRef SelectedKeyDB)
{
    PGPKeyDBObjRef key;
	PGPError err;

	// We don't even know their default key!
	if(!PGPKeyDBObjRefIsValid(DefaultKey))
		return FALSE;

	err=PGPclGetDefaultPrivateKey(SelectedKeyDB,&key);

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

BOOL RSACheck(HWND hwnd,
			   PGPKeyDBRef SelectedKeyDB)
{
	PGPKeySetRef SelectedKeySet;
    PGPKeyIterRef iter;
    PGPKeyDBObjRef key;
	PGPBoolean FoundRSAKey;
	PGPInt32 algorithm;

  	PGPNewKeySet( SelectedKeyDB, &SelectedKeySet );
	PGPNewKeyIterFromKeySet (SelectedKeySet, &iter);

	FoundRSAKey=FALSE;

    while (IsntPGPError(PGPKeyIterNextKeyDBObj(
							iter,
							kPGPKeyDBObjType_Key,
							&key)))
    {
		PGPGetKeyDBObjNumericProperty( key, 
			kPGPKeyProperty_AlgorithmID, &algorithm );
		if(algorithm == kPGPPublicKeyAlgorithm_RSA)
			FoundRSAKey=TRUE;
	}

	PGPFreeKeyIter(iter);
	PGPFreeKeySet(SelectedKeySet);

	return FoundRSAKey;

	return FALSE;
}
/*
BOOL CorpCheck(HWND hwnd,
			   PGPKeyDBRef MainKeyDB,
			   PGPKeyDBRef SelectedKeyDB,
			   PGPKeyDBObjRef CorpKey)
{
    PGPKeyDBObjRef userID;
	PGPKeySetRef SelectedKeySet;
    PGPKeyIterRef iter;
    PGPKeyDBObjRef key;
	char UserIDStr[kPGPMaxUserIDSize+1];
	int len;
	PGPBoolean SignedByCorp;
	PGPError err;
  	PGPKeyDBObjRef sig;
	PGPKeyDBObjRef certifierKey;

	PGPNewKeySet( SelectedKeyDB, &SelectedKeySet );
	PGPNewKeyIterFromKeySet (SelectedKeySet, &iter);

    while (IsntPGPError(PGPKeyIterNextKeyDBObj(
								iter,
								kPGPKeyDBObjType_Key,
								&key)))
    {
		SignedByCorp=FALSE;

        while (IsntPGPError(PGPKeyIterNextKeyDBObj(
								iter,
								kPGPKeyDBObjType_UserID,
								&userID)))
        {
			while(IsntPGPError(PGPKeyIterNextKeyDBObj(
								iter,
								kPGPKeyDBObjType_Signature,
								&sig)))
			{
				err = PGPGetSigCertifierKey(
					sig, MainKeyDB, &certifierKey);

				if(IsntPGPError(err))
				{
					if(certifierKey == CorpKey)
						SignedByCorp=TRUE;
				}
			}
		}

		if(!SignedByCorp)
		{
			UINT msgrst;
			char StrRes[500];

			err = PGPGetPrimaryUserIDName (key,
					UserIDStr, kPGPMaxUserIDSize, &len); 

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

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

			if(msgrst==IDNO)
			{
				PGPFreeKeyIter(iter);
				PGPFreeKeySet(SelectedKeySet);

				return FALSE;
			}
		}
	}

	PGPFreeKeyIter(iter);
	PGPFreeKeySet(SelectedKeySet);

	return TRUE;
}
*/
BOOL InvalidCheck(HWND hwnd,
			   PGPKeyDBRef MainKeyDB,
			   PGPKeyDBRef SelectedKeyDB)
{
	PGPKeySetRef SelectedKeySet;
    PGPKeyIterRef iter;
    PGPKeyDBObjRef key;
	PGPBoolean bAllValid;
	PGPBoolean bAxiomatic;
	DWORD Validity;

	bAllValid=TRUE;

	PGPNewKeySet( SelectedKeyDB, &SelectedKeySet );
	PGPNewKeyIterFromKeySet (SelectedKeySet, &iter);

    while (IsntPGPError(PGPKeyIterNextKeyDBObj(
								iter,
								kPGPKeyDBObjType_Key,
								&key)))
    {
		PGPGetKeyDBObjNumericProperty(key,
			kPGPKeyProperty_Validity,
			&Validity);
	    PGPGetKeyDBObjBooleanProperty (key, 
			kPGPKeyProperty_IsAxiomatic, 
			&bAxiomatic);

		if(bAxiomatic)
		{
			// Implicit Trust
		}
		else switch(Validity)
		{
			case kPGPValidity_Marginal :
			{
				// Marginal Key
				break;
			}
			case kPGPValidity_Complete :
			{
				// Valid Key;
				break;
			}
			default :
			{
				// Invalid Key
				bAllValid=FALSE;
				break;
			}
		}  
	}

	PGPFreeKeyIter(iter);
	PGPFreeKeySet(SelectedKeySet);

	return bAllValid;
}

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

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

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

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

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


void EncryptingToInvalidKeys(HWND hwnd)
{
	PGPclMessageBox(hwnd,IDS_CAPTIONERROR,IDS_ENCRYPTINVALID,
		MB_OK|MB_ICONSTOP);
}

/*
void NoCorpKey(HWND hwnd)
{
	PGPclMessageBox(hwnd,IDS_CAPTIONERROR,IDS_NOCORPSIGNKEY,
		MB_OK|MB_ICONSTOP);
}
*/
PGPError GrabRecipClientPrefs(HWND hwndParent,
							  PGPContextRef context,
							  PGPKeyDBRef keydb,
							  APREF *apref)
{
	PGPError		err;
	PGPPrefRef		prefRef;

	err=CLInitKeyServerPrefs(
		kPGPclAllServers,NULL,
		hwndParent,
		context,
		keydb,
		"",
		&(apref->pcss),
		&(apref->ksEntries),
		&(apref->serverList),
		&(apref->numKSEntries));

	if(IsntPGPError(err))
	{
		apref->bKeyserversInited=TRUE;
	}

	err = PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if (IsntPGPError (err))
	{
		PGPGetPrefBoolean(prefRef, kPGPPrefWarnOnADK,
				&(apref->bWarnOnADK));
		PGPGetPrefBoolean(prefRef, kPGPPrefDisplayMarginalValidity,
				&(apref->showMarginalValidity));
		PGPGetPrefBoolean(prefRef, kPGPPrefMarginalIsInvalid,
				&(apref->marginalIsInvalid));
		PGPGetPrefBoolean(prefRef, kPGPPrefEncryptToSelf,
				&(apref->encryptToSelf));
		PGPGetPrefBoolean(prefRef, kPGPPrefKeyServerSyncUnknownKeys,
				&(apref->synchUnknown));

		if(IsntPGPError(err))
		{

			err=PGPclGetDefaultPrivateKey(keydb,&(apref->defaultKey));

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

	return err;
}

PGPError GrabRecipAdminPrefs(HWND hwndParent,
							 PGPContextRef context,
							 PGPKeyDBRef keydb,
							 APREF *apref)
{
	PGPKeyID	*adKeyID;
	PGPSize		adKeyIDSize;
//	PGPKeyID	*corpKeyID;
//	PGPSize		corpKeyIDSize;
	PGPError	err;
	PGPPrefRef	prefRef;

	err = PGPclPeekClientLibPrefRefs(&prefRef,NULL);
	if (IsPGPError (err))
		return err;

	// Allow Conventional
	PGPGetPrefBoolean(prefRef,
		kPGPPrefAllowConventionalEncryption,
		&(apref->allowConvEncrypt));

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

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

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

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

	// Allow encryption to invalid keys
	PGPGetPrefBoolean(prefRef,
		kPGPPrefAllowEncryptInvalidKeys,
		&(apref->allowInvalidEncrypt));

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

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

	if((apref->haveOutgoingADK)&&(IsntPGPError(err)))
	{
		err=PGPFindKeyByKeyID(
			keydb,
			adKeyID,
			&(apref->outgoingADK));

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

	if(adKeyID)
		PGPFreeData(adKeyID);
/*
	if((apref->WarnNotCorpSigned)&&(IsntPGPError(err)))
	{
		err=PGPFindKeyByKeyID(
			keydb,
			corpKeyID,
			&(apref->corpKey));

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

	if(corpKeyID)
		PGPFreeData(corpKeyID);*/

	return err;
}

UINT PGPclExport PGPclRecipientDialog(PPGPclRecipientDialogStruct prds)
{
	PGPOptionListRef			rdoptionList;
	PGPOptionListRef			ksupoptionList;
	PGPOptionListRef			optionList;
	PGPUInt32					conventionalEncrypt,
								textOutput,
								wipeOriginal,
								fyeo,
								sda,
								inputIsText;
	PGPBoolean					haveFileOptions;
	PGPclGroupFile				*pGroup;
	PGPKeyDBRef					foundKeys;
	PGPUInt32					numKeys;
	APREF						apref;
	PGPUInt32					arrEnforcement;
	PGPError					err;
	char						StrRes1[100],StrRes2[300],StrRes3[100];
	DWORD						dwDisableFlags;

	dwDisableFlags=prds->dwDisableFlags;

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

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

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

// ******************BUSINESS SECURITY***********************
	if(PGPlnEnterprise())
	{
		if(IsntPGPError(err))
		{
			err=GrabRecipAdminPrefs(prds->hwndParent,
						prds->context,
						prds->keydbOriginal,
						&apref);
		}

		if(IsntPGPError(err))
		{
			arrEnforcement = kPGPARREnforcement_Warn;