cryptacm.h

老外写的加密库cryptlib(版本3.1)

/****************************************************************************
*																			*
*								Mechanism ACLs								*
*						Copyright Peter Gutmann 1999-2003					*
*																			*
****************************************************************************/

#ifndef _CRYPTACM_DEFINED

#define _CRYPTACM_DEFINED

/* The ACL tables for each mechanism class */

static const FAR_BSS MECHANISM_ACL mechanismWrapACL[] = {
	{ MECHANISM_PKCS1,				/* PKCS #1 encrypt */
	  { MKACM_S_OPT( 64, MAX_PKCENCRYPTED_SIZE ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV | ST_CTX_MAC,	/* Ctx containing key */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Wrap PKC context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_UNUSED() } },
	{ MECHANISM_PKCS1_PGP,			/* PKCS #1 encrypt using PGP formatting */
	  { MKACM_S_OPT( 64, MAX_PKCENCRYPTED_SIZE ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV,				/* Ctx containing key */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Wrap PKC context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_UNUSED() } },
	{ MECHANISM_PKCS1_RAW,			/* PKCS #1 encrypt of raw data */
	  { MKACM_S_OPT( 64, CRYPT_MAX_PKCSIZE ),/* Wrapped raw data */
		MKACM_S( 8, CRYPT_MAX_KEYSIZE ),	/* Raw data */
		MKACM_UNUSED(),
		MKACM_O( ST_CTX_PKC,				/* Wrap PKC context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_UNUSED() } },
	{ MECHANISM_CMS,				/* CMS key wrap */
	  { MKACM_S_OPT( 8 + 8, CRYPT_MAX_KEYSIZE + 16 ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV | ST_CTX_MAC,	/* Ctx containing key */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_CONV,				/* Wrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_KEA,				/* KEA key agreement */
	  { MKACM_S( 140, 140 ),				/* sizeof( TEK( MEK ) + Ra ) */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV,				/* Skipjack session key */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Recipient KEA pubkey */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_O( ST_CTX_PKC,				/* Sender KEA privkey */
				 ACL_FLAG_HIGH_STATE ) } },
	{ MECHANISM_PRIVATEKEYWRAP,		/* Private key wrap */
	  { MKACM_S_OPT( 16, MAX_PRIVATE_KEYSIZE ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_PKC,				/* Ctx containing private key */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_O( ST_CTX_CONV,				/* Wrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_PRIVATEKEYWRAP_PKCS8,/* Private key wrap */
	  { MKACM_S_OPT( 16, MAX_PRIVATE_KEYSIZE ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_PKC,				/* Ctx containing private key */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_O( ST_CTX_CONV,				/* Wrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_NONE,
	  { MKACM_END() } }
	};

static const FAR_BSS MECHANISM_ACL mechanismUnwrapACL[] = {
	{ MECHANISM_PKCS1,				/* PKCS #1 decrypt */
	  { MKACM_S_OPT( 60, CRYPT_MAX_PKCSIZE ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV | ST_CTX_MAC,	/* Ctx to contain key */
				 ACL_FLAG_LOW_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Unwrap PKC context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_UNUSED() } },
	{ MECHANISM_PKCS1_PGP,			/* PKCS #1 decrypt using PGP formatting */
	  { MKACM_S_OPT( 60, 4 + ( 2 * CRYPT_MAX_PKCSIZE ) ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_UNUSED(),						/* Placeholder for ctx to contain key */
		MKACM_O( ST_CTX_PKC,				/* Unwrap PKC context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_UNUSED() } },
	{ MECHANISM_PKCS1_RAW,			/* PKCS #1 decrypt of raw data */
	  { MKACM_S_OPT( 64, CRYPT_MAX_PKCSIZE ),/* Wrapped raw data */
		MKACM_S( 8, CRYPT_MAX_PKCSIZE ),	/* Raw data */
		MKACM_UNUSED(),
		MKACM_O( ST_CTX_PKC,				/* Unwrap PKC context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ),
		MKACM_UNUSED() } },
	{ MECHANISM_CMS,				/* CMS key unwrap */
	  { MKACM_S( 8 + 8, CRYPT_MAX_KEYSIZE + 16 ),/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV | ST_CTX_MAC,	/* Ctx to contain key */
				 ACL_FLAG_LOW_STATE ),
		MKACM_O( ST_CTX_CONV,				/* Unwrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_KEA,				/* KEA key agreement */
	  { MKACM_S( 140, 140 ),				/* sizeof( TEK( MEK ) + Ra ) */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_CONV,				/* Skipjack session key */
				 ACL_FLAG_LOW_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Recipient KEA privkey */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Sender KEA pubkey */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ) } },
	{ MECHANISM_PRIVATEKEYWRAP,		/* Private key unwrap */
	  { MKACM_S( 16, MAX_PRIVATE_KEYSIZE ),	/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_PKC,				/* Ctx to contain private key */
				 ACL_FLAG_LOW_STATE ),
		MKACM_O( ST_CTX_CONV,				/* Unwrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_PRIVATEKEYWRAP_PGP,	/* Private key unwrap */
	  { MKACM_S( 16, MAX_PRIVATE_KEYSIZE ),	/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_PKC,				/* Ctx to contain private key */
				 ACL_FLAG_LOW_STATE ),
		MKACM_O( ST_CTX_CONV,				/* Unwrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_PRIVATEKEYWRAP_OPENPGP,	/* Private key unwrap */
	  { MKACM_S( 16, MAX_PRIVATE_KEYSIZE ),	/* Wrapped key */
		MKACM_S_NONE(),
		MKACM_O( ST_CTX_PKC,				/* Ctx to contain private key */
				 ACL_FLAG_LOW_STATE ),
		MKACM_O( ST_CTX_CONV,				/* Unwrap context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_UNUSED() } },
	{ MECHANISM_NONE,
	  { MKACM_END() } }
	};

static const FAR_BSS MECHANISM_ACL mechanismSignACL[] = {
	{ MECHANISM_PKCS1,				/* PKCS #1 sign */
	  { MKACM_S_OPT( 64, CRYPT_MAX_PKCSIZE ),/* Signature */
		MKACM_O( ST_CTX_HASH,				/* Hash context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Signing context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ) } },
	{ MECHANISM_NONE,
	  { MKACM_END() } }
	};

static const FAR_BSS MECHANISM_ACL mechanismSigCheckACL[] = {
	{ MECHANISM_PKCS1,				/* PKCS #1 sig check */
	  { MKACM_S( 60, CRYPT_MAX_PKCSIZE ),	/* Signature */
		MKACM_O( ST_CTX_HASH,				/* Hash context */
				 ACL_FLAG_HIGH_STATE ),
		MKACM_O( ST_CTX_PKC,				/* Sig.check context */
				 ACL_FLAG_HIGH_STATE | ACL_FLAG_ROUTE_TO_CTX ) } },
	{ MECHANISM_NONE,
	  { MKACM_END() } }
	};

static const FAR_BSS MECHANISM_ACL mechanismDeriveACL[] = {
	{ MECHANISM_PKCS5,				/* PKCS #5 derive */
	  { MKACM_S( 1, CRYPT_MAX_KEYSIZE ),	/* Key data */
		MKACM_S( 2, MAX_ATTRIBUTE_SIZE ),	/* Keying material */
		MKACM_N( CRYPT_ALGO_HMAC_SHA, CRYPT_ALGO_HMAC_SHA ),/* Hash algo */
		MKACM_S( 4, 512 ),					/* Salt */
		MKACM_N( 1, INT_MAX ) } },			/* Iterations */
	{ MECHANISM_SSL,				/* SSL derive */
	  { MKACM_S( 48, 512 ),					/* Master secret/key data */
		MKACM_S( 48, 512 ),					/* Premaster secret/master secret */
		MKACM_N( CRYPT_USE_DEFAULT, CRYPT_USE_DEFAULT ),/* SSL uses dual hash */
		MKACM_S( 64, 64 ),					/* Salt */
		MKACM_N( 1, 1 ) } },				/* Iterations */
	{ MECHANISM_TLS,				/* TLS derive (the odd lower bounds on the output
											   and salt are needed when generating
											   the TLS hashed MAC and (for the salt)
											   when generating a master secret from
											   a fixed shared key) */
	  { MKACM_S( 12, 512 ),					/* Master secret/key data (usually 48) */
		MKACM_S( 48, 512 ),					/* Premaster secret/master secret */
		MKACM_N( CRYPT_USE_DEFAULT, CRYPT_USE_DEFAULT ),/* TLS uses dual hash */
		MKACM_S( 13, 512 ),					/* Salt (usually 64) */
		MKACM_N( 1, 1 ) } },				/* Iterations */
	{ MECHANISM_CMP,				/* CMP/Entrust derive */
	  { MKACM_S( 20, 20 ),					/* HMAC-SHA key */
		MKACM_S( 1, 512 ),					/* Key data */
		MKACM_N( CRYPT_ALGO_SHA, CRYPT_ALGO_SHA ),/* Hash algo */
		MKACM_S( 1, 512 ),					/* Salt */
		MKACM_N( 1, INT_MAX ) } },			/* Iterations */
	{ MECHANISM_PGP,				/* OpenPGP S2K derive */
	  { MKACM_S( 16, CRYPT_MAX_KEYSIZE ),	/* Key data */
		MKACM_S( 2, MAX_ATTRIBUTE_SIZE ),	/* Keying material */
		MKACM_N( CRYPT_ALGO_MD5, CRYPT_ALGO_RIPEMD160 ),/* Hash algo */
		MKACM_S( 8, 8 ),					/* Salt */
		MKACM_N( 0, INT_MAX ) } },			/* Iterations (0 = don't iterate) */
	{ MECHANISM_PKCS12,				/* PKCS #12 derive */
	  { MKACM_S( 20, 20 ),					/* Key data */
		MKACM_S( 2, CRYPT_MAX_TEXTSIZE ),	/* Keying material */
		MKACM_N( CRYPT_ALGO_SHA, CRYPT_ALGO_SHA ),/* Hash algo */
		MKACM_S( 9, 9 ),					/* Salt (+ ID byte) */
		MKACM_N( 1, INT_MAX ) } },			/* Iterations */
	{ MECHANISM_NONE,
	  { MKACM_END() } }
	};

/* Functions to implement the checks in the mechanism ACL tables */

static int preDispatchCheckMechanismWrapAccess( const int objectHandle,
												const MESSAGE_TYPE message,
												const void *messageDataPtr,
												const int messageValue,
												const void *dummy )
	{
	const MECHANISM_WRAP_INFO *mechanismInfo = \
				( MECHANISM_WRAP_INFO * ) messageDataPtr;
	const MECHANISM_ACL *mechanismACL = \
				( ( message & MESSAGE_MASK ) == MESSAGE_DEV_EXPORT ) ? \
				mechanismWrapACL : mechanismUnwrapACL;
	BOOLEAN isRawMechanism;
	int contextHandle, i;

	/* Precondition */
	PRE( isValidObject( objectHandle ) );
	PRE( message == MESSAGE_DEV_EXPORT || message == IMESSAGE_DEV_EXPORT || \
		 message == MESSAGE_DEV_IMPORT || message == IMESSAGE_DEV_IMPORT );
	PRE( messageDataPtr != NULL );
	PRE( messageValue == MECHANISM_PKCS1 || \
		 messageValue == MECHANISM_PKCS1_PGP || \
		 messageValue == MECHANISM_PKCS1_RAW || \
		 messageValue == MECHANISM_CMS || \
		 messageValue == MECHANISM_KEA || \
		 messageValue == MECHANISM_PRIVATEKEYWRAP || \
		 messageValue == MECHANISM_PRIVATEKEYWRAP_PKCS8 || \
		 messageValue == MECHANISM_PRIVATEKEYWRAP_PGP || \
		 messageValue == MECHANISM_PRIVATEKEYWRAP_OPENPGP );

	/* Find the appropriate ACL for this mechanism */
	for( i = 0; mechanismACL[ i ].type != messageValue && \
				mechanismACL[ i ].type != MECHANISM_NONE; i++ );
	mechanismACL = &mechanismACL[ i ];
	isRawMechanism = \