rsa.c

这是一个应用软件,用于处理大数,里面包含一些小的实用的软件,如生成 素数 ,大数阶乘.

/* RSA.c: implementation of the RSA class. */

#include "RSA.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


#ifdef  __cplusplus
extern "C"
{
#endif

	const BOOL RSA_CheckParam( const LPRSA pRSA, const BYTE byCheckItem );
	void RSA_GeneratePublicKey( LPRSA pRSA );
	void RSA_GeneratePrivateKey( LPRSA pRSA );

#ifdef  __cplusplus
}
#endif


const BOOL RSA_Init( LPRSA pRSA )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return FALSE;
	}

	pRSA->E = HX_new();
	pRSA->P = HX_new();
	pRSA->Q = HX_new();
	pRSA->N = HX_new();
	pRSA->D = HX_new();

	pRSA->OM = HX_new();
	pRSA->EM = HX_new();
	pRSA->DM = HX_new();

	HX_set_u32( pRSA->E, RSA_NORMALLY );
	pRSA->byStatus = BY_CHECK_E;
	pRSA->bHex = TRUE;

	return TRUE;
}

void RSA_free( LPRSA pRSA )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return;
	}

	HX_delete( pRSA->E );
	HX_delete( pRSA->P );
	HX_delete( pRSA->Q );
	HX_delete( pRSA->N );
	HX_delete( pRSA->D );

	HX_delete( pRSA->OM );
	HX_delete( pRSA->EM );
	HX_delete( pRSA->DM );
}

void RSA_SetHex( LPRSA pRSA, const BOOL bHex /*= TRUE*/ )
{
	pRSA->bHex = bHex;
}

const BOOL RSA_GeneratePrime( LPRSA pRSA, UINT32 * const pKeyBits )
{
	UINT32 u32KeyBits = DEFAULTBITS;
	UINT32 u32Bits_P, u32Bits_Q;

	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return FALSE;
	}

	if ( CHECK_FAIL_E( pRSA->byStatus ))
	{
		return FALSE;
	}

	if ( NULL != pKeyBits )
	{
		if ( !( MINBITS <= *pKeyBits && *pKeyBits <= MAXBITS ))
		{
			*pKeyBits = DEFAULTBITS;
		}

		u32KeyBits = *pKeyBits;
	}

	u32Bits_P = u32KeyBits / 2;
	u32Bits_Q = u32KeyBits - u32Bits_P;

	// 无需重复检测
	pRSA->byStatus = BY_CHECK_E | BY_CHECK_P | BY_CHECK_Q;

	for( ; ; )
	{
		HX_generatePrime( pRSA->P, u32Bits_P );
		if ( RSA_CheckParam( pRSA, BY_CHECK_P_1 ) )
		{
			break;
		}
	}

	for( ; ; )
	{
		HX_generatePrime( pRSA->Q, u32Bits_Q );
		if ( RSA_CheckParam( pRSA, BY_CHECK_PQ ) && RSA_CheckParam( pRSA, BY_CHECK_Q_1 ) )
		{
			break;
		}
	}

//	if ( RSA_PQ_OK( pRSA->byStatus ))
	{
		RSA_GeneratePublicKey( pRSA );
		RSA_GeneratePrivateKey( pRSA );
	}

	return TRUE;
}

