pgpkeyserver.cpp

vc环境下的pgp源码

											inBuffer, &inBufferSize );
							}
							else
							{
								err = kPGPError_OutOfMemory;
							}
						}
					
						PGPFreeIO( fileIORef );
					}
				}
				else if( IsntNull( options.inBuffer ) )
				{
					inBuffer 		= options.inBuffer;
					inBufferSize	= options.inBufferSize;
					freeInputBuffer	= FALSE;
				}
				
				err = pgpSendCertificateRequestInternal( keyServerRef, options.caKey,
							options.requestKey, inBuffer, inBufferSize, &outBuffer,
							&outBufferSize );
			
				if( freeInputBuffer && IsntNull( inBuffer ) )
					PGPFreeData( inBuffer );
					
				if( IsntPGPError( err ) && IsntNull( outBuffer ) )
				{
					if( PFLFileSpecRefIsValid( options.outFileSpecRef ) )
					{
						err = SaveDataToFile( options.outFileSpecRef,
									outBuffer, outBufferSize,
									options.appendOutput );
					}
					else if( IsntNull( options.outBuffer ) )
					{
						if( outBufferSize <= options.maxOutBufferSize )
						{
							pgpCopyMemory( outBuffer, options.outBuffer,
									outBufferSize );
									
							*options.outBufferSize = outBufferSize;
						}
						else
						{
							err = kPGPError_BufferTooSmall;
						}
					}
					else if( IsntNull( options.allocatedOutBuffer ) )
					{
						if( outBufferSize <= options.maxOutBufferSize )
						{
							*options.allocatedOutBuffer = outBuffer;
							*options.outBufferSize		= outBufferSize;
							
							freeOutputBuffer = FALSE;
						}
						else
						{
							err = kPGPError_BufferTooSmall;
						}
					}
					else
					{
						/* Discard output */
					}
				}
				
				if( freeOutputBuffer && IsntNull( outBuffer ) )
					PGPFreeData( outBuffer );
			}
		}
	}
	
	return( err );
}

	PGPError
PGPSendCertificateRequest( 
	PGPKeyServerRef 	inKeyServerRef,
	PGPOptionListRef	firstOption,
	... )
{
	PGPError	err = kPGPError_NoErr;
	va_list		args;

	pgpAssert( PGPKeyServerRefIsValid( inKeyServerRef ) );
		
	if( PGPKeyServerRefIsValid( inKeyServerRef )  )
	{
		PGPOptionListRef	optionList;
		PGPContextRef		context;
		
		context = PGPGetKeyServerContext( inKeyServerRef );
		
		va_start( args, firstOption );
		optionList = pgpBuildOptionListArgs( context, FALSE, firstOption, args);
		va_end( args );
	
		err = pgpSendCertificateRequest( context, inKeyServerRef, optionList );
	
		PGPFreeOptionList( optionList );
	}
	else
	{
		va_start( args, firstOption );
		pgpFreeVarArgOptionList( firstOption, args );
		va_end( args );
		
		err = kPGPError_BadParams;
	}
	
	return( err );
}

typedef struct RetrieveCertificateOptions
{
	PGPKeyRef		caKey;
	PFLFileSpecRef	outFileSpecRef;
		
	void			*outBuffer;
	PGPSize			maxOutBufferSize;
	PGPSize			*outBufferSize;
	
	void			**allocatedOutBuffer;
	
	PGPBoolean		appendOutput;
	
	PGPFilterRef	searchFilter;
	PGPKeyRef		searchKey;
	PGPKeySetRef	keySet;
	
	PGPKeyRef		signingKey;
	PGPByte *		passPhrase;
	PGPSize			passLength;
	PGPBoolean		isPassphrase;
} RetrieveCertificateOptions;


	static PGPError
