optestutils.c

PGP.Corporation.PGP.SDK.v3.7.2.rar 此前从本站下载的那个缺少几个lib文件

/*____________________________________________________________________________
optestUtils.c

Copyright (C) 2003,2004 PGP Corporation
All rights reserved.

  FIPS 140-2 Operational Test Utilities..

$Id: optestUtils.c 48493 2006-10-12 21:19:56Z vinnie $
____________________________________________________________________________*/

#include <time.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifndef PGP_WIN32
#include <unistd.h>
#else 
#include <direct.h>
#include <io.h>
#include <windows.h>

#endif
 
#include "pgpFeatures.h"
#include "pgpErrors.h"
#include "pgpUtilities.h"
#include "pgpRandomPool.h"
#include "pgpKeys.h"
#include "pgpHashWords.h"
#include "optest.h"
  
 
#include <stdarg.h>
 
void opTestTrace(const char *file, int line, const char *proc, const char *fmt, ...)  
{
	va_list marker;
	char s[1024];
	char s2[1024];
	const char *p = strrchr( file, '/' );
 
	if( p )  
		file = p+1;

	va_start( marker, fmt );     
	vsprintf( s, fmt, marker );
	va_end( marker ); 
	sprintf( s2, "\n**** %s (%4d): %s()%s %s\n", file, line, proc, *s?",":"", s );
#if PGP_WIN32 && !PGP_MOBILE	
	OutputDebugString( s2 );
#else
	OPTESTPrintF( s2 );	/* TODO: logging for other platforms */
#endif
}


#define kFlag_Priv 				0
#define kFlag_Axiomatic			1
#define kFlag_Revoked 			2
#define kFlag_Expired 			3
#define kFlag_Disabled 			4
#define kFlag_Token 			5
#define kFlag_X_509 			6
#define kFlag_Split 			7
#define kFlag_SignUserIDs 		8
#define kFlag_SignMessages 		9
#define kFlag_EncryptComm 		10
#define kFlag_EncryptStorage 	11
#define kFlag_Corrupt 			12
#define kFlag_EncryptionKey		13
#define kFlag_SigningKey		14
#define kFlag_Revocable			15
#define kFlag_ThirdPartyRevocation 16	
#define kFlag_HasCRL			17
#define	kFlag_LAST				18

static char *flagNameTxt[] = {
	"Sec",
	"Axiomatic",
	"Revoked",
	"Expired",
	"Disabled",
	"Token",
	"X.509",
	"Split",
	"SignUserIDs",
	"SignMessages",
	"EncryptComm",
	"EncryptStorage",
	"Corrupt",
	"EncryptionKey",
	"SigningKey",
	"Revocable",
	"3rdPartyRev",
	"HasCRL" };


typedef struct FlagBits{
 	struct 	{
		char		*name;
		PGPBoolean	value;
	}bit[kFlag_LAST];
}FlagBits;


void SetupFlags(FlagBits *flags)
{
 	int i;
 	for(i =0; i<kFlag_LAST; i++) flags->bit[i].name = flagNameTxt[i];
}

void ClearFlags(FlagBits *flags)
{
	int i;
 	for(i =0; i<kFlag_LAST; i++) flags->bit[i].value = FALSE;
}
 
void SetFlag( FlagBits *flags, int i, PGPBoolean value)
{
	flags->bit[i].value = value;
}

PGPBoolean* GetFlagValue(FlagBits *flags, int i)
{
	return (&flags->bit[i].value);
}

void getFlagString( FlagBits *flags, char* buf)
{
	
	int i, count;
 	*buf = '\0';
	
 	for(i =0, count = 0; i<kFlag_LAST; i++) if(flags->bit[i].value) count++;
	
	if(count)
	{
 		
		for(i =0; i<kFlag_LAST && count > 0; i++)
 			if(flags->bit[i].value)
			{
				strcat(buf,flags->bit[i].name );
				if(--count ) strcat(buf,", ");
			}
  	}
}
	 
#define FLAG(i) GetFlagValue(&keyflags, i)
#define VALUE(i) *GetFlagValue(&keyflags, i)
#define SET_FLAG(i,val) SetFlag(&keyflags, i, val)
 

