eccrypto.h

Go to the documentation of this file.

// eccrypto.h - originally written and placed in the public domain by Wei Dai
//              deterministic signatures added by by Douglas Roark
 
 
#ifndef CRYPTOPP_ECCRYPTO_H
#define CRYPTOPP_ECCRYPTO_H
 
#include "config.h"
#include "cryptlib.h"
#include "pubkey.h"
#include "integer.h"
#include "asn.h"
#include "hmac.h"
#include "sha.h"
#include "gfpcrypt.h"
#include "dh.h"
#include "mqv.h"
#include "hmqv.h"
#include "fhmqv.h"
#include "ecp.h"
#include "ec2n.h"
 
#include <iosfwd>
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4231 4275)
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
 
template <class EC>
class DL_GroupParameters_EC : public DL_GroupParametersImpl<EcPrecomputation<EC> >
{
        typedef DL_GroupParameters_EC<EC> ThisClass;
 
public:
        typedef EC EllipticCurve;
        typedef typename EllipticCurve::Point Point;
        typedef Point Element;
        typedef IncompatibleCofactorMultiplication DefaultCofactorOption;
 
        virtual ~DL_GroupParameters_EC() {}
 
        DL_GroupParameters_EC() : m_compress(false), m_encodeAsOID(true) {}
 
        DL_GroupParameters_EC(const OID &oid)
                : m_compress(false), m_encodeAsOID(true) {Initialize(oid);}
 
        DL_GroupParameters_EC(const EllipticCurve &ec, const Point &G, const Integer &n, const Integer &k = Integer::Zero())
                : m_compress(false), m_encodeAsOID(true) {Initialize(ec, G, n, k);}
 
        DL_GroupParameters_EC(BufferedTransformation &bt)
                : m_compress(false), m_encodeAsOID(true) {BERDecode(bt);}
 
        void Initialize(const EllipticCurve &ec, const Point &G, const Integer &n, const Integer &k = Integer::Zero())
        {
                this->m_groupPrecomputation.SetCurve(ec);
                this->SetSubgroupGenerator(G);
                m_n = n;
                m_k = k;
        }
 
        void Initialize(const OID &oid);
 
        // NameValuePairs
        bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;
        void AssignFrom(const NameValuePairs &source);
 
        // GeneratibleCryptoMaterial interface
 
        void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &alg);
 
        // DL_GroupParameters
        const DL_FixedBasePrecomputation<Element> & GetBasePrecomputation() const {return this->m_gpc;}
        DL_FixedBasePrecomputation<Element> & AccessBasePrecomputation() {return this->m_gpc;}
        const Integer & GetSubgroupOrder() const {return m_n;}
        Integer GetCofactor() const;
        bool ValidateGroup(RandomNumberGenerator &rng, unsigned int level) const;
        bool ValidateElement(unsigned int level, const Element &element, const DL_FixedBasePrecomputation<Element> *precomp) const;
        bool FastSubgroupCheckAvailable() const {return false;}
        void EncodeElement(bool reversible, const Element &element, byte *encoded) const
        {
                if (reversible)
                        GetCurve().EncodePoint(encoded, element, m_compress);
                else
                        element.x.Encode(encoded, GetEncodedElementSize(false));
        }
        virtual unsigned int GetEncodedElementSize(bool reversible) const
        {
                if (reversible)
                        return GetCurve().EncodedPointSize(m_compress);
                else
                        return GetCurve().GetField().MaxElementByteLength();
        }
        Element DecodeElement(const byte *encoded, bool checkForGroupMembership) const
        {
                Point result;
                if (!GetCurve().DecodePoint(result, encoded, GetEncodedElementSize(true)))
                        throw DL_BadElement();
                if (checkForGroupMembership && !ValidateElement(1, result, NULLPTR))
                        throw DL_BadElement();
                return result;
        }
        Integer ConvertElementToInteger(const Element &element) const;
        Integer GetMaxExponent() const {return GetSubgroupOrder()-1;}
        bool IsIdentity(const Element &element) const {return element.identity;}
        void SimultaneousExponentiate(Element *results, const Element &base, const Integer *exponents, unsigned int exponentsCount) const;
        static std::string CRYPTOPP_API StaticAlgorithmNamePrefix() {return "EC";}
 
        // ASN1Key
        OID GetAlgorithmID() const;
 
        // used by MQV
        Element MultiplyElements(const Element &a, const Element &b) const;
        Element CascadeExponentiate(const Element &element1, const Integer &exponent1, const Element &element2, const Integer &exponent2) const;
 
        // non-inherited
 
        // enumerate OIDs for recommended parameters, use OID() to get first one
        static OID CRYPTOPP_API GetNextRecommendedParametersOID(const OID &oid);
 
        void BERDecode(BufferedTransformation &bt);
        void DEREncode(BufferedTransformation &bt) const;
 
        void SetPointCompression(bool compress) {m_compress = compress;}
        bool GetPointCompression() const {return m_compress;}
 
        void SetEncodeAsOID(bool encodeAsOID) {m_encodeAsOID = encodeAsOID;}
        bool GetEncodeAsOID() const {return m_encodeAsOID;}
 
        const EllipticCurve& GetCurve() const {return this->m_groupPrecomputation.GetCurve();}
 
        bool operator==(const ThisClass &rhs) const
                {return this->m_groupPrecomputation.GetCurve() == rhs.m_groupPrecomputation.GetCurve() && this->m_gpc.GetBase(this->m_groupPrecomputation) == rhs.m_gpc.GetBase(rhs.m_groupPrecomputation);}
 