const BYTE RSA_SetParam( LPRSA pRSA, const LPCTSTR lpszString, const RSAParam enumRSAParam /*= RSA_OM*/ )
{
	typedef HHUGEINTX (*pfHX_setStr)( HHUGEINTX, const LPCTSTR );
	const pfHX_setStr pHX_setStr = ( pRSA->bHex ) ? HX_setHexStr : HX_set_str;

	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return RSA_GetStatus( pRSA );
	}

	switch( enumRSAParam )
	{
	case RSA_E:
		HX_abs( (*pHX_setStr)( pRSA->E, lpszString ));

		if ( RSA_CheckParam( pRSA, BY_CHECK_E ))
		{
			if ( !CHECK_FAIL_P( pRSA->byStatus )) RSA_CheckParam( pRSA, BY_CHECK_P_1 );
			if ( !CHECK_FAIL_Q( pRSA->byStatus )) RSA_CheckParam( pRSA, BY_CHECK_Q_1 );

			if ( RSA_PQ_OK( pRSA->byStatus ))
			{
				RSA_GeneratePublicKey( pRSA );
				RSA_GeneratePrivateKey( pRSA );
			}
		}
		break;

	case RSA_P:
		HX_abs( (*pHX_setStr)( pRSA->P, lpszString ));

		RSA_CheckParam( pRSA, BY_CHECK_PQ ) \
			&& RSA_CheckParam( pRSA, BY_CHECK_P ) \
			&& RSA_CheckParam( pRSA, BY_CHECK_P_1 );

		if ( RSA_PQ_OK( pRSA->byStatus ))
		{
			RSA_GeneratePublicKey( pRSA );
			RSA_GeneratePrivateKey( pRSA );
		}
		else
		{
			pRSA->byStatus &= (BYTE)~BY_PxQ_N;
		}
		break;

	case RSA_Q:
		HX_abs( (*pHX_setStr)( pRSA->Q, lpszString ));

		RSA_CheckParam( pRSA, BY_CHECK_PQ ) \
			&& RSA_CheckParam( pRSA, BY_CHECK_Q ) \
			&& RSA_CheckParam( pRSA, BY_CHECK_Q_1 );

		if ( RSA_PQ_OK( pRSA->byStatus ))
		{
			RSA_GeneratePublicKey( pRSA );
			RSA_GeneratePrivateKey( pRSA );
		}
		else
		{
			pRSA->byStatus &= (BYTE)~BY_PxQ_N;
		}
		break;

	case RSA_N:		// 一般它仅是 Get 而不是 Set!
		HX_abs( (*pHX_setStr)( pRSA->N, lpszString ));

		// 临时借用 EM
		if ( 0 == HX_compare_hx( pRSA->N, HX_mul( pRSA->EM, pRSA->P, pRSA->Q )))
		{
			pRSA->byStatus |= BY_PxQ_N;
		}
		else
		{
			pRSA->byStatus &= (BYTE)~BY_PxQ_N;
		}
		break;

	case RSA_D:		// 一般它仅是 Get 而不是 Set !
		HX_abs( (*pHX_setStr)( pRSA->D, lpszString ));
		break;

	case RSA_OM:
		HX_abs( HX_setText( pRSA->OM, lpszString ));

		RSA_CheckParam( pRSA, BY_CHECK_M );
		break;

	case RSA_EM:	// 一般它仅是 Get 而不是 Set !
		HX_abs( (*pHX_setStr)( pRSA->EM, lpszString ));
		break;

	case RSA_DM:	// 一般它仅是 Get 而不是 Set !
		HX_abs( HX_setText( pRSA->DM, lpszString ));
		break;

	default:
		break;
	}

	return RSA_GetStatus( pRSA );
}

const BYTE RSA_GetStatus( LPRSA pRSA )
{
	return pRSA->byStatus;
}

const LPCTSTR RSA_GetParam( const LPRSA pRSA, const RSAParam enumRSAParam /*= RSA_EM*/ )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return NULL;
	}

	// 注意：未注册用户，“(LPCTSTR)”返回的字串可能有“<HugeCalc>”字样的干扰
	// 但仅影响输出字串，内部数据并不受影响；函数“GetText()”无干扰
	if ( pRSA->bHex )
	{
		switch( enumRSAParam )
		{
		case RSA_P:		return HX_getHexStr( pRSA->P, FS_NORMAL, NULL );
		case RSA_Q:		return HX_getHexStr( pRSA->Q, FS_NORMAL, NULL );
		case RSA_E:		return HX_getHexStr( pRSA->E, FS_NORMAL, NULL );
		case RSA_N:		return HX_getHexStr( pRSA->N, FS_NORMAL, NULL );
		case RSA_D:		return HX_getHexStr( pRSA->D, FS_NORMAL, NULL );
		case RSA_OM:	return HX_getText( pRSA->OM );	// 该函数不受干扰
		case RSA_EM:	return HX_getHexStr( pRSA->EM, FS_NORMAL, NULL );
		case RSA_DM:	return HX_getText( pRSA->DM );	// 该函数不受干扰
		default:
			return NULL;
		}
	}
	else
	{
		switch( enumRSAParam )
		{
		case RSA_P:		return HX_getStrRadix( pRSA->P, 10, NULL, FS_NORMAL, 3, NULL );
		case RSA_Q:		return HX_getStrRadix( pRSA->Q, 10, NULL, FS_NORMAL, 3, NULL );
		case RSA_E:		return HX_getStrRadix( pRSA->E, 10, NULL, FS_NORMAL, 3, NULL );
		case RSA_N:		return HX_getStrRadix( pRSA->N, 10, NULL, FS_NORMAL, 3, NULL );
		case RSA_D:		return HX_getStrRadix( pRSA->D, 10, NULL, FS_NORMAL, 3, NULL );
		case RSA_OM:	return HX_getText( pRSA->OM );	// 该函数不受干扰
		case RSA_EM:	return HX_getStrRadix( pRSA->EM, 10, NULL, FS_NORMAL, 3, NULL );
		case RSA_DM:	return HX_getText( pRSA->DM );	// 该函数不受干扰
		default:
			return NULL;
		}
	}
}