PGPChar * hash_algor_table(int algor)
{
 	switch (algor )
	{
		case kPGPHashAlgorithm_MD5: 		return (PGPTXT_USER("MD5"));
		case kPGPHashAlgorithm_SHA: 		return (PGPTXT_USER("SHA-1"));
		case kPGPHashAlgorithm_RIPEMD160: 	return (PGPTXT_USER("RIPE-MD-160"));
		case kPGPHashAlgorithm_SHA256:		return (PGPTXT_USER("SHA-128"));
		case kPGPHashAlgorithm_SHA384:		return (PGPTXT_USER("SHA-384"));
		case kPGPHashAlgorithm_SHA512:		return (PGPTXT_USER("SHA-512"));						
		default:							return (PGPTXT_USER("Invalid"));
	}
}

 
PGPChar * cipher_algor_table(int algor)
{
 	switch (algor )
	{
		case kPGPCipherAlgorithm_IDEA: 		return (PGPTXT_USER("IDEA"));
		case kPGPCipherAlgorithm_3DES: 		return (PGPTXT_USER("3-DES"));
		case kPGPCipherAlgorithm_CAST5: 	return (PGPTXT_USER("CAST-5"));
		case kPGPCipherAlgorithm_AES128: 	return (PGPTXT_USER("AES-128"));
		case kPGPCipherAlgorithm_AES192: 	return (PGPTXT_USER("AES-192"));
		case kPGPCipherAlgorithm_AES256: 	return (PGPTXT_USER("AES-256"));	
		case kPGPCipherAlgorithm_Blowfish:  return (PGPTXT_USER("BlowFish"));
		case kPGPCipherAlgorithm_Twofish256: return (PGPTXT_USER("TwoFish"));
		default:	 return (PGPTXT_USER("Invalid"));
	}
}

PGPChar * key_algor_table(int keytype)
{
	switch(keytype)
	{
		case kPGPPublicKeyAlgorithm_RSA:			return (PGPTXT_USER("RSA"));
		case kPGPPublicKeyAlgorithm_RSAEncryptOnly:	return (PGPTXT_USER("RSA Encrypt Only"));
		case kPGPPublicKeyAlgorithm_RSASignOnly:	return (PGPTXT_USER("RSA Sign Only"));
		case kPGPPublicKeyAlgorithm_ElGamal:		return (PGPTXT_USER("Elgamal"));
		case kPGPPublicKeyAlgorithm_DSA:			return (PGPTXT_USER("DSA"));
 		case kPGPPublicKeyAlgorithm_ECEncrypt:		return (PGPTXT_USER("EC-Enc"));
		case kPGPPublicKeyAlgorithm_ECSign:			return (PGPTXT_USER("EC-Sign"));
		default:									return (PGPTXT_USER("Invalid"));
	}
}



PGPChar * compression_algor_table(int algor)
{
	switch(algor)
	{
		case kPGPCompressionAlgorithm_None:			return (PGPTXT_USER("None"));
		case kPGPCompressionAlgorithm_ZLIB:			return (PGPTXT_USER("ZLIB"));
		case kPGPCompressionAlgorithm_ZIP:			return (PGPTXT_USER("Zip"));
		case kPGPCompressionAlgorithm_BZIP2:		return (PGPTXT_USER("BZip2"));
 		default:									return (PGPTXT_USER("Invalid"));
	}
}

PGPChar * email_encoding_table(int encoding)
{
	switch(encoding)
	{
 		case kPGPPreferredEmailEncoding_PGPMIME:			return (PGPTXT_USER("PGPMIME"));
		case kPGPPreferredEmailEncoding_Partitioned:		return (PGPTXT_USER("Legacy"));
  		default:											return (PGPTXT_USER("Invalid"));
	}
}

/* Get feature info about a cipher. */

PGPError getCipherInfo(PGPCipherAlgorithm algor, PGPAlgorithmInfo* info)
{
 	PGPError					err 		= kPGPError_BadCipherNumber;
	PGPSymmetricCipherInfo		cipherInfo;
	PGPUInt32 numAlgs, i;

 	err = PGPCountSymmetricCiphers (&numAlgs); CKERR;
	for (i = 0; i < numAlgs; i ++)
 	{
		err = PGPGetIndexedSymmetricCipherInfo (i, &cipherInfo); CKERR;
		if(cipherInfo.algID == algor)
		{
			*info = cipherInfo.info;
			return kPGPError_NoErr;
		}
	}	
 	
done:
 	return err;
 }

 
 PGPSize addAV( PGPAVAttribute attribute, const char *value, PGPAttributeValue *av)
{
	if (IsntNull(value))
	{
		av->attribute = attribute;
		av->size = strlen(value);
		av->value.pointervalue = (char *) value;
		return 1;
	}
	
	return 0;
}
 


