eccrypto.cpp

一个DES,RSA,MD5,RC4等加密算法的源码

			1),
		EcRecommendedParameters<ECP>(ASN1::secp160k1(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73",
			"0000000000000000000000000000000000000000",
			"0000000000000000000000000000000000000007",
			"043B4C382CE37AA192A4019E763036F4F5DD4D7EBB938CF935318FDCED6BC28286531733C3F03C4FEE",
			"0100000000000000000001B8FA16DFAB9ACA16B6B3",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp256k1(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F",
			"0000000000000000000000000000000000000000000000000000000000000000",
			"0000000000000000000000000000000000000000000000000000000000000007",
			"0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8",
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp128r1(),
			"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF",
			"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC",
			"E87579C11079F43DD824993C2CEE5ED3",
			"04161FF7528B899B2D0C28607CA52C5B86CF5AC8395BAFEB13C02DA292DDED7A83",
			"FFFFFFFE0000000075A30D1B9038A115",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp128r2(),
			"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF",
			"D6031998D1B3BBFEBF59CC9BBFF9AEE1",
			"5EEEFCA380D02919DC2C6558BB6D8A5D",
			"047B6AA5D85E572983E6FB32A7CDEBC14027B6916A894D3AEE7106FE805FC34B44",
			"3FFFFFFF7FFFFFFFBE0024720613B5A3",
			4),
		EcRecommendedParameters<ECP>(ASN1::secp160r2(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73",
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC70",
			"B4E134D3FB59EB8BAB57274904664D5AF50388BA",
			"0452DCB034293A117E1F4FF11B30F7199D3144CE6DFEAFFEF2E331F296E071FA0DF9982CFEA7D43F2E",
			"0100000000000000000000351EE786A818F3A1A16B",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp192k1(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37",
			"000000000000000000000000000000000000000000000000",
			"000000000000000000000000000000000000000000000003",
			"04DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D",
			"FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp224k1(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFE56D",
			"00000000000000000000000000000000000000000000000000000000",
			"00000000000000000000000000000000000000000000000000000005",
			"04A1455B334DF099DF30FC28A169A467E9E47075A90F7E650EB6B7A45C7E089FED7FBA344282CAFBD6F7E319F7C0B0BD59E2CA4BDB556D61A5",
			"010000000000000000000000000001DCE8D2EC6184CAF0A971769FB1F7",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp224r1(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001",
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE",
			"B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4",
			"04B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34",
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp384r1(),
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF",
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC",
			"B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF",
			"04AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB73617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F",
			"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973",
			1),
		EcRecommendedParameters<ECP>(ASN1::secp521r1(),
			"01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
			"01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC",
			"0051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00",
			"0400C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650",
			"01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409",
			1),
	};
	begin = rec;
	end = rec + sizeof(rec)/sizeof(rec[0]);
}

template <class EC> OID ECParameters<EC>::GetNextRecommendedParametersOID(const OID &oid)
{
	const EcRecommendedParameters<EC> *begin, *end;
	GetRecommendedParameters(begin, end);
	// VC60 workaround: problem with operator< if using upper_bound
	const EcRecommendedParameters<EC> *it = std::lower_bound(begin, end, oid);
	if (it != end && it->oid == oid)
		++it;
	return (it == end ? OID() : it->oid);
}

template <class EC> void ECParameters<EC>::LoadRecommendedParameters(const OID &oid)
{
	const EcRecommendedParameters<EC> *begin, *end;
	GetRecommendedParameters(begin, end);
	const EcRecommendedParameters<EC> *it = std::lower_bound(begin, end, oid);
	if (it == end || it->oid != oid)
		throw UnknownOID();

	const EcRecommendedParameters<EC> &param = *it;
	m_oid = oid;
	m_ec.reset(param.NewEC());
	StringSource ssG(param.g, true, new HexDecoder);
	bool result = m_ec->DecodePoint(m_G, ssG, ssG.MaxRetrieveable());
	assert(result);
	StringSource ssN(param.n, true, new HexDecoder);
	m_n.Decode(ssN, ssN.MaxRetrieveable());
	m_cofactorPresent = true;
	m_k = param.h;

	m_Gpc.SetCurveAndBase(GetCurve(), m_G);
}

template <class EC>
void ECParameters<EC>::BERDecode(BufferedTransformation &bt)
{
	byte b;
	if (!bt.Peek(b))
		BERDecodeError();
	if (b == OBJECT_IDENTIFIER)
		LoadRecommendedParameters(OID(bt));
	else
	{
		BERSequenceDecoder seq(bt);
		m_ec.reset(new EC(seq));
		m_G = m_ec->BERDecodePoint(seq);
		m_n.BERDecode(seq);
		m_cofactorPresent = !seq.EndReached();
		if (m_cofactorPresent)
			m_k.BERDecode(seq);
		seq.MessageEnd();

		m_Gpc.SetCurveAndBase(GetCurve(), m_G);
	}
}

template <class EC>
void ECParameters<EC>::DEREncode(BufferedTransformation &bt) const
{
	if (m_encodeAsOID && !m_oid.m_values.empty())
		m_oid.DEREncode(bt);
	else
	{
		DERSequenceEncoder seq(bt);
		m_ec->DEREncode(seq);
		m_ec->DEREncodePoint(seq, m_G, m_compress);
		m_n.DEREncode(seq);
		if (m_cofactorPresent)
			m_k.DEREncode(seq);
		seq.MessageEnd();
	}
}

template <class EC>
bool ECParameters<EC>::ValidateParameters(RandomNumberGenerator &rng) const
{
	Integer q = m_ec->FieldSize(), qSqrt = q.SquareRoot();

	return m_ec->ValidateParameters(rng) && m_n!=q && m_n>4*qSqrt && VerifyPrime(rng, m_n)
		&& m_ec->VerifyPoint(m_G) && !m_G.identity && m_ec->Multiply(m_n, m_G).identity
		&& m_k==(q+2*qSqrt+1)/m_n && CheckMOVCondition(q, m_n);
}

template <class EC>
void ECParameters<EC>::Precompute(unsigned int precomputationStorage)
{
	m_Gpc.Precompute(ExponentBitLength(), precomputationStorage);
}

template <class EC>
void ECParameters<EC>::LoadPrecomputation(BufferedTransformation &bt)
{
	m_Gpc.Load(bt);
}

template <class EC>
void ECParameters<EC>::SavePrecomputation(BufferedTransformation &bt) const
{
	m_Gpc.Save(bt);
}

// ******************************************************************

template <class EC>
ECPublicKey<EC>::ECPublicKey(BufferedTransformation &bt)
{
	BERSequenceDecoder seq(bt);
		BERSequenceDecoder algorithm(seq);
			if (OID(algorithm) != ASN1::id_ecPublicKey())
				BERDecodeError();
			ECParameters<EC>::BERDecode(algorithm);
		algorithm.MessageEnd();
		SecByteBlock subjectPublicKey;
		unsigned int unusedBits;
		BERDecodeBitString(seq, subjectPublicKey, unusedBits);
		if (!(unusedBits == 0 && m_ec->DecodePoint(m_Q, subjectPublicKey, subjectPublicKey.size)))
			BERDecodeError();
	seq.MessageEnd();

	m_Qpc.SetCurveAndBase(GetCurve(), m_Q);
}

template <class EC>
void ECPublicKey<EC>::DEREncode(BufferedTransformation &bt) const
{
	DERSequenceEncoder seq(bt);
		DERSequenceEncoder algorithm(seq);
			ASN1::id_ecPublicKey().DEREncode(algorithm);
			ECParameters<EC>::DEREncode(algorithm);
		algorithm.MessageEnd();

		SecByteBlock subjectPublicKey(EncodedPointSize());
		EncodePoint(subjectPublicKey, m_Q);
		DEREncodeBitString(seq, subjectPublicKey.ptr, subjectPublicKey.size);
	seq.MessageEnd();
}

template <class EC>
void ECPublicKey<EC>::Precompute(unsigned int precomputationStorage)
{
	m_Gpc.Precompute(ExponentBitLength(), precomputationStorage);
	m_Qpc.Precompute(ExponentBitLength(), precomputationStorage);
}

template <class EC>
void ECPublicKey<EC>::LoadPrecomputation(BufferedTransformation &bt)
{
	m_Gpc.Load(bt);
	m_Qpc.Load(bt);
}

template <class EC>
void ECPublicKey<EC>::SavePrecomputation(BufferedTransformation &bt) const
{
	m_Gpc.Save(bt);
	m_Qpc.Save(bt);
}

template <class EC>
Integer ECPublicKey<EC>::EncodeDigest(ECSignatureScheme ss, const byte *digest, unsigned int digestLen) const
{
	if (ss == ECNR)
		return NR_EncodeDigest(m_n.BitCount(), digest, digestLen);
	else
	{
		assert(ss == ECDSA);
		return DSA_EncodeDigest(m_n.BitCount(), digest, digestLen);
	}
}

// ******************************************************************

template <class EC>
ECPrivateKey<EC>::ECPrivateKey(BufferedTransformation &bt)
{
	BERSequenceDecoder privateKeyInfo(bt);
		word32 version;
		BERDecodeUnsigned<word32>(privateKeyInfo, version, INTEGER, 0, 1);	// check version

		if (version == 1)
			RawDecode(privateKeyInfo, true);	// for backwards compatibility
		else
		{