protected:
        unsigned int FieldElementLength() const {return GetCurve().GetField().MaxElementByteLength();}
        unsigned int ExponentLength() const {return m_n.ByteCount();}
 
        OID m_oid;                      // set if parameters loaded from a recommended curve
        Integer m_n;            // order of base point
        mutable Integer m_k;            // cofactor
        mutable bool m_compress, m_encodeAsOID;         // presentation details
};
 
inline std::ostream& operator<<(std::ostream& os, const DL_GroupParameters_EC<ECP>::Element& obj);
 
template <class EC>
class DL_PublicKey_EC : public DL_PublicKeyImpl<DL_GroupParameters_EC<EC> >
{
public:
        typedef typename EC::Point Element;
 
        virtual ~DL_PublicKey_EC() {}
 
        void Initialize(const DL_GroupParameters_EC<EC> &params, const Element &Q)
                {this->AccessGroupParameters() = params; this->SetPublicElement(Q);}
 
        void Initialize(const EC &ec, const Element &G, const Integer &n, const Element &Q)
                {this->AccessGroupParameters().Initialize(ec, G, n); this->SetPublicElement(Q);}
 
        // X509PublicKey
        void BERDecodePublicKey(BufferedTransformation &bt, bool parametersPresent, size_t size);
        void DEREncodePublicKey(BufferedTransformation &bt) const;
};
 
template <class EC>
class DL_PrivateKey_EC : public DL_PrivateKeyImpl<DL_GroupParameters_EC<EC> >
{
public:
        typedef typename EC::Point Element;
 
        virtual ~DL_PrivateKey_EC();
 
        void Initialize(const DL_GroupParameters_EC<EC> &params, const Integer &x)
                {this->AccessGroupParameters() = params; this->SetPrivateExponent(x);}
 
        void Initialize(const EC &ec, const Element &G, const Integer &n, const Integer &x)
                {this->AccessGroupParameters().Initialize(ec, G, n); this->SetPrivateExponent(x);}
 
        void Initialize(RandomNumberGenerator &rng, const DL_GroupParameters_EC<EC> &params)
                {this->GenerateRandom(rng, params);}
 
        void Initialize(RandomNumberGenerator &rng, const EC &ec, const Element &G, const Integer &n)
                {this->GenerateRandom(rng, DL_GroupParameters_EC<EC>(ec, G, n));}
 
        // PKCS8PrivateKey
        void BERDecodePrivateKey(BufferedTransformation &bt, bool parametersPresent, size_t size);
        void DEREncodePrivateKey(BufferedTransformation &bt) const;
};
 
// Out-of-line dtor due to AIX and GCC, http://github.com/weidai11/cryptopp/issues/499
template<class EC>
DL_PrivateKey_EC<EC>::~DL_PrivateKey_EC() {}
 
template <class EC, class COFACTOR_OPTION = typename DL_GroupParameters_EC<EC>::DefaultCofactorOption>
struct ECDH
{
        typedef DH_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain;
};
 
template <class EC, class COFACTOR_OPTION = typename DL_GroupParameters_EC<EC>::DefaultCofactorOption>
struct ECMQV
{
        typedef MQV_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain;
};
 
template <class EC, class COFACTOR_OPTION = typename DL_GroupParameters_EC<EC>::DefaultCofactorOption, class HASH = SHA256>
struct ECHMQV
{
        typedef HMQV_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION, HASH> Domain;
};
 
typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption,   SHA1 >::Domain ECHMQV160;
typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA256 >::Domain ECHMQV256;
typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA384 >::Domain ECHMQV384;
typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA512 >::Domain ECHMQV512;
 
template <class EC, class COFACTOR_OPTION = typename DL_GroupParameters_EC<EC>::DefaultCofactorOption, class HASH = SHA256>
struct ECFHMQV
{
        typedef FHMQV_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION, HASH> Domain;
};
 
typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption,   SHA1 >::Domain ECFHMQV160;
typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA256 >::Domain ECFHMQV256;
typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA384 >::Domain ECFHMQV384;
typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA512 >::Domain ECFHMQV512;
 
template <class EC>
struct DL_Keys_EC
{
        typedef DL_PublicKey_EC<EC> PublicKey;
        typedef DL_PrivateKey_EC<EC> PrivateKey;
};
 
// Forward declaration; documented below
template <class EC, class H>
struct ECDSA;
 
template <class EC>
struct DL_Keys_ECDSA
{
        typedef DL_PublicKey_EC<EC> PublicKey;
        typedef DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<EC>, ECDSA<EC, SHA256> > PrivateKey;
};
 
template <class EC>
class DL_Algorithm_ECDSA : public DL_Algorithm_GDSA<typename EC::Point>
{
public:
  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECDSA";}
};
 
template <class EC, class H>
class DL_Algorithm_ECDSA_RFC6979 : public DL_Algorithm_DSA_RFC6979<typename EC::Point, H>
{
public:
  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECDSA-RFC6979";}
};
 
template <class EC>
class DL_Algorithm_ECNR : public DL_Algorithm_NR<typename EC::Point>
{
public:
  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECNR";}
};
 
template <class EC, class H>
struct ECDSA : public DL_SS<DL_Keys_ECDSA<EC>, DL_Algorithm_ECDSA<EC>, DL_SignatureMessageEncodingMethod_DSA, H>
{
};
 
template <class EC, class H>
struct ECDSA_RFC6979 : public DL_SS<
        DL_Keys_ECDSA<EC>,
        DL_Algorithm_ECDSA_RFC6979<EC, H>,
        DL_SignatureMessageEncodingMethod_DSA,
        H,
        ECDSA_RFC6979<EC,H> >
{
        static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string("ECDSA-RFC6979/") + H::StaticAlgorithmName();}
};
 
template <class EC, class H = SHA1>
struct ECNR : public DL_SS<DL_Keys_EC<EC>, DL_Algorithm_ECNR<EC>, DL_SignatureMessageEncodingMethod_NR, H>
{
};
 
// ******************************************
 
template <class EC>
class DL_PublicKey_ECGDSA;
template <class EC>
class DL_PrivateKey_ECGDSA;
 
template <class EC>
class DL_PrivateKey_ECGDSA : public DL_PrivateKeyImpl<DL_GroupParameters_EC<EC> >
{
public:
        typedef typename EC::Point Element;
 
        virtual ~DL_PrivateKey_ECGDSA() {}
 
        void Initialize(const DL_GroupParameters_EC<EC> &params, const Integer &x)
        {
                this->AccessGroupParameters() = params;
                this->SetPrivateExponent(x);
                CRYPTOPP_ASSERT(x>=1 && x<=params.GetSubgroupOrder()-1);
        }
 
        void Initialize(const EC &ec, const Element &G, const Integer &n, const Integer &x)
        {
                this->AccessGroupParameters().Initialize(ec, G, n);
                this->SetPrivateExponent(x);
                CRYPTOPP_ASSERT(x>=1 && x<=this->AccessGroupParameters().GetSubgroupOrder()-1);
        }
 
        void Initialize(RandomNumberGenerator &rng, const DL_GroupParameters_EC<EC> &params)
                {this->GenerateRandom(rng, params);}
 
        void Initialize(RandomNumberGenerator &rng, const EC &ec, const Element &G, const Integer &n)
                {this->GenerateRandom(rng, DL_GroupParameters_EC<EC>(ec, G, n));}
 
        virtual void MakePublicKey(DL_PublicKey_ECGDSA<EC> &pub) const
        {
                const DL_GroupParameters<Element>& params = this->GetAbstractGroupParameters();
                pub.AccessAbstractGroupParameters().AssignFrom(params);
                const Integer &xInv = this->GetPrivateExponent().InverseMod(params.GetSubgroupOrder());
                pub.SetPublicElement(params.ExponentiateBase(xInv));
                CRYPTOPP_ASSERT(xInv.NotZero());
        }
 
        virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
        {
                return GetValueHelper<DL_PrivateKey_ECGDSA<EC>,
                        DL_PrivateKey_ECGDSA<EC> >(this, name, valueType, pValue).Assignable();
        }
 
        virtual void AssignFrom(const NameValuePairs &source)
        {
                AssignFromHelper<DL_PrivateKey_ECGDSA<EC>,
                        DL_PrivateKey_ECGDSA<EC> >(this, source);
        }
 
        // PKCS8PrivateKey
        void BERDecodePrivateKey(BufferedTransformation &bt, bool parametersPresent, size_t size);
        void DEREncodePrivateKey(BufferedTransformation &bt) const;
};
 