const UINT RSA_GetParamBits( const LPRSA pRSA, const RSAParam enumRSAParam /*= RSA_N*/ )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return 0;
	}

	switch( enumRSAParam )
	{
	case RSA_P:		return HX_getBits( pRSA->P );
	case RSA_Q:		return HX_getBits( pRSA->Q );
	case RSA_E:		return HX_getBits( pRSA->E );
	case RSA_N:		return HX_getBits( pRSA->N );
	case RSA_D:		return HX_getBits( pRSA->D );
	case RSA_OM:	return HX_getBits( pRSA->OM );
	case RSA_EM:	return HX_getBits( pRSA->EM );
	case RSA_DM:	return HX_getBits( pRSA->DM );
	default:
		return 0;
	}
}

const LPCTSTR RSA_EncryptMessage( LPRSA pRSA, const LPCTSTR lpszText )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return NULL;
	}

	RSA_SetParam( pRSA, lpszText, RSA_OM );

	// EM = OM^E mod N
	HX_powMod( pRSA->EM, pRSA->OM, pRSA->E, pRSA->N );

	// 防止异常（如对0取模运算）而终止服务
	HC_setTerminate( FALSE );

	return RSA_GetParam( pRSA, RSA_EM );
}

const LPCTSTR RSA_DecryptMessage( LPRSA pRSA, const LPCTSTR lpszHexNum )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return NULL;
	}

#if 0
	RSA_SetParam( pRSA, lpszHexNum, RSA_EM );
#endif

	// DM = EM^D mod N
	HX_powMod( pRSA->DM, pRSA->EM, pRSA->D, pRSA->N );

	// 防止异常（如对0取模运算）而终止服务
	HC_setTerminate( FALSE );

	return RSA_GetParam( pRSA, RSA_DM );
}



const BOOL RSA_CheckParam( const LPRSA pRSA, const BYTE byCheckItem /*= 0xFF*/ )
{
	BOOL bCheckPass = FALSE;
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return bCheckPass;
	}

	switch( byCheckItem )
	{
	case BY_CHECK_E: // E > 1 && E is an odd number? ( otherwise, Gcd(P-1, E) can't equal to 1 )
		bCheckPass = ( 0 < HX_compare_u32( pRSA->E, 1 )) && HX_isOdd( pRSA->E );
		break;

	case BY_CHECK_PQ: // P <> Q ?
		bCheckPass = ( 0 != HX_compare_hx( pRSA->P, pRSA->Q ));
		break;

	case BY_CHECK_P: // P is a prime ?
		bCheckPass = HX_isPrime( pRSA->P );
		break;

	case BY_CHECK_Q: // Q is a prime ?
		bCheckPass = HX_isPrime( pRSA->Q );
		break;

	case BY_CHECK_P_1: // Gcd( P-1, E ) == 1 ?
		// 临时借用 EM, DM
		HX_sub_u32( pRSA->EM, pRSA->P, 1 );
		HX_gcd( pRSA->DM, pRSA->EM, pRSA->E );
		bCheckPass = ( 0 == HX_compare_u32( pRSA->DM, 1 ));
		break;

	case BY_CHECK_Q_1: // Gcd( Q-1, E ) == 1 ?
		// 临时借用 EM, DM
		HX_sub_u32( pRSA->EM, pRSA->Q, 1 );
		HX_gcd( pRSA->DM, pRSA->EM, pRSA->E );
		bCheckPass = ( 0 == HX_compare_u32( pRSA->DM, 1 ));
		break;

	case BY_CHECK_M: // OM < N ?
		bCheckPass = ( 0 > HX_compare_hx( pRSA->OM, pRSA->N ));
		break;

	default:
		return FALSE;
	}

	if ( bCheckPass )
	{
		pRSA->byStatus |= byCheckItem;
	}
	else
	{
		pRSA->byStatus &= (BYTE)~byCheckItem;
	}

	return bCheckPass;
}


void RSA_GeneratePublicKey( LPRSA pRSA )
{
	if ( HC_LICENSE_NONE == HC_getLicenseLevel())
	{
		return;
	}

	// N = P * Q
	HX_mul( pRSA->N, pRSA->P, pRSA->Q );

	pRSA->byStatus |= BY_PxQ_N;
}

void RSA_GeneratePrivateKey( LPRSA pRSA )
{
	if ( HC_LICENSE_NONE != HC_getLicenseLevel())
	{
		// D = E^(-1) mod ((P-1)*(Q-1))

		HHUGEINTX P_1 = HX_new();
		HHUGEINTX Q_1 = HX_new();
		HHUGEINTX P_1xQ_1 = HX_new();

		HX_mul( P_1xQ_1, HX_sub_u32( P_1, pRSA->P, 1 ), HX_sub_u32( Q_1, pRSA->Q, 1 ));
		HX_invertMod( pRSA->D, pRSA->E, P_1xQ_1 );

		HX_delete( P_1 );
		HX_delete( Q_1 );
		HX_delete( P_1xQ_1 );

		// 防止异常（如对0取模运算）而终止服务
		HC_setTerminate( FALSE );
	}
}