← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/libcrypto++/intrepid

« back to all changes in this revision

Viewing changes to eccrypto.h

  • Committer: Bazaar Package Importer
  • Author(s): Pierre Machard
  • Date: 2004-08-27 12:35:05 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040827123505-7evgxiu7k8memiyk
Tags: 5.2.1a-1
* Urgency set to high because lastest upload was unclean
* Rename libcrypto++-5.2.1.orig.tar.gz in  libcrypto++-5.2.1a.orig.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
eccrypto.h
1
1
#ifndef CRYPTOPP_ECCRYPTO_H
2
 
#define CRYPTOPP_ECCRTPTO_H
 
2
#define CRYPTOPP_ECCRYPTO_H
3
3
 
4
4
/*! \file
5
5
*/
12
12
#include "gfpcrypt.h"
13
13
#include "dh.h"
14
14
#include "mqv.h"
 
15
#include "ecp.h"
 
16
#include "ec2n.h"
15
17
 
16
18
NAMESPACE_BEGIN(CryptoPP)
17
19
 
18
 
template <class T> class EcPrecomputation;
19
 
 
20
20
//! Elliptic Curve Parameters
21
21
/*! This class corresponds to the ASN.1 sequence of the same name
22
22
    in ANSI X9.62 (also SEC 1).
42
42
 
43
43
        void Initialize(const EllipticCurve &ec, const Point &G, const Integer &n, const Integer &k = Integer::Zero())
44
44
        {
45
 
                m_groupPrecomputation.SetCurve(ec);
 
45
                this->m_groupPrecomputation.SetCurve(ec);
46
46
                SetSubgroupGenerator(G);
47
47
                m_n = n;
48
48
                m_k = k;
59
59
        void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &alg);
60
60
 
61
61
        // DL_GroupParameters
62
 
        const DL_FixedBasePrecomputation<Element> & GetBasePrecomputation() const {return m_gpc;}
63
 
        DL_FixedBasePrecomputation<Element> & AccessBasePrecomputation() {return m_gpc;}
 
62
        const DL_FixedBasePrecomputation<Element> & GetBasePrecomputation() const {return this->m_gpc;}
 
63
        DL_FixedBasePrecomputation<Element> & AccessBasePrecomputation() {return this->m_gpc;}
64
64
        const Integer & GetSubgroupOrder() const {return m_n;}
65
65
        Integer GetCofactor() const;
66
66
        bool ValidateGroup(RandomNumberGenerator &rng, unsigned int level) const;
93
93
        Integer GetMaxExponent() const {return GetSubgroupOrder()-1;}
94
94
        bool IsIdentity(const Element &element) const {return element.identity;}
95
95
        void SimultaneousExponentiate(Element *results, const Element &base, const Integer *exponents, unsigned int exponentsCount) const;
 
96
        static std::string StaticAlgorithmNamePrefix() {return "EC";}
96
97
 
97
98
        // ASN1Key
98
99
        OID GetAlgorithmID() const;
115
116
        void SetEncodeAsOID(bool encodeAsOID) {m_encodeAsOID = encodeAsOID;}
116
117
        bool GetEncodeAsOID() const {return m_encodeAsOID;}
117
118
 
118
 
        const EllipticCurve& GetCurve() const {return m_groupPrecomputation.GetCurve();}
 
119
        const EllipticCurve& GetCurve() const {return this->m_groupPrecomputation.GetCurve();}
 
120
 
 
121
        bool operator==(const ThisClass &rhs) const
 
122
                {return this->m_groupPrecomputation.GetCurve() == rhs.m_groupPrecomputation.GetCurve() && this->m_gpc.GetBase(this->m_groupPrecomputation) == rhs.m_gpc.GetBase(rhs.m_groupPrecomputation);}
119
123
 
120
124
#ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
121
125
        const Point& GetBasePoint() const {return GetSubgroupGenerator();}
133
137
        mutable Integer m_k;            // cofactor
134
138
};
135
139
 
136
 
//! .
 
140
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters_EC<ECP>;
 
141
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters_EC<EC2N>;
 
142
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKeyImpl<DL_GroupParameters_EC<ECP> >;
 
143
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKeyImpl<DL_GroupParameters_EC<EC2N> >;
 
144
 
 
145
//! EC public key
137
146
template <class EC>
138
147
class DL_PublicKey_EC : public DL_PublicKeyImpl<DL_GroupParameters_EC<EC> >
139
148
{
141
150
        typedef typename EC::Point Element;
142
151
 
143
152
        void Initialize(const DL_GroupParameters_EC<EC> &params, const Element &Q)
144
 
                {AccessGroupParameters() = params; SetPublicElement(Q);}
 
153
                {this->AccessGroupParameters() = params; SetPublicElement(Q);}
145
154
        void Initialize(const EC &ec, const Element &G, const Integer &n, const Element &Q)
146
 
                {AccessGroupParameters().Initialize(ec, G, n); SetPublicElement(Q);}
 
155
                {this->AccessGroupParameters().Initialize(ec, G, n); SetPublicElement(Q);}
147
156
 
148
157
        // X509PublicKey
149
158
        void BERDecodeKey2(BufferedTransformation &bt, bool parametersPresent, unsigned int size);
150
159
        void DEREncodeKey(BufferedTransformation &bt) const;
151
160
};
152
161
 
153
 
//! .
 
162
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_EC<ECP>;
 
163
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_EC<EC2N>;
 
164
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKeyImpl<DL_GroupParameters_EC<ECP> >;
 
165
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKeyImpl<DL_GroupParameters_EC<EC2N> >;
 
166
 
 
167
//! EC private key
154
168
template <class EC>
155
169
class DL_PrivateKey_EC : public DL_PrivateKeyImpl<DL_GroupParameters_EC<EC> >
156
170
{
158
172
        typedef typename EC::Point Element;
159
173
 
160
174
        void Initialize(const DL_GroupParameters_EC<EC> &params, const Integer &x)
161
 
                {AccessGroupParameters() = params; SetPrivateExponent(x);}
 
175
                {this->AccessGroupParameters() = params; this->SetPrivateExponent(x);}
162
176
        void Initialize(const EC &ec, const Element &G, const Integer &n, const Integer &x)
163
 
                {AccessGroupParameters().Initialize(ec, G, n); SetPrivateExponent(x);}
 
177
                {this->AccessGroupParameters().Initialize(ec, G, n); this->SetPrivateExponent(x);}
164
178
        void Initialize(RandomNumberGenerator &rng, const DL_GroupParameters_EC<EC> &params)
165
179
                {GenerateRandom(rng, params);}
166
180
        void Initialize(RandomNumberGenerator &rng, const EC &ec, const Element &G, const Integer &n)
171
185
        void DEREncodeKey(BufferedTransformation &bt) const;
172
186
};
173
187
 
 
188
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_EC<ECP>;
 
189
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_EC<EC2N>;
 
190
 
174
191
//! Elliptic Curve Diffie-Hellman, AKA <a href="http://www.weidai.com/scan-mirror/ka.html#ECDH">ECDH</a>
175
192
template <class EC, class COFACTOR_OPTION = CPP_TYPENAME DL_GroupParameters_EC<EC>::DefaultCofactorOption>
176
193
struct ECDH
185
202
        typedef MQV_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain;
186
203
};
187
204
 
188
 
//! .
 
205
//! EC keys
189
206
template <class EC>
190
207
struct DL_Keys_EC
191
208
{
196
213
template <class EC, class H = SHA>
197
214
struct ECDSA;
198
215
 
199
 
//! .
 
216
//! ECDSA keys
200
217
template <class EC>
201
218
struct DL_Keys_ECDSA
202
219
{
204
221
        typedef DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<EC>, ECDSA<EC> > PrivateKey;
205
222
};
206
223
 
207
 
//! .
 
224
CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_GDSA<ECP::Point>;
 
225
CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_GDSA<EC2N::Point>;
 
226
 
 
227
//! ECDSA algorithm
208
228
template <class EC>
209
229
class DL_Algorithm_ECDSA : public DL_Algorithm_GDSA<typename EC::Point>
210
230
{
212
232
        static const char * StaticAlgorithmName() {return "ECDSA";}
213
233
};
214
234
 
215
 
//! .
 
235
//! ECNR algorithm
216
236
template <class EC>
217
237
class DL_Algorithm_ECNR : public DL_Algorithm_NR<typename EC::Point>
218
238
{
226
246
{
227
247
};
228
248
 
 
249
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<ECP>, ECDSA<ECP> >;
 
250
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<EC2N>, ECDSA<EC2N> >;
 
251
 
229
252
//! ECNR
230
253
template <class EC, class H = SHA>
231
254
struct ECNR : public DL_SS<DL_Keys_EC<EC>, DL_Algorithm_ECNR<EC>, DL_SignatureMessageEncodingMethod_NR, H>