rsa.cpp

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

// RSA.cpp: implementation of the CRSA class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "RSA.hpp"

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

#pragma message( "automatic link to ../../../HugeCalc_API/CppAPI/Lib/HugeCalc.lib" )
#pragma comment( lib, "../../../HugeCalc_API/CppAPI/Lib/HugeCalc.lib" )

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CRSA::CRSA( void )
: E( RSA_NORMALLY ) \
, P(), Q() \
, N(), D() \
, m_byStatus( BY_CHECK_E ), m_bHex( TRUE ), OM(), EM(), DM()
{
}

CRSA::~CRSA()
{
}

void CRSA::SetHex( const BOOL bHex /*= TRUE*/ )
{
	m_bHex = bHex;
}

const BOOL CRSA::GeneratePrime( UINT32 * const pKeyBits /*= NULL*/ )
{
	if ( HC_LICENSE_NONE == HugeCalc::GetLicenseLevel())
	{
		return FALSE;
	}

	if ( CHECK_FAIL_E( m_byStatus ))
	{
		return FALSE;
	}

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

		u32KeyBits = *pKeyBits;
	}

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

	// 无需重复检测
	m_byStatus = BY_CHECK_E | BY_CHECK_P | BY_CHECK_Q;

	for( ; ; )
	{
		P.GeneratePrime( u32Bits_P );
		if ( CheckParam( BY_CHECK_P_1 ) )
		{
			break;
		}
	}

	for( ; ; )
	{
		Q.GeneratePrime( u32Bits_Q );
		if ( CheckParam( BY_CHECK_PQ ) && CheckParam( BY_CHECK_Q_1 ) )
		{
			break;
		}
	}

//	if ( RSA_PQ_OK( m_byStatus ))
	{
		GeneratePublicKey();
		GeneratePrivateKey();
	}

	return TRUE;
}

const BYTE CRSA::SetParam( const LPCTSTR lpszString, const RSAParam enumRSAParam /*= RSA_OM*/ )
{
	if ( HC_LICENSE_NONE == HugeCalc::GetLicenseLevel())
	{
		return GetStatus();
	}

	switch( enumRSAParam )
	{
	case RSA_E:
		if ( m_bHex )
		{
			E.SetHexStr( lpszString ).Abs();
		}
		else
		{
			( E = lpszString ).Abs();
		}

		if ( CheckParam( BY_CHECK_E ))
		{
			if ( !CHECK_FAIL_P( m_byStatus )) CheckParam( BY_CHECK_P_1 );
			if ( !CHECK_FAIL_Q( m_byStatus )) CheckParam( BY_CHECK_Q_1 );

			if ( RSA_PQ_OK( m_byStatus ))
			{
				GeneratePublicKey();
				GeneratePrivateKey();
			}
		}
		break;

	case RSA_P:
		if ( m_bHex )
		{
			P.SetHexStr( lpszString ).Abs();
		}
		else
		{
			( P = lpszString ).Abs();
		}

		CheckParam( BY_CHECK_PQ ) \
			&& CheckParam( BY_CHECK_P ) \
			&& CheckParam( BY_CHECK_P_1 );

		if ( RSA_PQ_OK( m_byStatus ))
		{
			GeneratePublicKey();
			GeneratePrivateKey();
		}
		else
		{
			m_byStatus &= (BYTE)~BY_PxQ_N;
		}
		break;

	case RSA_Q:
		if ( m_bHex )
		{
			Q.SetHexStr( lpszString ).Abs();
		}
		else
		{
			( Q = lpszString ).Abs();
		}

		CheckParam( BY_CHECK_PQ ) \
			&& CheckParam( BY_CHECK_Q ) \
			&& CheckParam( BY_CHECK_Q_1 );

		if ( RSA_PQ_OK( m_byStatus ))
		{
			GeneratePublicKey();
			GeneratePrivateKey();
		}
		else
		{
			m_byStatus &= (BYTE)~BY_PxQ_N;
		}
		break;

	case RSA_N:		// 一般它仅是 Get 而不是 Set!
		if ( m_bHex )
		{
			N.SetHexStr( lpszString ).Abs();
		}
		else
		{
			( N = lpszString ).Abs();
		}

		if ( N == CHugeIntX().Mul( P, Q ))
		{
			m_byStatus |= BY_PxQ_N;
		}
		else
		{
			m_byStatus &= (BYTE)~BY_PxQ_N;
		}
		break;

	case RSA_D:		// 一般它仅是 Get 而不是 Set !
		if ( m_bHex )
		{
			D.SetHexStr( lpszString ).Abs();
		}
		else
		{
			( D = lpszString ).Abs();
		}
		break;

	case RSA_OM:
		OM.SetText( lpszString ).Abs();

		CheckParam( BY_CHECK_M );
		break;

	case RSA_EM:	// 一般它仅是 Get 而不是 Set !
		if ( m_bHex )
		{
			EM.SetHexStr( lpszString ).Abs();
		}
		else
		{
			( EM = lpszString ).Abs();
		}
		break;

	case RSA_DM:	// 一般它仅是 Get 而不是 Set !
		DM.SetText( lpszString ).Abs();
		break;

	default:
		break;
	}

	return GetStatus();
}

