shatest.c

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

/*____________________________________________________________________________
SHAtest.c

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

SHAtest.c - This file contains functions which are used to demo
the  SHA Hashing functions It runs a known answer test using vectors from 
the FIPS-180-2 document.

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

#include <string.h>
#include <stdio.h>

#include "pgpEncode.h"
#include "pgpErrors.h"
#include "pgpKeys.h"
#include "pgpPublicKey.h"
#include "pgpHash.h"
#include "pgpUtilities.h"

#include "optest.h"

/*
Run a specific SHA-1 test and compare against known answer. 
*/

 
static PGPError TestSHAkat( 
						PGPContextRef 		context, 
						PGPHashAlgorithm	algor,
						char				*name,
						char				*msg, 
						PGPSize				msgsize, 
						PGPUInt32			passes, 
						const PGPByte		*expected )
{

 	PGPHashContextRef 		hashref  	= kInvalidPGPHashContextRef;
	PGPError				err 		= kPGPError_NoErr;
	PGPSize  				hashSize;
	PGPByte					hashBuf [64];	

	PGPUInt32  	i;

	if(gVerbose_flag)
		OPTESTPrintF("\t%10s  %ld byte %s\n", hash_algor_table(algor) , msgsize * passes , name  );
		
/* create a SHA  hash context */
 	err = PGPNewHashContext( context, algor, &hashref); CKERR;
  
	err = PGPGetHashSize(hashref,  &hashSize);CKERR;
 	
	if(hashSize > sizeof(hashBuf)) RETERR(kPGPError_BufferTooSmall);
 	
/* calculate the hash..  */
 	for (i = 0; i < passes; i++)
	{
		err =  PGPContinueHash( hashref, msg,  msgsize); CKERR;
 	}
	
/* output the hash */
	err = PGPFinalizeHash(hashref, hashBuf);CKERR;
	
/* check against known answer */
 	err = pgpMemoryEqual(hashBuf, expected, hashSize) ? kPGPError_NoErr : kPGPError_SelfTestFailed;
 	
  if( IsPGPError(err))
	{	
		OPTESTPrintF(" %4s %s %s\n", (IsntPGPError(err)?"":"FAIL"), hash_algor_table(algor),  name);
		OPTESTPrintF("   expected:\n");
		dumpLong((PGPByte*)expected, (int)hashSize);
		OPTESTPrintF("   calculated:\n");
		dumpLong(hashBuf, (int)hashSize);
		OPTESTPrintF("\n");
	}
 
/* no reason to do this other than testing */
	PGPResetHash(hashref);  
 
done:
 	if( PGPHashContextRefIsValid( hashref ) )
			PGPFreeHashContext(hashref);
 
	return err;
	
}
  
 
 	
/*
  Run SHA-1 known answer self test 
*/