/*  TE02.04.02 - Import key(s) */
PGPError importKeys (PGPContextRef context,  const PGPChar8 *path, PGPInputFormat format, PGPKeyDBRef *keyDB )
{
 	PGPError		err 		= kPGPError_NoErr;
	PGPFileSpecRef 	fileSpec 	= kInvalidPGPFileSpecRef;
 
/* Create filespec to keys */
	err = PGPNewFileSpecFromFullPath(context, path, &fileSpec); CKERR;

/* Read in the test key and get a ref to it */
	err = PGPImport( context, keyDB,
						PGPOInputFile( context, fileSpec ),
						PGPOInputFormat( context, format),
 						PGPOLastOption( context ) ); CKERR;
 done:
 	
	if( PGPFileSpecRefIsValid(fileSpec))
			 PGPFreeFileSpec(fileSpec);
			 
	return err;

}
 
/* standard Hex dump formatter */

void dumpHex( PGPByte* buffer, int length, int offset)
{
	char hexDigit[] = "0123456789ABCDEF";
	register int			i;
	int						lineStart;
	int						lineLength;
	short					c;
	PGPByte			 *bufferPtr = buffer;
#define kLineSize	16
	for (lineStart = 0; lineStart < length; lineStart += lineLength) {
		lineLength = kLineSize;
		if (lineStart + lineLength > length)
			lineLength = length - lineStart;
			
		OPTESTPrintF("%6d: ", lineStart+offset);
		for (i = 0; i < lineLength; i++){
			putchar( hexDigit[ bufferPtr[lineStart+i] >>4]);
			putchar( hexDigit[ bufferPtr[lineStart+i] &0xF]);
			if((lineStart+i) &0x01) putchar(' ');
		}
		for (; i < kLineSize; i++)
			OPTESTPrintF("   ");
		OPTESTPrintF("  ");
		for (i = 0; i < lineLength; i++) {
			c = bufferPtr[lineStart + i] & 0xFF;
			if (c > ' ' && c < '~')
				OPTESTPrintF("%c", c);
			else {
				OPTESTPrintF(".");
			}
		}
		OPTESTPrintF("\n");
	}
}

 
void dumpLong( PGPByte* buffer, int length)
{
	char hexDigit[] = "0123456789abcdef";
 	register int			i;
	int						lineStart;
	int						lineLength;
 	PGPByte			 *bufferPtr = buffer;
	
#define kLineSize	16
	for (lineStart = 0; lineStart < length; lineStart += lineLength) {
		lineLength = kLineSize;
		if (lineStart + lineLength > length)
			lineLength = length - lineStart;
			
		OPTESTPrintF("%6s ", "");
		for (i = 0; i < lineLength; i++){
#if 0
			putchar( hexDigit[ bufferPtr[lineStart+i] >>4]);
			putchar( hexDigit[ bufferPtr[lineStart+i] &0xF]);
	 		if( ((lineStart+i) & 0x3)  == 0x3) putchar(' ');
#else
			OPTESTPrintF("0x%c%c, ", hexDigit[ bufferPtr[lineStart+i] >>4] ,  hexDigit[ bufferPtr[lineStart+i] &0xF]);
#endif

		}
 	OPTESTPrintF("\n");
	}
}
 
void printTruncated(char* data, int len, int max)
{
	char buffer[1024];
	
	unsigned int count =  0;
	unsigned int i;
	
 	count =  len > max? max: len;
	count =  count > sizeof(buffer) -1 ?sizeof(buffer) -1:count;
 	
	for(i = 0; i<count; i++)
		buffer[i] = isprint(data[i])?data[i]: (iscntrl(data[i])?' ':'.');
	buffer[i] = 0;
	OPTESTPrintF("%s%s\n", buffer, len > max?"...":"");	
  
}




/* Format a Fingerprint for printing */