const BYTE CRSA::GetStatus( void ) const
{
	return m_byStatus;
}

const LPCTSTR CRSA::GetParam( const RSAParam enumRSAParam /*= RSA_EM*/ ) const
{
	if ( HC_LICENSE_NONE == HugeCalc::GetLicenseLevel())
	{
		return NULL;
	}

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

const UINT CRSA::GetParamBits( const RSAParam enumRSAParam /*= RSA_N*/ ) const
{
	switch( enumRSAParam )
	{
	case RSA_P:		return P.GetBits();
	case RSA_Q:		return Q.GetBits();
	case RSA_E:		return E.GetBits();
	case RSA_N:		return N.GetBits();
	case RSA_D:		return D.GetBits();
	case RSA_OM:	return OM.GetBits();
	case RSA_EM:	return EM.GetBits();
	case RSA_DM:	return DM.GetBits();
	default:
		return 0;
	}
}

const LPCTSTR CRSA::EncryptMessage( const LPCTSTR lpszText ) const
{
	const_cast< CRSA * >( this )->SetParam( lpszText, RSA_OM );

//	if ( !Check( CHECK_OM ))
//	{
//		// OM >= N
//		return NULL;
//	}

	// EM = OM^E mod N
	EM.PowMod( OM, E, N );

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

	return GetParam( RSA_EM );
}

const LPCTSTR CRSA::DecryptMessage( const LPCTSTR lpszHexNum ) const
{
#if 0
	const_cast< CRSA * >( this ) -> SetParam( lpszHexNum, RSA_EM );
#endif

	// DM = EM^D mod N
	DM.PowMod( EM, D, N );

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

	return GetParam( RSA_DM );
}

const BOOL CRSA::CheckParam( const BYTE byCheckItem /*= 0xFF*/ ) const
{
	if ( HC_LICENSE_NONE == HugeCalc::GetLicenseLevel())
	{
		return FALSE;
	}

	BOOL 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 = ( E > 1 ) && E.IsOdd();
		break;

	case BY_CHECK_PQ: // P <> Q ?
		bCheckPass = ( P != Q );
		break;

	case BY_CHECK_P: // P is a prime ?
		bCheckPass = P.IsPrime();
		break;

	case BY_CHECK_Q: // Q is a prime ?
		bCheckPass = Q.IsPrime();
		break;

	case BY_CHECK_P_1: // Gcd( P-1, E ) == 1 ?
		bCheckPass = ( CHugeIntX().Gcd((--CHugeIntX( P )), E ) == 1 );
		break;

	case BY_CHECK_Q_1: // Gcd( Q-1, E ) == 1 ?
		bCheckPass = ( CHugeIntX().Gcd((--CHugeIntX( Q )), E ) == 1 );
		break;

	case BY_CHECK_M: // OM < N ?
		bCheckPass = ( OM < N );
		break;

	default:
		return FALSE;
	}

	if ( bCheckPass )
	{
		m_byStatus |= byCheckItem;
	}
	else
	{
		m_byStatus &= (BYTE)~byCheckItem;
	}

	return bCheckPass;
}

void CRSA::GeneratePublicKey( void )
{
	// N = P * Q
	N.Mul( P, Q );

	m_byStatus |= BY_PxQ_N;
}

void CRSA::GeneratePrivateKey( void )
{
	// D = E^(-1) mod ((P-1)*(Q-1))
	D.InvertMod( E, (--CHugeIntX( P )) * (--CHugeIntX( Q )));

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