PGPError TestSHA(	PGPContextRef context)
{
	PGPError		err 		= kPGPError_NoErr;
	PGPError		err1 	= kPGPError_NoErr;
 	unsigned int i;
	
/* Test vectors, first line from each FIPS-180 SHA-1 known answer test */
	typedef struct  {
			PGPHashAlgorithm	algor;
			char				*name;
			char				*msg;
			int					passes;
			PGPByte*			kat;
		} katvector;
	
	katvector kat_vector_array[] = 
	{
		{
			kPGPHashAlgorithm_SHA,
			"One-Block Message",
			"abc",
			1,
			(PGPByte*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C"
			"\x9C\xD0\xD8\x9D"
		},
 		{
			kPGPHashAlgorithm_SHA,
			"Multi-Block Message",
			"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
			1,
			(PGPByte*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5"
			"\xE5\x46\x70\xF1"
		},
 		{
			kPGPHashAlgorithm_SHA,
			"Long Message",
			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
			15625,
			(PGPByte*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31"
			"\x65\x34\x01\x6F"
		},
		{
			kPGPHashAlgorithm_SHA256,
			"One-Block Message",
			"abc",
			1,
			(PGPByte*)"\xBA\x78\x16\xBF\x8F\x01\xCF\xEA\x41\x41\x40\xDE\x5D\xAE\x22\x23"
			"\xB0\x03\x61\xA3\x96\x17\x7A\x9C\xB4\x10\xFF\x61\xF2\x00\x15\xAD"
		},
		
		{
			kPGPHashAlgorithm_SHA256,
			"Multi-Block Message",
			"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
			1,
			(PGPByte*)"\x24\x8D\x6A\x61\xD2\x06\x38\xB8\xE5\xC0\x26\x93\x0C\x3E\x60\x39"
			"\xA3\x3C\xE4\x59\x64\xFF\x21\x67\xF6\xEC\xED\xD4\x19\xDB\x06\xC1"
		},
 		{
			kPGPHashAlgorithm_SHA256,
			"Long Message",
			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
			15625,
			(PGPByte*)"\xCD\xC7\x6E\x5C\x99\x14\xFB\x92\x81\xA1\xC7\xE2\x84\xD7\x3E\x67"
			"\xF1\x80\x9A\x48\xA4\x97\x20\x0E\x04\x6D\x39\xCC\xC7\x11\x2C\xD0"
		},
 		{
			kPGPHashAlgorithm_SHA384,
			"One-Block Message",
			"abc",
			1,
			(PGPByte*)"\xCB\x00\x75\x3F\x45\xA3\x5E\x8B\xB5\xA0\x3D\x69\x9A\xC6\x50\x07"
			"\x27\x2C\x32\xAB\x0E\xDE\xD1\x63\x1A\x8B\x60\x5A\x43\xFF\x5B\xED"
			"\x80\x86\x07\x2B\xA1\xE7\xCC\x23\x58\xBA\xEC\xA1\x34\xC8\x25\xA7"
		},
		{
			kPGPHashAlgorithm_SHA384,
			"Multi-Block Message",
			"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
					"hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
			1,
			(PGPByte*)"\x09\x33\x0C\x33\xF7\x11\x47\xE8\x3D\x19\x2F\xC7\x82\xCD\x1B\x47"
			"\x53\x11\x1B\x17\x3B\x3B\x05\xD2\x2F\xA0\x80\x86\xE3\xB0\xF7\x12"
			"\xFC\xC7\xC7\x1A\x55\x7E\x2D\xB9\x66\xC3\xE9\xFA\x91\x74\x60\x39"
		},
			{
			kPGPHashAlgorithm_SHA384,
			"Long Message",
			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
			15625,
			(PGPByte*)"\x9D\x0E\x18\x09\x71\x64\x74\xCB\x08\x6E\x83\x4E\x31\x0A\x4A\x1C"
			"\xED\x14\x9E\x9C\x00\xF2\x48\x52\x79\x72\xCE\xC5\x70\x4C\x2A\x5B"
			"\x07\xB8\xB3\xDC\x38\xEC\xC4\xEB\xAE\x97\xDD\xD8\x7F\x3D\x89\x85"
		},
		{
			kPGPHashAlgorithm_SHA512,
			"One-Block Message",
			"abc",
			1,
			(PGPByte*)"\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
			"\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
			"\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
			"\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F"
		},
		{
			kPGPHashAlgorithm_SHA512,
			"Multi-Block Message",
			"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
					"hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
			1,
			(PGPByte*)"\x8E\x95\x9B\x75\xDA\xE3\x13\xDA\x8C\xF4\xF7\x28\x14\xFC\x14\x3F"
			"\x8F\x77\x79\xC6\xEB\x9F\x7F\xA1\x72\x99\xAE\xAD\xB6\x88\x90\x18"
			"\x50\x1D\x28\x9E\x49\x00\xF7\xE4\x33\x1B\x99\xDE\xC4\xB5\x43\x3A"
			"\xC7\xD3\x29\xEE\xB6\xDD\x26\x54\x5E\x96\xE5\x5B\x87\x4B\xE9\x09"
		},
		{
			kPGPHashAlgorithm_SHA512,
			"Long Message",
			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
			15625,
			(PGPByte*)"\xE7\x18\x48\x3D\x0C\xE7\x69\x64\x4E\x2E\x42\xC7\xBC\x15\xB4\x63"
			"\x8E\x1F\x98\xB1\x3B\x20\x44\x28\x56\x32\xA8\x03\xAF\xA9\x73\xEB"
			"\xDE\x0F\xF2\x44\x87\x7E\xA6\x0A\x4C\xB0\x43\x2C\xE5\x77\xC3\x1B"
			"\xEB\x00\x9C\x5C\x2C\x49\xAA\x2E\x4E\xAD\xB2\x17\xAD\x8C\xC0\x9B"
		},
	};
	
 
/* run test array */

	for (i = 0; i < sizeof(kat_vector_array)/ sizeof(katvector) ; i++)
	{
		err1 = TestSHAkat(context, 
					kat_vector_array[i].algor,
					kat_vector_array[i].name,
					kat_vector_array[i].msg,
					strlen( (const char *) kat_vector_array[i].msg), 
					kat_vector_array[i].passes,
					kat_vector_array[i].kat ); MARK_ERR(err, err1);;
 	
	}
    	
 	return( err );
 }