Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

luc.h

Go to the documentation of this file.
00001 #ifndef CRYPTOPP_LUC_H 00002 #define CRYPTOPP_LUC_H 00003 00004 /** \file 00005 */ 00006 00007 #include "pkcspad.h" 00008 #include "oaep.h" 00009 #include "integer.h" 00010 #include "dh.h" 00011 00012 #include <limits.h> 00013 00014 NAMESPACE_BEGIN(CryptoPP) 00015 00016 //! The LUC function. 00017 /*! This class is here for historical and pedagogical interest. It has no 00018 practical advantages over other trapdoor functions and probably shouldn't 00019 be used in production software. The discrete log based LUC schemes 00020 defined later in this .h file may be of more practical interest. 00021 */ 00022 class LUCFunction : public TrapdoorFunction, public PublicKey 00023 { 00024 typedef LUCFunction ThisClass; 00025 00026 public: 00027 void Initialize(const Integer &n, const Integer &e) 00028 {m_n = n; m_e = e;} 00029 00030 void BERDecode(BufferedTransformation &bt); 00031 void DEREncode(BufferedTransformation &bt) const; 00032 00033 Integer ApplyFunction(const Integer &x) const; 00034 Integer PreimageBound() const {return m_n;} 00035 Integer ImageBound() const {return m_n;} 00036 00037 bool Validate(RandomNumberGenerator &rng, unsigned int level) const; 00038 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const; 00039 void AssignFrom(const NameValuePairs &source); 00040 00041 // non-derived interface 00042 const Integer & GetModulus() const {return m_n;} 00043 const Integer & GetPublicExponent() const {return m_e;} 00044 00045 void SetModulus(const Integer &n) {m_n = n;} 00046 void SetPublicExponent(const Integer &e) {m_e = e;} 00047 00048 protected: 00049 Integer m_n, m_e; 00050 }; 00051 00052 //! _ 00053 class InvertibleLUCFunction : public LUCFunction, public TrapdoorFunctionInverse, public PrivateKey 00054 { 00055 typedef InvertibleLUCFunction ThisClass; 00056 00057 public: 00058 void Initialize(RandomNumberGenerator &rng, unsigned int modulusBits, const Integer &eStart=17); 00059 void Initialize(const Integer &n, const Integer &e, const Integer &p, const Integer &q, const Integer &u) 00060 {m_n = n; m_e = e; m_p = p; m_q = q; m_u = u;} 00061 00062 void BERDecode(BufferedTransformation &bt); 00063 void DEREncode(BufferedTransformation &bt) const; 00064 00065 Integer CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const; 00066 00067 bool Validate(RandomNumberGenerator &rng, unsigned int level) const; 00068 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const; 00069 void AssignFrom(const NameValuePairs &source); 00070 /*! parameters: (ModulusSize, PublicExponent (default 17)) */ 00071 void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &alg); 00072 00073 // non-derived interface 00074 const Integer& GetPrime1() const {return m_p;} 00075 const Integer& GetPrime2() const {return m_q;} 00076 const Integer& GetMultiplicativeInverseOfPrime2ModPrime1() const {return m_u;} 00077 00078 void SetPrime1(const Integer &p) {m_p = p;} 00079 void SetPrime2(const Integer &q) {m_q = q;} 00080 void SetMultiplicativeInverseOfPrime2ModPrime1(const Integer &u) {m_u = u;} 00081 00082 protected: 00083 Integer m_p, m_q, m_u; 00084 }; 00085 00086 struct LUC 00087 { 00088 static std::string StaticAlgorithmName() {return "LUC";} 00089 typedef LUCFunction PublicKey; 00090 typedef InvertibleLUCFunction PrivateKey; 00091 }; 00092 00093 //! LUC cryptosystem 00094 template <class STANDARD> 00095 struct LUCES : public TF_ES<STANDARD, LUC> 00096 { 00097 }; 00098 00099 //! LUC signature scheme with appendix 00100 template <class STANDARD, class H> 00101 struct LUCSS : public TF_SS<STANDARD, H, LUC> 00102 { 00103 }; 00104 00105 // analagous to the RSA schemes defined in PKCS #1 v2.0 00106 typedef LUCES<OAEP<SHA> >::Decryptor LUCES_OAEP_SHA_Decryptor; 00107 typedef LUCES<OAEP<SHA> >::Encryptor LUCES_OAEP_SHA_Encryptor; 00108 00109 typedef LUCSS<PKCS1v15, SHA>::Signer LUCSSA_PKCS1v15_SHA_Signer; 00110 typedef LUCSS<PKCS1v15, SHA>::Verifier LUCSSA_PKCS1v15_SHA_Verifier; 00111 00112 // ******************************************************** 00113 00114 // no actual precomputation 00115 class DL_GroupPrecomputation_LUC : public DL_GroupPrecomputation<Integer> 00116 { 00117 public: 00118 const AbstractGroup<Element> & GetGroup() const {assert(false); throw 0;} 00119 Element BERDecodeElement(BufferedTransformation &bt) const {return Integer(bt);} 00120 void DEREncodeElement(BufferedTransformation &bt, const Element &v) const {v.DEREncode(bt);} 00121 00122 // non-inherited 00123 void SetModulus(const Integer &v) {m_p = v;} 00124 const Integer & GetModulus() const {return m_p;} 00125 00126 private: 00127 Integer m_p; 00128 }; 00129 00130 //! _ 00131 class DL_BasePrecomputation_LUC : public DL_FixedBasePrecomputation<Integer> 00132 { 00133 public: 00134 // DL_FixedBasePrecomputation 00135 bool IsInitialized() const {return m_g.NotZero();} 00136 void SetBase(const DL_GroupPrecomputation<Element> &group, const Integer &base) {m_g = base;} 00137 const Integer & GetBase(const DL_GroupPrecomputation<Element> &group) const {return m_g;} 00138 void Precompute(const DL_GroupPrecomputation<Element> &group, unsigned int maxExpBits, unsigned int storage) {} 00139 void Load(const DL_GroupPrecomputation<Element> &group, BufferedTransformation &storedPrecomputation) {} 00140 void Save(const DL_GroupPrecomputation<Element> &group, BufferedTransformation &storedPrecomputation) const {} 00141 Integer Exponentiate(const DL_GroupPrecomputation<Element> &group, const Integer &exponent) const; 00142 Integer CascadeExponentiate(const DL_GroupPrecomputation<Element> &group, const Integer &exponent, const DL_FixedBasePrecomputation<Integer> &pc2, const Integer &exponent2) const 00143 {throw NotImplemented("DL_BasePrecomputation_LUC: CascadeExponentiate not implemented");} // shouldn't be called 00144 00145 private: 00146 Integer m_g; 00147 }; 00148 00149 //! _ 00150 class DL_GroupParameters_LUC : public DL_GroupParameters_IntegerBasedImpl<DL_GroupPrecomputation_LUC, DL_BasePrecomputation_LUC> 00151 { 00152 public: 00153 // DL_GroupParameters 00154 bool IsIdentity(const Integer &element) const {return element == Integer::Two();} 00155 void SimultaneousExponentiate(Element *results, const Element &base, const Integer *exponents, unsigned int exponentsCount) const; 00156 Element MultiplyElements(const Element &a, const Element &b) const 00157 {throw NotImplemented("LUC_GroupParameters: MultiplyElements can not be implemented");} 00158 Element CascadeExponentiate(const Element &element1, const Integer &exponent1, const Element &element2, const Integer &exponent2) const 00159 {throw NotImplemented("LUC_GroupParameters: MultiplyElements can not be implemented");} 00160 00161 // NameValuePairs interface 00162 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const 00163 { 00164 return GetValueHelper<DL_GroupParameters_IntegerBased>(this, name, valueType, pValue).Assignable(); 00165 } 00166 00167 private: 00168 int GetFieldType() const {return 2;} 00169 }; 00170 00171 //! _ 00172 class DL_GroupParameters_LUC_DefaultSafePrime : public DL_GroupParameters_LUC 00173 { 00174 public: 00175 typedef NoCofactorMultiplication DefaultCofactorOption; 00176 00177 protected: 00178 unsigned int GetDefaultSubgroupOrderSize(unsigned int modulusSize) const {return modulusSize-1;} 00179 }; 00180 00181 //! _ 00182 class DL_Algorithm_LUC_HMP : public DL_ElgamalLikeSignatureAlgorithm<Integer> 00183 { 00184 public: 00185 static const char * StaticAlgorithmName() {return "LUC-HMP";} 00186 00187 void Sign(const DL_GroupParameters<Integer> &params, const Integer &x, const Integer &k, const Integer &e, Integer &r, Integer &s) const; 00188 bool Verify(const DL_GroupParameters<Integer> &params, const DL_PublicKey<Integer> &publicKey, const Integer &e, const Integer &r, const Integer &s) const; 00189 00190 unsigned int RLen(const DL_GroupParameters<Integer> &params) const 00191 {return params.GetGroupOrder().ByteCount();} 00192 }; 00193 00194 //! _ 00195 struct DL_SignatureKeys_LUC 00196 { 00197 typedef DL_GroupParameters_LUC GroupParameters; 00198 typedef DL_PublicKey_GFP<GroupParameters> PublicKey; 00199 typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey; 00200 }; 00201 00202 //! LUC-HMP, based on "Digital signature schemes based on Lucas functions" by Patrick Horster, Markus Michels, Holger Petersen 00203 template <class H> 00204 struct LUC_HMP : public DL_SS<DL_SignatureKeys_LUC, DL_Algorithm_LUC_HMP, DL_SignatureMessageEncodingMethod_DSA, H> 00205 { 00206 }; 00207 00208 //! _ 00209 struct DL_CryptoKeys_LUC 00210 { 00211 typedef DL_GroupParameters_LUC_DefaultSafePrime GroupParameters; 00212 typedef DL_PublicKey_GFP<GroupParameters> PublicKey; 00213 typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey; 00214 }; 00215 00216 //! LUC-IES 00217 template <class COFACTOR_OPTION = NoCofactorMultiplication, bool DHAES_MODE = true> 00218 struct LUC_IES 00219 : public DL_ES< 00220 DL_CryptoKeys_LUC, 00221 DL_KeyAgreementAlgorithm_DH<Integer, COFACTOR_OPTION>, 00222 DL_KeyDerivationAlgorithm_P1363<Integer, DHAES_MODE, P1363_KDF2<SHA1> >, 00223 DL_EncryptionAlgorithm_Xor<HMAC<SHA1>, DHAES_MODE>, 00224 LUC_IES<> > 00225 { 00226 static std::string StaticAlgorithmName() {return "LUC-IES";} // non-standard name 00227 }; 00228 00229 // ******************************************************** 00230 00231 //! LUC-DH 00232 typedef DH_Domain<DL_GroupParameters_LUC_DefaultSafePrime> LUC_DH; 00233 00234 NAMESPACE_END 00235 00236 #endif

Generated on Fri Aug 27 14:00:37 2004 for Crypto++ by doxygen 1.3.8