void FormatFingerprintString(char *p, PGPByte *inBuffp, PGPSize len )
{
	static char hexDigit[] = "0123456789ABCDEF";
	int			strIndex;
	if(len == 20)
	{
		for(strIndex = 0 ; strIndex < 20 ; strIndex++)
		{
			*p++ = hexDigit[inBuffp[strIndex]>>4];
			*p++ = hexDigit[inBuffp[strIndex]&0xF];
			if((strIndex == 1) || (strIndex == 3) || (strIndex == 5)
			   || (strIndex == 7) || (strIndex == 11) ||
			   (strIndex == 13)
			   || (strIndex == 13) || (strIndex == 15) ||
			   (strIndex == 17))
				*p++ = ' ';
			else if(strIndex == 9)
			{
				*p++ = ' ';
				*p++ = ' ';
			}
		}
	}
	else
	{
		for(strIndex = 0 ; strIndex < 16 ; strIndex++)
		{
			*p++ = hexDigit[inBuffp[strIndex]>>4];
			*p++ = hexDigit[inBuffp[strIndex]&0xF];
			if((strIndex == 1) || (strIndex == 3) || (strIndex == 5)
			   || (strIndex == 9) || (strIndex == 11) || (strIndex == 13))
				*p++ = ' ';
			else if(strIndex == 7)
			{
				*p++ = ' ';
				*p++ = ' ';
			}
		}
	}
	*p++ = '\0';
}


static  void getKeyUsageString( PGPKeyDBObjRef theKey, char* buf)
{
	PGPBoolean  isToken		= FALSE;
	PGPBoolean  canEncrypt	= canKeyEncrypt(theKey);
	PGPBoolean  canDecrypt	= canKeyDecrypt(theKey);
	PGPBoolean  canSign		= canKeySignMessages(theKey);
	PGPBoolean  canVerify	= canKeyVerify(theKey);
  
  	PGPGetKeyDBObjBooleanProperty(theKey, kPGPKeyProperty_IsOnToken,	&isToken );
	
	sprintf(buf,"[%c%c%c%c%c]",
 			isToken?'t':'-',canEncrypt?'e':'-',canDecrypt?'d':'-',canSign?'s':'-',canVerify?'v':'-'  );
 }


void printKeyName( char *header, PGPKeyDBObjRef theKey)
{
	PGPKeyID			theKeyID;
	char				keyIDstr[kPGPMaxKeyIDStringSize];
	char				buffer[256];
 	char				props[8];
 	PGPSize				bufSize;
	PGPBoolean			isSecret = FALSE;

	PGPGetKeyDBObjBooleanProperty(theKey, kPGPKeyProperty_IsSecret,	&isSecret );	 
	PGPGetKeyID( theKey, &theKeyID );
	PGPGetKeyIDString( &theKeyID, kPGPKeyIDString_Abbreviated, keyIDstr);
	PGPGetPrimaryUserIDName(theKey,  buffer, sizeof(buffer), &bufSize);
		getKeyUsageString(theKey, props);

	OPTESTPrintF("%s%s (%s) %s \"%s\" \n",(header?header:""),keyIDstr, (isSecret?"Sec":"Pub"), props, buffer);

}
 
 PGPError printSigInfo( char *header, PGPKeyDBObjRef sig)
{
	PGPInt32			algorithm	= 0;
  	FlagBits			keyflags;
	PGPKeyID			keyID;
	PGPSize				length;
	char				tempBuf[256];
	PGPError			err  = kPGPError_NoErr;
	PGPTime				createTime, expireTime;
	PGPUInt16			year, month, day;

	SetupFlags(&keyflags);
	ClearFlags(&keyflags);
	err = PGPGetKeyDBObjBooleanProperty(sig, kPGPSigProperty_IsX509,		FLAG(kFlag_X_509));		CKERR;
	err = PGPGetKeyDBObjBooleanProperty(sig, kPGPSigProperty_IsRevoked,		FLAG(kFlag_Revoked));	CKERR;
	err = PGPGetKeyDBObjBooleanProperty(sig, kPGPSigProperty_IsExpired,		FLAG(kFlag_Expired));	CKERR;
	err = PGPGetKeyDBObjBooleanProperty(sig, kPGPSigProperty_IsNotCorrupt,	FLAG(kFlag_Corrupt));	CKERR;
	*FLAG(kFlag_Corrupt) = !*(FLAG(kFlag_Corrupt));
	err = PGPGetKeyDBObjNumericProperty(sig, kPGPSigProperty_AlgorithmID,	&algorithm);		CKERR;
	
	err = PGPGetKeyDBObjDataProperty(sig, kPGPSigProperty_KeyID, &keyID, sizeof(keyID), &length);  
	if(IsntPGPError(err))
	{
		PGPGetKeyIDString(&keyID, kPGPKeyIDString_Abbreviated, (void*)tempBuf);
	}
	else
	{