template <class EC>
class DL_PublicKey_ECGDSA : public DL_PublicKeyImpl<DL_GroupParameters_EC<EC> >
{
        typedef DL_PublicKey_ECGDSA<EC> ThisClass;
 
public:
        typedef typename EC::Point Element;
 
        virtual ~DL_PublicKey_ECGDSA() {}
 
        void Initialize(const DL_GroupParameters_EC<EC> &params, const Element &Q)
                {this->AccessGroupParameters() = params; this->SetPublicElement(Q);}
 
        void Initialize(const EC &ec, const Element &G, const Integer &n, const Element &Q)
                {this->AccessGroupParameters().Initialize(ec, G, n); this->SetPublicElement(Q);}
 
        virtual void AssignFrom(const NameValuePairs &source)
        {
                DL_PrivateKey_ECGDSA<EC> *pPrivateKey = NULLPTR;
                if (source.GetThisPointer(pPrivateKey))
                        pPrivateKey->MakePublicKey(*this);
                else
                {
                        this->AccessAbstractGroupParameters().AssignFrom(source);
                        AssignFromHelper(this, source)
                                CRYPTOPP_SET_FUNCTION_ENTRY(PublicElement);
                }
        }
 
        // DL_PublicKey<T>
        virtual void SetPublicElement(const Element &y)
                {this->AccessPublicPrecomputation().SetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation(), y);}
 
        // X509PublicKey
        void BERDecodePublicKey(BufferedTransformation &bt, bool parametersPresent, size_t size);
        void DEREncodePublicKey(BufferedTransformation &bt) const;
};
 
template <class EC>
struct DL_Keys_ECGDSA
{
        typedef DL_PublicKey_ECGDSA<EC> PublicKey;
        typedef DL_PrivateKey_ECGDSA<EC> PrivateKey;
};
 
template <class EC>
class DL_Algorithm_ECGDSA : public DL_Algorithm_GDSA_ISO15946<typename EC::Point>
{
public:
  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECGDSA";}
};
 
template <class EC, class H>
struct ECGDSA : public DL_SS<
        DL_Keys_ECGDSA<EC>,
        DL_Algorithm_ECGDSA<EC>,
        DL_SignatureMessageEncodingMethod_DSA,
        H>
{
        static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string("ECGDSA-ISO15946/") + H::StaticAlgorithmName();}
};
 
// ******************************************
 
template <class EC, class HASH = SHA1, class COFACTOR_OPTION = NoCofactorMultiplication, bool DHAES_MODE = true, bool LABEL_OCTETS = false>
struct ECIES
        : public DL_ES<
                DL_Keys_EC<EC>,
                DL_KeyAgreementAlgorithm_DH<typename EC::Point, COFACTOR_OPTION>,
                DL_KeyDerivationAlgorithm_P1363<typename EC::Point, DHAES_MODE, P1363_KDF2<HASH> >,
                DL_EncryptionAlgorithm_Xor<HMAC<HASH>, DHAES_MODE, LABEL_OCTETS>,
                ECIES<EC> >
{
        // TODO: fix this after name is standardized
        CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECIES";}
};
 
template <class EC, class HASH = SHA1, class COFACTOR_OPTION = NoCofactorMultiplication>
struct ECIES_P1363
        : public DL_ES<
                DL_Keys_EC<EC>,
                DL_KeyAgreementAlgorithm_DH<typename EC::Point, COFACTOR_OPTION>,
                DL_KeyDerivationAlgorithm_P1363<typename EC::Point, false, P1363_KDF2<HASH> >,
                DL_EncryptionAlgorithm_Xor<HMAC<HASH>, false, true>,
                ECIES<EC> >
{
        // TODO: fix this after name is standardized
        CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECIES-P1363";}
};
 
NAMESPACE_END
 
#ifdef CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
#include "eccrypto.cpp"
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters_EC<ECP>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters_EC<EC2N>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKeyImpl<DL_GroupParameters_EC<ECP> >;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKeyImpl<DL_GroupParameters_EC<EC2N> >;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_EC<ECP>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_EC<EC2N>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_ECGDSA<ECP>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_ECGDSA<EC2N>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKeyImpl<DL_GroupParameters_EC<ECP> >;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKeyImpl<DL_GroupParameters_EC<EC2N> >;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_EC<ECP>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_EC<EC2N>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_ECGDSA<ECP>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_ECGDSA<EC2N>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_GDSA<ECP::Point>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_GDSA<EC2N::Point>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<ECP>, ECDSA<ECP, SHA256> >;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<EC2N>, ECDSA<EC2N, SHA256> >;
 
NAMESPACE_END
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
 
#endif