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

Generated on Tue Jul 8 23:34:19 2003 for Crypto++ by doxygen 1.3.2