GatherRetrieveCertOptions(
	PGPOptionListRef			optionList,
	RetrieveCertificateOptions	*options)
{
	PGPError	err 				= kPGPError_NoErr;
	PGPUInt32	numOutputOptions	= 0;
	PGPInt32	tempInt;
	
	pgpAssert( pgpOptionListIsValid( optionList ) );
	pgpAssert( IsntNull( options ) );
	
	pgpClearMemory( options, sizeof( *options ) );
	
	/* Find ca key */
	if ( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_KeyServerCAKey, FALSE, "%p",
					&options->caKey);
	}
	
	/* Find ca keyset */
	if ( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_KeySetRef, FALSE, "%p",
					&options->keySet);
	}

	/* Find search key */
	if ( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_KeyServerSearchKey, FALSE, "%p",
					&options->searchKey);
	}
	
	/* Find search filter */
	if ( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_KeyServerSearchFilter, FALSE, "%p",
					&options->searchFilter);
	}
	
	/* Find signing key and passphrase*/
	if ( IsntPGPError( err ) )
	{
		PGPOption	signOp;
		
		err = pgpSearchOptionSingle(optionList, kPGPOptionType_SignWithKey, &signOp);
		if (IsntPGPError(err) && IsOp(signOp)) {
			err = pgpOptionPtr(&signOp, (void **) &options->signingKey);
			if (IsntPGPError(err)) {
				err = pgpFindOptionArgs(signOp.subOptions, kPGPOptionType_Passphrase, FALSE,
						"%p%l", &options->passPhrase, &options->passLength);
			}
			if (IsntPGPError(err) && IsntNull(options->passPhrase)) {
				options->isPassphrase = true;
			} else if (IsntPGPError(err)) {
				err = pgpFindOptionArgs(signOp.subOptions, kPGPOptionType_Passkey, FALSE,
						"%p%l", &options->passPhrase, &options->passLength);
				options->isPassphrase = false;
			}
		}
	}

	/* Find outputs */
	if( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_OutputFileRef, FALSE, "%f",
					&options->outFileSpecRef );
		if( PFLFileSpecRefIsValid( options->outFileSpecRef ) )
		{
			++numOutputOptions;
		}
	}

	if( IsntPGPError( err ) )
	{
		PGPOOutputBufferDesc	*desc;
		
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_OutputBuffer, FALSE, "%p", &desc );
		if( IsntNull( options->outBuffer ) )
		{
			options->outBuffer 			= desc->buffer;
			options->maxOutBufferSize 	= desc->bufferSize;
			options->outBufferSize 		= desc->outputDataLength;
			
			*(options->outBufferSize) = 0;

			++numOutputOptions;
		}
	}

	if( IsntPGPError( err ) )
	{
		PGPOAllocatedOutputBufferDesc	*desc;
		
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_OutputAllocatedBuffer, FALSE, "%p", &desc );
		if( IsntNull( desc ) )
		{
			options->allocatedOutBuffer = desc->buffer;
			options->maxOutBufferSize 	= desc->maximumBufferSize;
			options->outBufferSize 		= desc->actualBufferSize;
			
			*(options->allocatedOutBuffer) 	= 0;
			*(options->outBufferSize) 		= 0;
			
			++numOutputOptions;
		}
	}

	if( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_AppendOutput, FALSE, "%d", &tempInt );
		if( tempInt != 0 )
		{
			options->appendOutput = TRUE;
			
			++numOutputOptions;
		}
	}

	/* Check for at most one output */
	
	if( IsntPGPError( err ) && 
		( numOutputOptions > 1 ) )
	{
		pgpDebugMsg( "Invalid input or output specification" );
		err = kPGPError_BadParams;
	}
	
	return err;
}

static const PGPOptionType sRetrieveCertOptionSet[] =
{
	kPGPOptionType_KeyServerCAKey,
	kPGPOptionType_KeyServerSearchKey,
	kPGPOptionType_KeyServerSearchFilter,
	kPGPOptionType_SignWithKey,
	kPGPOptionType_OutputFileRef,
	kPGPOptionType_OutputBuffer,
	kPGPOptionType_OutputAllocatedBuffer,
	kPGPOptionType_AppendOutput,
	kPGPOptionType_DiscardOutput,
	kPGPOptionType_KeySetRef
};

	static PGPError
pgpRetrieveCertificateInternal(
	PGPKeyServerRef 	keyServerRef,
	PGPFilterRef		searchFilter,
	PGPKeyRef			searchKey,
	PGPKeyRef			signingKey,
	PGPByte *			passPhrase,
	PGPSize				passLength,
	PGPBoolean			isPassphrase,
	void				**outBuffer,
	PGPSize				*outBufferSize)
{
	PGPError		result = kPGPError_NoErr;
	
	try {
		*outBuffer 		= 0;
		*outBufferSize	= 0;
	
		StKeyServerBusy	busyKeyServer((CKeyServer *) keyServerRef);
		
		((CKeyServer *) keyServerRef)->RetrieveCertificate(	searchFilter,
															searchKey,
															signingKey,
															passPhrase,
															passLength,
															isPassphrase,
															outBuffer,
															outBufferSize);
	}
	
	catch (PGPError exception) {
		result = MapErrors(exception);
	}
	
#if !PGP_WIN32
	catch (...) {
		result = kPGPError_UnknownError;
	}
#endif
	
	return result;
}

	static PGPError
pgpRetrieveCertificate(
	PGPContextRef		context,
	PGPKeyServerRef 	keyServerRef,
	PGPOptionListRef	optionList)
{
	PGPError		err;
	
	(void) context;
	
	pgpAssert( pgpContextIsValid( context ) );
	pgpAssert( PGPKeyServerRefIsValid( keyServerRef ) );
	pgpAssert( pgpOptionListIsValid( optionList ) );
	
	err = pgpGetOptionListError( optionList );
	if( IsntPGPError( err ) )
	{
		err = pgpCheckOptionsInSet( optionList, sRetrieveCertOptionSet,
					elemsof( sRetrieveCertOptionSet ) );
		if( IsntPGPError( err ) )
		{
			RetrieveCertificateOptions	options;
			
			err = GatherRetrieveCertOptions( optionList, &options );
			if( IsntPGPError( err ) )
			{
				void		*outBuffer 			= 0;
				PGPSize		outBufferSize		= 0;
				PGPBoolean	freeOutputBuffer	= TRUE;
								
				err = pgpRetrieveCertificateInternal( keyServerRef, options.searchFilter,
							options.searchKey, options.signingKey, options.passPhrase,
							options.passLength, options.isPassphrase, &outBuffer, &outBufferSize );
			
				if( IsntPGPError( err ) )
				{
					if( PFLFileSpecRefIsValid( options.outFileSpecRef ) )
					{
						err = SaveDataToFile( options.outFileSpecRef,
									outBuffer, outBufferSize,
									options.appendOutput );
					}
					else if( IsntNull( options.outBuffer ) )
					{
						if( outBufferSize <= options.maxOutBufferSize )
						{
							pgpCopyMemory( outBuffer, options.outBuffer,
									outBufferSize );
									
							*options.outBufferSize = outBufferSize;
						}
						else
						{
							err = kPGPError_BufferTooSmall;
						}
					}
					else if( IsntNull( options.allocatedOutBuffer ) )
					{
						if( outBufferSize <= options.maxOutBufferSize )
						{
							*options.allocatedOutBuffer = outBuffer;
							*options.outBufferSize		= outBufferSize;
							
							freeOutputBuffer = FALSE;
						}
						else
						{
							err = kPGPError_BufferTooSmall;
						}
					}
					else
					{
						/* Discard output */
					}
				}
				
				if( freeOutputBuffer && IsntNull( outBuffer ) )
					PGPFreeData( outBuffer );
			}
		}
	}
	
	return( err );
}

	PGPError
PGPRetrieveCertificate( 
	PGPKeyServerRef 	inKeyServerRef,
	PGPOptionListRef	firstOption,
	... )
{
	PGPError	err = kPGPError_NoErr;
	va_list		args;

	pgpAssert( PGPKeyServerRefIsValid( inKeyServerRef ) );
		
	if( PGPKeyServerRefIsValid( inKeyServerRef ) )
	{
		PGPOptionListRef	optionList;
		PGPContextRef		context;
		
		context = PGPGetKeyServerContext( inKeyServerRef );
		
		va_start( args, firstOption );
		optionList = pgpBuildOptionListArgs( context, FALSE, firstOption, args);
		va_end( args );
	
		err = pgpRetrieveCertificate( context, inKeyServerRef, optionList );
	
		PGPFreeOptionList( optionList );
	}
	else
	{
		va_start( args, firstOption );
		pgpFreeVarArgOptionList( firstOption, args );
		va_end( args );
		
		err = kPGPError_BadParams;
	}
	
	return( err );
}

	static PGPError
pgpRetrieveCRLInternal(
	PGPKeyServerRef 	keyServerRef,
	PGPKeyRef			certifyingKey,
	PGPKeySetRef		searchKeySet,
	PGPKeyRef			signingKey,
	PGPByte *			passPhrase,
	PGPSize				passLength,
	PGPBoolean			isPassphrase,
	void				**outBuffer,
	PGPSize				*outBufferSize)
{
	PGPError		result = kPGPError_NoErr;
	
	try {
		*outBuffer 		= 0;
		*outBufferSize	= 0;
	
		StKeyServerBusy	busyKeyServer((CKeyServer *) keyServerRef);
		
		((CKeyServer *) keyServerRef)->RetrieveCRL(	certifyingKey,
													searchKeySet,
													signingKey,
													passPhrase,
													passLength,
													isPassphrase,
													outBuffer,
													outBufferSize);
	}
	
	catch (PGPError exception) {
		result = MapErrors(exception);
	}
	
#if !PGP_WIN32
	catch (...) {
		result = kPGPError_UnknownError;
	}
#endif
	
	return result;
}

	static PGPError
pgpRetrieveCRL(
	PGPContextRef		context,
	PGPKeyServerRef 	keyServerRef,
	PGPOptionListRef	optionList)
{
	PGPError		err;
	
	(void) context;
	
	pgpAssert( pgpContextIsValid( context ) );
	pgpAssert( PGPKeyServerRefIsValid( keyServerRef ) );
	pgpAssert( pgpOptionListIsValid( optionList ) );
	
	err = pgpGetOptionListError( optionList );
	if( IsntPGPError( err ) )
	{
		/* This call uses the same options as PGPRetrieveCertificate() */
		
		err = pgpCheckOptionsInSet( optionList, sRetrieveCertOptionSet,
					elemsof( sRetrieveCertOptionSet ) );
		if( IsntPGPError( err ) )
		{
			RetrieveCertificateOptions	options;
			
			err = GatherRetrieveCertOptions( optionList, &options );
			if( IsntPGPError( err ) )
			{
				void		*outBuffer 			= 0;
				PGPSize		outBufferSize		= 0;
				PGPBoolean	freeOutputBuffer	= TRUE;
								
				err = pgpRetrieveCRLInternal( keyServerRef,
							options.caKey, options.keySet, options.signingKey, options.passPhrase,
							options.passLength, options.isPassphrase, &outBuffer, &outBufferSize );
			
				if( IsntPGPError( err ) )
				{
					if( PFLFileSpecRefIsValid( options.outFileSpecRef ) )
					{
						err = SaveDataToFile( options.outFileSpecRef,
									outBuffer, outBufferSize,
									options.appendOutput );
					}
					else if( IsntNull( options.outBuffer ) )
					{
						if( outBufferSize <= options.maxOutBufferSize )
						{
							pgpCopyMemory( outBuffer, options.outBuffer,
									outBufferSize );
									
							*options.outBufferSize = outBufferSize;
						}
						else
						{
							err = kPGPError_BufferTooSmall;
						}
					}
					else if( IsntNull( options.allocatedOutBuffer ) )
					{
						if( outBufferSize <= options.maxOutBufferSize )
						{
							*options.allocatedOutBuffer = outBuffer;
							*options.outBufferSize		= outBufferSize;
							
							freeOutputBuffer = FALSE;
						}
						else
						{
							err = kPGPError_BufferTooSmall;
						}
					}
					else
					{
						/* Discard output */
					}
				}
				
				if( freeOutputBuffer && IsntNull( outBuffer ) )
					PGPFreeData( outBuffer );
			}
		}
	}
	
	return( err );
}

	PGPError
PGPRetrieveCertificateRevocationList( 
	PGPKeyServerRef 	inKeyServerRef,
	PGPOptionListRef	firstOption,
	... )
{
	PGPError	err = kPGPError_NoErr;
	va_list		args;

	pgpAssert( PGPKeyServerRefIsValid( inKeyServerRef ) );
		
	if( PGPKeyServerRefIsValid( inKeyServerRef ) )
	{
		PGPOptionListRef	optionList;
		PGPContextRef		context;
		
		context = PGPGetKeyServerContext( inKeyServerRef );
		
		va_start( args, firstOption );
		optionList = pgpBuildOptionListArgs( context, FALSE, firstOption, args);
		va_end( args );
	
		err = pgpRetrieveCRL( context, inKeyServerRef, optionList );
	
		PGPFreeOptionList( optionList );
	}
	else
	{
		va_start( args, firstOption );
		pgpFreeVarArgOptionList( firstOption, args );
		va_end( args );
		
		err = kPGPError_BadParams;
	}
	
	return( err );
}