<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>Crypto++: pubkey.h Source File</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.3.7 -->
<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="namespaces.html">Namespace List</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="classes.html">Alphabetical List</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="namespacemembers.html">Namespace Members</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div>
<h1>pubkey.h</h1><a href="pubkey_8h.html">Go to the documentation of this file.</a><pre class="fragment"><div>00001 <span class="comment">// pubkey.h - written and placed in the public domain by Wei Dai</span>
00002
00003 <span class="preprocessor">#ifndef CRYPTOPP_PUBKEY_H</span>
00004 <span class="preprocessor"></span><span class="preprocessor">#define CRYPTOPP_PUBKEY_H</span>
00005 <span class="preprocessor"></span><span class="comment"></span>
00006 <span class="comment">/** \file</span>
00007 <span class="comment"></span>
00008 <span class="comment"> This file contains helper classes/functions for implementing public key algorithms.</span>
00009 <span class="comment"></span>
00010 <span class="comment"> The class hierachies in this .h file tend to look like this:</span>
00011 <span class="comment"><pre></span>
00012 <span class="comment"> x1</span>
00013 <span class="comment"> / \</span>
00014 <span class="comment"> y1 z1</span>
00015 <span class="comment"> | |</span>
00016 <span class="comment"> x2<y1> x2<z1></span>
00017 <span class="comment"> | |</span>
00018 <span class="comment"> y2 z2</span>
00019 <span class="comment"> | |</span>
00020 <span class="comment"> x3<y2> x3<z2></span>
00021 <span class="comment"> | |</span>
00022 <span class="comment"> y3 z3</span>
00023 <span class="comment"></pre></span>
00024 <span class="comment"> - x1, y1, z1 are abstract interface classes defined in cryptlib.h</span>
00025 <span class="comment"> - x2, y2, z2 are implementations of the interfaces using "abstract policies", which</span>
00026 <span class="comment"> are pure virtual functions that should return interfaces to interchangeable algorithms.</span>
00027 <span class="comment"> These classes have "Base" suffixes.</span>
00028 <span class="comment"> - x3, y3, z3 hold actual algorithms and implement those virtual functions.</span>
00029 <span class="comment"> These classes have "Impl" suffixes.</span>
00030 <span class="comment"></span>
00031 <span class="comment"> The "TF_" prefix means an implementation using trapdoor functions on integers.</span>
00032 <span class="comment"> The "DL_" prefix means an implementation using group operations (in groups where discrete log is hard).</span>
00033 <span class="comment">*/</span>
00034
00035 <span class="preprocessor">#include "modarith.h"</span>
00036 <span class="preprocessor">#include "filters.h"</span>
00037 <span class="preprocessor">#include "eprecomp.h"</span>
00038 <span class="preprocessor">#include "<a class="code" href="fips140_8h.html">fips140.h</a>"</span>
00039 <span class="preprocessor">#include "argnames.h"</span>
00040 <span class="preprocessor">#include <memory></span>
00041
00042 <span class="comment">// VC60 workaround: this macro is defined in shlobj.h and conflicts with a template parameter used in this file</span>
00043 <span class="preprocessor">#undef INTERFACE</span>
00044 <span class="preprocessor"></span>
00045 NAMESPACE_BEGIN(CryptoPP)
00046
00047 <span class="comment">//! _</span>
<a name="l00048"></a><a class="code" href="class_trapdoor_function_bounds.html">00048</a> <span class="comment"></span>class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE <a class="code" href="class_trapdoor_function_bounds.html">TrapdoorFunctionBounds</a>
00049 {
00050 <span class="keyword">public</span>:
00051 <span class="keyword">virtual</span> ~TrapdoorFunctionBounds() {}
00052
00053 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> PreimageBound() <span class="keyword">const</span> =0;
00054 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> ImageBound() <span class="keyword">const</span> =0;
00055 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> MaxPreimage()<span class="keyword"> const </span>{<span class="keywordflow">return</span> --PreimageBound();}
00056 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> MaxImage()<span class="keyword"> const </span>{<span class="keywordflow">return</span> --ImageBound();}
00057 };
00058 <span class="comment"></span>
00059 <span class="comment">//! _</span>
<a name="l00060"></a><a class="code" href="class_randomized_trapdoor_function.html">00060</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunction : <span class="keyword">public</span> <a class="code" href="class_trapdoor_function_bounds.html">TrapdoorFunctionBounds</a>
00061 {
00062 <span class="keyword">public</span>:
00063 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> ApplyRandomizedFunction(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x) <span class="keyword">const</span> =0;
00064 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> IsRandomized()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00065 };
00066 <span class="comment"></span>
00067 <span class="comment">//! _</span>
<a name="l00068"></a><a class="code" href="class_trapdoor_function.html">00068</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunction : <span class="keyword">public</span> RandomizedTrapdoorFunction
00069 {
00070 <span class="keyword">public</span>:
00071 <a class="code" href="class_integer.html">Integer</a> ApplyRandomizedFunction(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x)<span class="keyword"> const</span>
00072 <span class="keyword"> </span>{<span class="keywordflow">return</span> ApplyFunction(x);}
00073 <span class="keywordtype">bool</span> IsRandomized()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00074
00075 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> ApplyFunction(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x) <span class="keyword">const</span> =0;
00076 };
00077 <span class="comment"></span>
00078 <span class="comment">//! _</span>
<a name="l00079"></a><a class="code" href="class_randomized_trapdoor_function_inverse.html">00079</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunctionInverse
00080 {
00081 <span class="keyword">public</span>:
00082 <span class="keyword">virtual</span> ~RandomizedTrapdoorFunctionInverse() {}
00083
00084 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> CalculateRandomizedInverse(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x) <span class="keyword">const</span> =0;
00085 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> IsRandomized()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00086 };
00087 <span class="comment"></span>
00088 <span class="comment">//! _</span>
<a name="l00089"></a><a class="code" href="class_trapdoor_function_inverse.html">00089</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunctionInverse : <span class="keyword">public</span> RandomizedTrapdoorFunctionInverse
00090 {
00091 <span class="keyword">public</span>:
00092 <span class="keyword">virtual</span> ~TrapdoorFunctionInverse() {}
00093
00094 <a class="code" href="class_integer.html">Integer</a> CalculateRandomizedInverse(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x)<span class="keyword"> const</span>
00095 <span class="keyword"> </span>{<span class="keywordflow">return</span> CalculateInverse(rng, x);}
00096 <span class="keywordtype">bool</span> IsRandomized()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00097
00098 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> CalculateInverse(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x) <span class="keyword">const</span> =0;
00099 };
00100
00101 <span class="comment">// ********************************************************</span>
00102 <span class="comment"></span>
00103 <span class="comment">//! message encoding method for public key encryption</span>
<a name="l00104"></a><a class="code" href="class_p_k___encryption_message_encoding_method.html">00104</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_NO_VTABLE PK_EncryptionMessageEncodingMethod
00105 {
00106 <span class="keyword">public</span>:
00107 <span class="keyword">virtual</span> ~PK_EncryptionMessageEncodingMethod() {}
00108
00109 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> ParameterSupported(<span class="keyword">const</span> <span class="keywordtype">char</span> *name)<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00110 <span class="comment"></span>
00111 <span class="comment"> //! max size of unpadded message in bytes, given max size of padded message in bits (1 less than size of modulus)</span>
00112 <span class="comment"></span> <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxUnpaddedLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> paddedLength) <span class="keyword">const</span> =0;
00113
00114 <span class="keyword">virtual</span> <span class="keywordtype">void</span> Pad(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *raw, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> inputLength, byte *padded, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> paddedBitLength, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters) <span class="keyword">const</span> =0;
00115
00116 <span class="keyword">virtual</span> <a class="code" href="struct_decoding_result.html">DecodingResult</a> Unpad(<span class="keyword">const</span> byte *padded, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> paddedBitLength, byte *raw, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters) <span class="keyword">const</span> =0;
00117 };
00118
00119 <span class="comment">// ********************************************************</span>
00120 <span class="comment"></span>
00121 <span class="comment">//! _</span>
00122 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> TFI, <span class="keyword">class</span> MEI>
<a name="l00123"></a><a class="code" href="class_t_f___base.html">00123</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE TF_Base
00124 {
00125 <span class="keyword">protected</span>:
00126 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_trapdoor_function_bounds.html">TrapdoorFunctionBounds</a> & GetTrapdoorFunctionBounds() <span class="keyword">const</span> =0;
00127
00128 <span class="keyword">typedef</span> TFI TrapdoorFunctionInterface;
00129 <span class="keyword">virtual</span> <span class="keyword">const</span> TrapdoorFunctionInterface & GetTrapdoorFunctionInterface() <span class="keyword">const</span> =0;
00130
00131 <span class="keyword">typedef</span> MEI MessageEncodingInterface;
00132 <span class="keyword">virtual</span> <span class="keyword">const</span> MessageEncodingInterface & GetMessageEncodingInterface() <span class="keyword">const</span> =0;
00133 };
00134
00135 <span class="comment">// ********************************************************</span>
00136 <span class="comment"></span>
00137 <span class="comment">//! _</span>
00138 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE>
<a name="l00139"></a><a class="code" href="class_p_k___fixed_length_crypto_system_impl.html">00139</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE PK_FixedLengthCryptoSystemImpl : <span class="keyword">public</span> BASE
00140 {
00141 <span class="keyword">public</span>:
00142 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxPlaintextLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ciphertextLength)<span class="keyword"> const</span>
00143 <span class="keyword"> </span>{<span class="keywordflow">return</span> ciphertextLength == FixedCiphertextLength() ? FixedMaxPlaintextLength() : 0;}
00144 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> CiphertextLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength)<span class="keyword"> const</span>
00145 <span class="keyword"> </span>{<span class="keywordflow">return</span> plaintextLength <= FixedMaxPlaintextLength() ? FixedCiphertextLength() : 0;}
00146
00147 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> FixedMaxPlaintextLength() <span class="keyword">const</span> =0;
00148 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> FixedCiphertextLength() <span class="keyword">const</span> =0;
00149 };
00150 <span class="comment"></span>
00151 <span class="comment">//! _</span>
00152 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> INTERFACE, <span class="keyword">class</span> BASE>
<a name="l00153"></a><a class="code" href="class_t_f___crypto_system_base.html">00153</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE TF_CryptoSystemBase : <span class="keyword">public</span> PK_FixedLengthCryptoSystemImpl<INTERFACE>, <span class="keyword">protected</span> BASE
00154 {
00155 <span class="keyword">public</span>:
00156 <span class="keywordtype">bool</span> ParameterSupported(<span class="keyword">const</span> <span class="keywordtype">char</span> *name)<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetMessageEncodingInterface().ParameterSupported(name);}
00157 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> FixedMaxPlaintextLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}
00158 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> FixedCiphertextLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetTrapdoorFunctionBounds().MaxImage().ByteCount();}
00159
00160 <span class="keyword">protected</span>:
00161 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> PaddedBlockByteLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> BitsToBytes(PaddedBlockBitLength());}
00162 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> PaddedBlockBitLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;}
00163 };
00164 <span class="comment"></span>
00165 <span class="comment">//! _</span>
<a name="l00166"></a><a class="code" href="class_t_f___decryptor_base.html">00166</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_DecryptorBase : <span class="keyword">public</span> TF_CryptoSystemBase<PK_Decryptor, TF_Base<TrapdoorFunctionInverse, PK_EncryptionMessageEncodingMethod> >
00167 {
00168 <span class="keyword">public</span>:
00169 <a class="code" href="struct_decoding_result.html">DecodingResult</a> Decrypt(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *ciphertext, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ciphertextLength, byte *plaintext, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters = g_nullNameValuePairs) <span class="keyword">const</span>;
00170 };
00171 <span class="comment"></span>
00172 <span class="comment">//! _</span>
<a name="l00173"></a><a class="code" href="class_t_f___encryptor_base.html">00173</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_EncryptorBase : <span class="keyword">public</span> TF_CryptoSystemBase<PK_Encryptor, TF_Base<RandomizedTrapdoorFunction, PK_EncryptionMessageEncodingMethod> >
00174 {
00175 <span class="keyword">public</span>:
00176 <span class="keywordtype">void</span> Encrypt(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *plaintext, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength, byte *ciphertext, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters = g_nullNameValuePairs) <span class="keyword">const</span>;
00177 };
00178
00179 <span class="comment">// ********************************************************</span>
00180
00181 <span class="keyword">typedef</span> std::pair<const byte *, unsigned int> HashIdentifier;
00182 <span class="comment"></span>
00183 <span class="comment">//! interface for message encoding method for public key signature schemes</span>
<a name="l00184"></a><a class="code" href="class_p_k___signature_message_encoding_method.html">00184</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_NO_VTABLE PK_SignatureMessageEncodingMethod
00185 {
00186 <span class="keyword">public</span>:
00187 <span class="keyword">virtual</span> ~PK_SignatureMessageEncodingMethod() {}
00188
00189 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxRecoverableLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> hashIdentifierLength, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> digestLength)<span class="keyword"> const</span>
00190 <span class="keyword"> </span>{<span class="keywordflow">return</span> 0;}
00191
00192 <span class="keywordtype">bool</span> IsProbabilistic()<span class="keyword"> const </span>
00193 <span class="keyword"> </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00194 <span class="keywordtype">bool</span> AllowNonrecoverablePart()<span class="keyword"> const</span>
00195 <span class="keyword"> </span>{<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"PK_MessageEncodingMethod: this signature scheme does not support message recovery"</span>);}
00196 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> RecoverablePartFirst()<span class="keyword"> const</span>
00197 <span class="keyword"> </span>{<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"PK_MessageEncodingMethod: this signature scheme does not support message recovery"</span>);}
00198
00199 <span class="comment">// for verification, DL</span>
00200 <span class="keyword">virtual</span> <span class="keywordtype">void</span> ProcessSemisignature(<a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, <span class="keyword">const</span> byte *semisignature, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> semisignatureLength)<span class="keyword"> const </span>{}
00201
00202 <span class="comment">// for signature</span>
00203 <span class="keyword">virtual</span> <span class="keywordtype">void</span> ProcessRecoverableMessage(<a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash,
00204 <span class="keyword">const</span> byte *recoverableMessage, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> recoverableMessageLength,
00205 <span class="keyword">const</span> byte *presignature, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> presignatureLength,
00206 <a class="code" href="class_sec_block.html">SecByteBlock</a> &semisignature)<span class="keyword"> const</span>
00207 <span class="keyword"> </span>{
00208 <span class="keywordflow">if</span> (RecoverablePartFirst())
00209 assert(!<span class="stringliteral">"ProcessRecoverableMessage() not implemented"</span>);
00210 }
00211
00212 <span class="keyword">virtual</span> <span class="keywordtype">void</span> ComputeMessageRepresentative(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng,
00213 <span class="keyword">const</span> byte *recoverableMessage, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> recoverableMessageLength,
00214 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00215 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength) <span class="keyword">const</span> =0;
00216
00217 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> VerifyMessageRepresentative(
00218 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00219 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength) <span class="keyword">const</span> =0;
00220
00221 <span class="keyword">virtual</span> <a class="code" href="struct_decoding_result.html">DecodingResult</a> RecoverMessageFromRepresentative( <span class="comment">// for TF</span>
00222 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00223 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength,
00224 byte *recoveredMessage)<span class="keyword"> const</span>
00225 <span class="keyword"> </span>{<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"PK_MessageEncodingMethod: this signature scheme does not support message recovery"</span>);}
00226
00227 <span class="keyword">virtual</span> <a class="code" href="struct_decoding_result.html">DecodingResult</a> RecoverMessageFromSemisignature( <span class="comment">// for DL</span>
00228 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier,
00229 <span class="keyword">const</span> byte *presignature, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> presignatureLength,
00230 <span class="keyword">const</span> byte *semisignature, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> semisignatureLength,
00231 byte *recoveredMessage)<span class="keyword"> const</span>
00232 <span class="keyword"> </span>{<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"PK_MessageEncodingMethod: this signature scheme does not support message recovery"</span>);}
00233
00234 <span class="comment">// VC60 workaround</span>
00235 <span class="keyword">struct </span>HashIdentifierLookup
00236 {
00237 <span class="keyword">template</span> <<span class="keyword">class</span> H> <span class="keyword">struct </span>HashIdentifierLookup2
00238 {
00239 <span class="keyword">static</span> HashIdentifier Lookup()
00240 {
00241 <span class="keywordflow">return</span> HashIdentifier(NULL, 0);
00242 }
00243 };
00244 };
00245 };
00246
00247 <span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_DeterministicSignatureMessageEncodingMethod : <span class="keyword">public</span> PK_SignatureMessageEncodingMethod
00248 {
00249 <span class="keyword">public</span>:
00250 <span class="keywordtype">bool</span> VerifyMessageRepresentative(
00251 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00252 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength) <span class="keyword">const</span>;
00253 };
00254
00255 <span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_RecoverableSignatureMessageEncodingMethod : <span class="keyword">public</span> PK_SignatureMessageEncodingMethod
00256 {
00257 <span class="keyword">public</span>:
00258 <span class="keywordtype">bool</span> VerifyMessageRepresentative(
00259 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00260 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength) <span class="keyword">const</span>;
00261 };
00262
00263 <span class="keyword">class </span>CRYPTOPP_DLL DL_SignatureMessageEncodingMethod_DSA : <span class="keyword">public</span> PK_DeterministicSignatureMessageEncodingMethod
00264 {
00265 <span class="keyword">public</span>:
00266 <span class="keywordtype">void</span> ComputeMessageRepresentative(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng,
00267 <span class="keyword">const</span> byte *recoverableMessage, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> recoverableMessageLength,
00268 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00269 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength) <span class="keyword">const</span>;
00270 };
00271
00272 <span class="keyword">class </span>CRYPTOPP_DLL DL_SignatureMessageEncodingMethod_NR : <span class="keyword">public</span> PK_DeterministicSignatureMessageEncodingMethod
00273 {
00274 <span class="keyword">public</span>:
00275 <span class="keywordtype">void</span> ComputeMessageRepresentative(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng,
00276 <span class="keyword">const</span> byte *recoverableMessage, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> recoverableMessageLength,
00277 <a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, HashIdentifier hashIdentifier, <span class="keywordtype">bool</span> messageEmpty,
00278 byte *representative, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> representativeBitLength) <span class="keyword">const</span>;
00279 };
00280
00281 <span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_MessageAccumulatorBase : <span class="keyword">public</span> <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a>
00282 {
00283 <span class="keyword">public</span>:
00284 PK_MessageAccumulatorBase() : m_empty(true) {}
00285
00286 <span class="keyword">virtual</span> <a class="code" href="class_hash_transformation.html">HashTransformation</a> & AccessHash() =0;
00287
00288 <span class="keywordtype">void</span> Update(<span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length)
00289 {
00290 AccessHash().<a class="code" href="class_hash_transformation.html#_two_bases_3_01_message_authentication_code_00_01_variable_key_length_3_0132_00_010_00_01_u_i_n_t___m_a_x_01_4_01_4a0">Update</a>(input, length);
00291 m_empty = m_empty && length == 0;
00292 }
00293
00294 <a class="code" href="class_sec_block.html">SecByteBlock</a> m_recoverableMessage, m_representative, m_presignature, m_semisignature;
00295 <a class="code" href="class_integer.html">Integer</a> m_k, m_s;
00296 <span class="keywordtype">bool</span> m_empty;
00297 };
00298
00299 <span class="keyword">template</span> <<span class="keyword">class</span> HASH_ALGORITHM>
00300 <span class="keyword">class </span>PK_MessageAccumulatorImpl : <span class="keyword">public</span> PK_MessageAccumulatorBase, <span class="keyword">protected</span> ObjectHolder<HASH_ALGORITHM>
00301 {
00302 <span class="keyword">public</span>:
00303 <a class="code" href="class_hash_transformation.html">HashTransformation</a> & AccessHash() {<span class="keywordflow">return</span> this->m_object;}
00304 };
00305 <span class="comment"></span>
00306 <span class="comment">//! _</span>
00307 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> INTERFACE, <span class="keyword">class</span> BASE>
<a name="l00308"></a><a class="code" href="class_t_f___signature_scheme_base.html">00308</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE TF_SignatureSchemeBase : <span class="keyword">public</span> INTERFACE, <span class="keyword">protected</span> BASE
00309 {
00310 <span class="keyword">public</span>:
00311 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> SignatureLength()<span class="keyword"> const </span>
00312 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}
00313 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxRecoverableLength()<span class="keyword"> const </span>
00314 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());}
00315 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxRecoverableLengthFromSignatureLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> signatureLength)<span class="keyword"> const</span>
00316 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->MaxRecoverableLength();}
00317
00318 <span class="keywordtype">bool</span> IsProbabilistic()<span class="keyword"> const </span>
00319 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->GetTrapdoorFunctionInterface().IsRandomized() || this->GetMessageEncodingInterface().IsProbabilistic();}
00320 <span class="keywordtype">bool</span> AllowNonrecoverablePart()<span class="keyword"> const </span>
00321 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->GetMessageEncodingInterface().AllowNonrecoverablePart();}
00322 <span class="keywordtype">bool</span> RecoverablePartFirst()<span class="keyword"> const </span>
00323 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->GetMessageEncodingInterface().RecoverablePartFirst();}
00324
00325 <span class="keyword">protected</span>:
00326 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MessageRepresentativeLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> BitsToBytes(MessageRepresentativeBitLength());}
00327 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MessageRepresentativeBitLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;}
00328 <span class="keyword">virtual</span> HashIdentifier GetHashIdentifier() <span class="keyword">const</span> =0;
00329 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetDigestSize() <span class="keyword">const</span> =0;
00330 };
00331 <span class="comment"></span>
00332 <span class="comment">//! _</span>
<a name="l00333"></a><a class="code" href="class_t_f___signer_base.html">00333</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_SignerBase : <span class="keyword">public</span> TF_SignatureSchemeBase<PK_Signer, TF_Base<RandomizedTrapdoorFunctionInverse, PK_SignatureMessageEncodingMethod> >
00334 {
00335 <span class="keyword">public</span>:
00336 <span class="keywordtype">void</span> InputRecoverableMessage(<a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator, <span class="keyword">const</span> byte *recoverableMessage, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> recoverableMessageLength) <span class="keyword">const</span>;
00337 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> SignAndRestart(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator, byte *signature, <span class="keywordtype">bool</span> restart=<span class="keyword">true</span>) <span class="keyword">const</span>;
00338 };
00339 <span class="comment"></span>
00340 <span class="comment">//! _</span>
<a name="l00341"></a><a class="code" href="class_t_f___verifier_base.html">00341</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_VerifierBase : <span class="keyword">public</span> TF_SignatureSchemeBase<PK_Verifier, TF_Base<TrapdoorFunction, PK_SignatureMessageEncodingMethod> >
00342 {
00343 <span class="keyword">public</span>:
00344 <span class="keywordtype">void</span> InputSignature(<a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator, <span class="keyword">const</span> byte *signature, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> signatureLength) <span class="keyword">const</span>;
00345 <span class="keywordtype">bool</span> VerifyAndRestart(<a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator) <span class="keyword">const</span>;
00346 <a class="code" href="struct_decoding_result.html">DecodingResult</a> RecoverAndRestart(byte *recoveredMessage, <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &recoveryAccumulator) <span class="keyword">const</span>;
00347 };
00348
00349 <span class="comment">// ********************************************************</span>
00350 <span class="comment"></span>
00351 <span class="comment">//! _</span>
00352 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3>
<a name="l00353"></a><a class="code" href="struct_t_f___crypto_scheme_options.html">00353</a> <span class="keyword">struct </span><a class="code" href="struct_t_f___crypto_scheme_options.html">TF_CryptoSchemeOptions</a>
00354 {
00355 <span class="keyword">typedef</span> T1 AlgorithmInfo;
00356 <span class="keyword">typedef</span> T2 Keys;
00357 <span class="keyword">typedef</span> <span class="keyword">typename</span> Keys::PrivateKey PrivateKey;
00358 <span class="keyword">typedef</span> <span class="keyword">typename</span> Keys::PublicKey PublicKey;
00359 <span class="keyword">typedef</span> T3 MessageEncodingMethod;
00360 };
00361 <span class="comment"></span>
00362 <span class="comment">//! _</span>
00363 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4>
<a name="l00364"></a><a class="code" href="struct_t_f___signature_scheme_options.html">00364</a> <span class="keyword">struct </span><a class="code" href="struct_t_f___signature_scheme_options.html">TF_SignatureSchemeOptions</a> : <span class="keyword">public</span> <a class="code" href="struct_t_f___crypto_scheme_options.html">TF_CryptoSchemeOptions</a><T1, T2, T3>
00365 {
00366 <span class="keyword">typedef</span> T4 HashFunction;
00367 };
00368 <span class="comment"></span>
00369 <span class="comment">//! _</span>
00370 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> KEYS>
<a name="l00371"></a><a class="code" href="class_public_key_copier.html">00371</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE PublicKeyCopier
00372 {
00373 <span class="keyword">public</span>:
00374 <span class="keyword">typedef</span> <span class="keyword">typename</span> KEYS::PublicKey KeyClass;
00375 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> KEYS::PublicKey &key) <span class="keyword">const</span> =0;
00376 };
00377 <span class="comment"></span>
00378 <span class="comment">//! _</span>
00379 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> KEYS>
<a name="l00380"></a><a class="code" href="class_private_key_copier.html">00380</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE PrivateKeyCopier
00381 {
00382 <span class="keyword">public</span>:
00383 <span class="keyword">typedef</span> <span class="keyword">typename</span> KEYS::PrivateKey KeyClass;
00384 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> KEYS::PublicKey &key) <span class="keyword">const</span> =0;
00385 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> KEYS::PrivateKey &key) <span class="keyword">const</span> =0;
00386 };
00387 <span class="comment"></span>
00388 <span class="comment">//! _</span>
00389 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS, <span class="keyword">class</span> KEY>
<a name="l00390"></a><a class="code" href="class_t_f___object_impl_base.html">00390</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE TF_ObjectImplBase : <span class="keyword">public</span> <a class="code" href="class_algorithm_impl.html">AlgorithmImpl</a><BASE, typename SCHEME_OPTIONS::AlgorithmInfo>
00391 {
00392 <span class="keyword">public</span>:
00393 <span class="keyword">typedef</span> SCHEME_OPTIONS SchemeOptions;
00394 <span class="keyword">typedef</span> KEY KeyClass;
00395
00396 <a class="code" href="class_public_key.html">PublicKey</a> & AccessPublicKey() {<span class="keywordflow">return</span> AccessKey();}
00397 <span class="keyword">const</span> <a class="code" href="class_public_key.html">PublicKey</a> & GetPublicKey()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetKey();}
00398
00399 <a class="code" href="class_private_key.html">PrivateKey</a> & AccessPrivateKey() {<span class="keywordflow">return</span> AccessKey();}
00400 <span class="keyword">const</span> <a class="code" href="class_private_key.html">PrivateKey</a> & GetPrivateKey()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetKey();}
00401
00402 <span class="keyword">virtual</span> <span class="keyword">const</span> KeyClass & GetKey() <span class="keyword">const</span> =0;
00403 <span class="keyword">virtual</span> KeyClass & AccessKey() =0;
00404
00405 <span class="keyword">const</span> KeyClass & GetTrapdoorFunction()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetKey();}
00406
00407 <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> * NewSignatureAccumulator(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng)<span class="keyword"> const</span>
00408 <span class="keyword"> </span>{
00409 <span class="keywordflow">return</span> <span class="keyword">new</span> PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>;
00410 }
00411 <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> * NewVerificationAccumulator()<span class="keyword"> const</span>
00412 <span class="keyword"> </span>{
00413 <span class="keywordflow">return</span> <span class="keyword">new</span> PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>;
00414 }
00415
00416 <span class="keyword">protected</span>:
00417 <span class="keyword">const</span> <span class="keyword">typename</span> BASE::MessageEncodingInterface & GetMessageEncodingInterface()<span class="keyword"> const </span>
00418 <span class="keyword"> </span>{<span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<CPP_TYPENAME SCHEME_OPTIONS::MessageEncodingMethod></a>().Ref();}
00419 <span class="keyword">const</span> <a class="code" href="class_trapdoor_function_bounds.html">TrapdoorFunctionBounds</a> & GetTrapdoorFunctionBounds()<span class="keyword"> const </span>
00420 <span class="keyword"> </span>{<span class="keywordflow">return</span> GetKey();}
00421 <span class="keyword">const</span> <span class="keyword">typename</span> BASE::TrapdoorFunctionInterface & GetTrapdoorFunctionInterface()<span class="keyword"> const </span>
00422 <span class="keyword"> </span>{<span class="keywordflow">return</span> GetKey();}
00423
00424 <span class="comment">// for signature scheme</span>
00425 HashIdentifier GetHashIdentifier()<span class="keyword"> const</span>
00426 <span class="keyword"> </span>{
00427 <span class="keyword">typedef</span> CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;
00428 <span class="keywordflow">return</span> L::Lookup();
00429 }
00430 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetDigestSize()<span class="keyword"> const</span>
00431 <span class="keyword"> </span>{
00432 <span class="keyword">typedef</span> CPP_TYPENAME SchemeOptions::HashFunction H;
00433 <span class="keywordflow">return</span> H::DIGESTSIZE;
00434 }
00435 };
00436 <span class="comment"></span>
00437 <span class="comment">//! _</span>
00438 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS, <span class="keyword">class</span> KEY>
<a name="l00439"></a><a class="code" href="class_t_f___object_impl_ext_ref.html">00439</a> <span class="keyword">class </span><a class="code" href="class_t_f___object_impl_ext_ref.html">TF_ObjectImplExtRef</a> : <span class="keyword">public</span> TF_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>
00440 {
00441 <span class="keyword">public</span>:
00442 <a class="code" href="class_t_f___object_impl_ext_ref.html">TF_ObjectImplExtRef</a>(<span class="keyword">const</span> KEY *pKey = NULL) : m_pKey(pKey) {}
00443 <span class="keywordtype">void</span> SetKeyPtr(<span class="keyword">const</span> KEY *pKey) {m_pKey = pKey;}
00444
00445 <span class="keyword">const</span> KEY & GetKey()<span class="keyword"> const </span>{<span class="keywordflow">return</span> *m_pKey;}
00446 KEY & AccessKey() {<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"TF_ObjectImplExtRef: cannot modify refererenced key"</span>);}
00447
00448 <span class="keyword">private</span>:
00449 <span class="keyword">const</span> KEY * m_pKey;
00450 };
00451 <span class="comment"></span>
00452 <span class="comment">//! _</span>
00453 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS, <span class="keyword">class</span> KEY_COPIER>
<a name="l00454"></a><a class="code" href="class_t_f___object_impl.html">00454</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE TF_ObjectImpl : <span class="keyword">public</span> TF_ObjectImplBase<TwoBases<BASE, KEY_COPIER>, SCHEME_OPTIONS, typename KEY_COPIER::KeyClass>
00455 {
00456 <span class="keyword">public</span>:
00457 <span class="keyword">typedef</span> <span class="keyword">typename</span> KEY_COPIER::KeyClass KeyClass;
00458
00459 <span class="keyword">const</span> KeyClass & GetKey()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_trapdoorFunction;}
00460 KeyClass & AccessKey() {<span class="keywordflow">return</span> m_trapdoorFunction;}
00461
00462 <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> SCHEME_OPTIONS::PrivateKey &key)<span class="keyword"> const </span>{key = GetKey();}
00463 <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> SCHEME_OPTIONS::PublicKey &key)<span class="keyword"> const </span>{key = GetKey();}
00464
00465 <span class="keyword">private</span>:
00466 KeyClass m_trapdoorFunction;
00467 };
00468 <span class="comment"></span>
00469 <span class="comment">//! _</span>
00470 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l00471"></a><a class="code" href="class_t_f___decryptor_impl.html">00471</a> <span class="keyword">class </span><a class="code" href="class_t_f___decryptor_impl.html">TF_DecryptorImpl</a> : <span class="keyword">public</span> TF_ObjectImpl<TF_DecryptorBase, SCHEME_OPTIONS, PrivateKeyCopier<typename SCHEME_OPTIONS::Keys> >
00472 {
00473 };
00474 <span class="comment"></span>
00475 <span class="comment">//! _</span>
00476 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l00477"></a><a class="code" href="class_t_f___encryptor_impl.html">00477</a> <span class="keyword">class </span><a class="code" href="class_t_f___encryptor_impl.html">TF_EncryptorImpl</a> : <span class="keyword">public</span> TF_ObjectImpl<TF_EncryptorBase, SCHEME_OPTIONS, PublicKeyCopier<typename SCHEME_OPTIONS::Keys> >
00478 {
00479 };
00480 <span class="comment"></span>
00481 <span class="comment">//! _</span>
00482 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l00483"></a><a class="code" href="class_t_f___signer_impl.html">00483</a> <span class="keyword">class </span><a class="code" href="class_t_f___signer_impl.html">TF_SignerImpl</a> : <span class="keyword">public</span> TF_ObjectImpl<TF_SignerBase, SCHEME_OPTIONS, PrivateKeyCopier<typename SCHEME_OPTIONS::Keys> >
00484 {
00485 };
00486 <span class="comment"></span>
00487 <span class="comment">//! _</span>
00488 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l00489"></a><a class="code" href="class_t_f___verifier_impl.html">00489</a> <span class="keyword">class </span><a class="code" href="class_t_f___verifier_impl.html">TF_VerifierImpl</a> : <span class="keyword">public</span> TF_ObjectImpl<TF_VerifierBase, SCHEME_OPTIONS, PublicKeyCopier<typename SCHEME_OPTIONS::Keys> >
00490 {
00491 };
00492
00493 <span class="comment">// ********************************************************</span>
00494 <span class="comment"></span>
00495 <span class="comment">//! _</span>
<a name="l00496"></a><a class="code" href="class_mask_generating_function.html">00496</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_NO_VTABLE MaskGeneratingFunction
00497 {
00498 <span class="keyword">public</span>:
00499 <span class="keyword">virtual</span> ~MaskGeneratingFunction() {}
00500 <span class="keyword">virtual</span> <span class="keywordtype">void</span> GenerateAndMask(<a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, byte *output, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> outputLength, <span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> inputLength, <span class="keywordtype">bool</span> mask = <span class="keyword">true</span>) <span class="keyword">const</span> =0;
00501 };
00502
00503 CRYPTOPP_DLL <span class="keywordtype">void</span> P1363_MGF1KDF2_Common(<a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, byte *output, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> outputLength, <span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> inputLength, <span class="keyword">const</span> byte *derivationParams, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> derivationParamsLength, <span class="keywordtype">bool</span> mask, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> counterStart);
00504 <span class="comment"></span>
00505 <span class="comment">//! _</span>
<a name="l00506"></a><a class="code" href="class_p1363___m_g_f1.html">00506</a> <span class="comment"></span><span class="keyword">class </span><a class="code" href="class_p1363___m_g_f1.html">P1363_MGF1</a> : <span class="keyword">public</span> MaskGeneratingFunction
00507 {
00508 <span class="keyword">public</span>:
00509 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> * StaticAlgorithmName() {<span class="keywordflow">return</span> <span class="stringliteral">"MGF1"</span>;}
00510 <span class="keywordtype">void</span> GenerateAndMask(<a class="code" href="class_hash_transformation.html">HashTransformation</a> &hash, byte *output, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> outputLength, <span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> inputLength, <span class="keywordtype">bool</span> mask = <span class="keyword">true</span>)<span class="keyword"> const</span>
00511 <span class="keyword"> </span>{
00512 P1363_MGF1KDF2_Common(hash, output, outputLength, input, inputLength, NULL, 0, mask, 0);
00513 }
00514 };
00515
00516 <span class="comment">// ********************************************************</span>
00517 <span class="comment"></span>
00518 <span class="comment">//! _</span>
00519 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> H>
<a name="l00520"></a><a class="code" href="class_p1363___k_d_f2.html">00520</a> <span class="keyword">class </span><a class="code" href="class_p1363___k_d_f2.html">P1363_KDF2</a>
00521 {
00522 <span class="keyword">public</span>:
00523 <span class="keyword">static</span> <span class="keywordtype">void</span> DeriveKey(byte *output, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> outputLength, <span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> inputLength, <span class="keyword">const</span> byte *derivationParams, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> derivationParamsLength)
00524 {
00525 H h;
00526 P1363_MGF1KDF2_Common(h, output, outputLength, input, inputLength, derivationParams, derivationParamsLength, <span class="keyword">false</span>, 1);
00527 }
00528 };
00529
00530 <span class="comment">// ********************************************************</span>
00531 <span class="comment"></span>
00532 <span class="comment">//! to be thrown by DecodeElement and AgreeWithStaticPrivateKey</span>
<a name="l00533"></a><a class="code" href="class_d_l___bad_element.html">00533</a> <span class="comment"></span><span class="keyword">class </span><a class="code" href="class_d_l___bad_element.html">DL_BadElement</a> : <span class="keyword">public</span> <a class="code" href="class_invalid_data_format.html">InvalidDataFormat</a>
00534 {
00535 <span class="keyword">public</span>:
00536 <a class="code" href="class_d_l___bad_element.html">DL_BadElement</a>() : <a class="code" href="class_invalid_data_format.html">InvalidDataFormat</a>(<span class="stringliteral">"CryptoPP: invalid group element"</span>) {}
00537 };
00538 <span class="comment"></span>
00539 <span class="comment">//! interface for DL group parameters</span>
00540 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00541"></a><a class="code" href="class_d_l___group_parameters.html">00541</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_GroupParameters : <span class="keyword">public</span> <a class="code" href="class_crypto_parameters.html">CryptoParameters</a>
00542 {
00543 <span class="keyword">typedef</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> <a class="code" href="class_d_l___group_parameters.html">ThisClass</a>;
00544
00545 <span class="keyword">public</span>:
00546 <span class="keyword">typedef</span> T Element;
00547
00548 DL_GroupParameters() : m_validationLevel(0) {}
00549
00550 <span class="comment">// CryptoMaterial</span>
<a name="l00551"></a><a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa1">00551</a> <span class="keywordtype">bool</span> Validate(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> level)<span class="keyword"> const</span>
00552 <span class="keyword"> </span>{
00553 <span class="keywordflow">if</span> (!GetBasePrecomputation().IsInitialized())
00554 <span class="keywordflow">return</span> <span class="keyword">false</span>;
00555
00556 <span class="keywordflow">if</span> (m_validationLevel > level)
00557 <span class="keywordflow">return</span> <span class="keyword">true</span>;
00558
00559 <span class="keywordtype">bool</span> pass = ValidateGroup(rng, level);
00560 pass = pass && ValidateElement(level, GetSubgroupGenerator(), &GetBasePrecomputation());
00561
00562 m_validationLevel = pass ? level+1 : 0;
00563
00564 <span class="keywordflow">return</span> pass;
00565 }
00566
<a name="l00567"></a><a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa2">00567</a> <span class="keywordtype">bool</span> GetVoidValue(<span class="keyword">const</span> <span class="keywordtype">char</span> *name, <span class="keyword">const</span> std::type_info &valueType, <span class="keywordtype">void</span> *pValue)<span class="keyword"> const</span>
00568 <span class="keyword"> </span>{
00569 <span class="keywordflow">return</span> GetValueHelper(<span class="keyword">this</span>, name, valueType, pValue)
00570 CRYPTOPP_GET_FUNCTION_ENTRY(SubgroupOrder)
00571 CRYPTOPP_GET_FUNCTION_ENTRY(SubgroupGenerator)
00572 ;
00573 }
00574
<a name="l00575"></a><a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa3">00575</a> <span class="keywordtype">bool</span> <a class="code" href="class_crypto_material.html#_x_t_r___d_ha32">SupportsPrecomputation</a>()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00576
<a name="l00577"></a><a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa4">00577</a> <span class="keywordtype">void</span> Precompute(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> precomputationStorage=16)
00578 {
00579 AccessBasePrecomputation().Precompute(GetGroupPrecomputation(), GetSubgroupOrder().BitCount(), precomputationStorage);
00580 }
00581
<a name="l00582"></a><a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa5">00582</a> <span class="keywordtype">void</span> LoadPrecomputation(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &storedPrecomputation)
00583 {
00584 AccessBasePrecomputation().Load(GetGroupPrecomputation(), storedPrecomputation);
00585 m_validationLevel = 0;
00586 }
00587
<a name="l00588"></a><a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa6">00588</a> <span class="keywordtype">void</span> SavePrecomputation(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &storedPrecomputation)<span class="keyword"> const</span>
00589 <span class="keyword"> </span>{
00590 GetBasePrecomputation().Save(GetGroupPrecomputation(), storedPrecomputation);
00591 }
00592
00593 <span class="comment">// non-inherited</span>
00594 <span class="keyword">virtual</span> <span class="keyword">const</span> Element & GetSubgroupGenerator()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetBasePrecomputation().GetBase(GetGroupPrecomputation());}
00595 <span class="keyword">virtual</span> <span class="keywordtype">void</span> SetSubgroupGenerator(<span class="keyword">const</span> Element &base) {AccessBasePrecomputation().SetBase(GetGroupPrecomputation(), base);}
00596 <span class="keyword">virtual</span> Element ExponentiateBase(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &exponent)<span class="keyword"> const</span>
00597 <span class="keyword"> </span>{
00598 <span class="keywordflow">return</span> GetBasePrecomputation().Exponentiate(GetGroupPrecomputation(), exponent);
00599 }
00600 <span class="keyword">virtual</span> Element ExponentiateElement(<span class="keyword">const</span> Element &base, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &exponent)<span class="keyword"> const</span>
00601 <span class="keyword"> </span>{
00602 Element result;
00603 SimultaneousExponentiate(&result, base, &exponent, 1);
00604 <span class="keywordflow">return</span> result;
00605 }
00606
00607 <span class="keyword">virtual</span> <span class="keyword">const</span> DL_GroupPrecomputation<Element> & GetGroupPrecomputation() const =0;
00608 virtual const DL_FixedBasePrecomputation<Element> & GetBasePrecomputation() const =0;
00609 virtual DL_FixedBasePrecomputation<Element> & AccessBasePrecomputation() =0;
00610 virtual const <a class="code" href="class_integer.html">Integer</a> & GetSubgroupOrder() const =0; <span class="comment">// order of subgroup generated by base element</span>
00611 virtual <a class="code" href="class_integer.html">Integer</a> GetMaxExponent() const =0;
00612 virtual <a class="code" href="class_integer.html">Integer</a> GetGroupOrder()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetSubgroupOrder()*GetCofactor();} <span class="comment">// one of these two needs to be overriden</span>
00613 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> GetCofactor()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetGroupOrder()/GetSubgroupOrder();}
00614 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetEncodedElementSize(<span class="keywordtype">bool</span> reversible) <span class="keyword">const</span> =0;
00615 <span class="keyword">virtual</span> <span class="keywordtype">void</span> EncodeElement(<span class="keywordtype">bool</span> reversible, <span class="keyword">const</span> Element &element, byte *encoded) <span class="keyword">const</span> =0;
00616 <span class="keyword">virtual</span> Element DecodeElement(<span class="keyword">const</span> byte *encoded, <span class="keywordtype">bool</span> checkForGroupMembership) <span class="keyword">const</span> =0;
00617 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> ConvertElementToInteger(<span class="keyword">const</span> Element &element) <span class="keyword">const</span> =0;
00618 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> ValidateGroup(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> level) <span class="keyword">const</span> =0;
00619 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> ValidateElement(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> level, <span class="keyword">const</span> Element &element, <span class="keyword">const</span> DL_FixedBasePrecomputation<Element> *precomp) <span class="keyword">const</span> =0;
00620 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> FastSubgroupCheckAvailable() const =0;
00621 virtual <span class="keywordtype">bool</span> IsIdentity(const Element &element) const =0;
00622 virtual <span class="keywordtype">void</span> SimultaneousExponentiate(Element *results, const Element &base, const <a class="code" href="class_integer.html">Integer</a> *exponents, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> exponentsCount) const =0;
00623
00624 protected:
00625 <span class="keywordtype">void</span> ParametersChanged() {m_validationLevel = 0;}
00626
00627 <span class="keyword">private</span>:
00628 <span class="keyword">mutable</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> m_validationLevel;
00629 };
00630 <span class="comment"></span>
00631 <span class="comment">//! _</span>
00632 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> GROUP_PRECOMP, <span class="keyword">class</span> BASE_PRECOMP = DL_FixedBasePrecomputationImpl<CPP_TYPENAME GROUP_PRECOMP::Element>, <span class="keyword">class</span> BASE = DL_GroupParameters<CPP_TYPENAME GROUP_PRECOMP::Element> >
<a name="l00633"></a><a class="code" href="class_d_l___group_parameters_impl.html">00633</a> <span class="keyword">class </span><a class="code" href="class_d_l___group_parameters_impl.html">DL_GroupParametersImpl</a> : <span class="keyword">public</span> BASE
00634 {
00635 <span class="keyword">public</span>:
00636 <span class="keyword">typedef</span> GROUP_PRECOMP GroupPrecomputation;
00637 <span class="keyword">typedef</span> <span class="keyword">typename</span> GROUP_PRECOMP::Element Element;
00638 <span class="keyword">typedef</span> BASE_PRECOMP BasePrecomputation;
00639
00640 <span class="keyword">const</span> DL_GroupPrecomputation<Element> & GetGroupPrecomputation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_groupPrecomputation;}
00641 <span class="keyword">const</span> DL_FixedBasePrecomputation<Element> & GetBasePrecomputation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_gpc;}
00642 DL_FixedBasePrecomputation<Element> & AccessBasePrecomputation() {<span class="keywordflow">return</span> m_gpc;}
00643
00644 <span class="keyword">protected</span>:
00645 GROUP_PRECOMP m_groupPrecomputation;
00646 BASE_PRECOMP m_gpc;
00647 };
00648 <span class="comment"></span>
00649 <span class="comment">//! _</span>
00650 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00651"></a><a class="code" href="class_d_l___key.html">00651</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_Key
00652 {
00653 <span class="keyword">public</span>:
00654 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> & GetAbstractGroupParameters() <span class="keyword">const</span> =0;
00655 <span class="keyword">virtual</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> & AccessAbstractGroupParameters() =0;
00656 };
00657 <span class="comment"></span>
00658 <span class="comment">//! interface for DL public keys</span>
00659 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00660"></a><a class="code" href="class_d_l___public_key.html">00660</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_PublicKey : <span class="keyword">public</span> DL_Key<T>
00661 {
00662 <span class="keyword">typedef</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> <a class="code" href="class_d_l___public_key.html">ThisClass</a>;
00663
00664 <span class="keyword">public</span>:
00665 <span class="keyword">typedef</span> T Element;
00666
00667 <span class="keywordtype">bool</span> GetVoidValue(<span class="keyword">const</span> <span class="keywordtype">char</span> *name, <span class="keyword">const</span> std::type_info &valueType, <span class="keywordtype">void</span> *pValue)<span class="keyword"> const</span>
00668 <span class="keyword"> </span>{
00669 <span class="keywordflow">return</span> GetValueHelper(<span class="keyword">this</span>, name, valueType, pValue, &this->GetAbstractGroupParameters())
00670 CRYPTOPP_GET_FUNCTION_ENTRY(PublicElement);
00671 }
00672
00673 <span class="keywordtype">void</span> AssignFrom(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &source);
00674
00675 <span class="comment">// non-inherited</span>
00676 <span class="keyword">virtual</span> <span class="keyword">const</span> Element & GetPublicElement()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetPublicPrecomputation().GetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation());}
00677 <span class="keyword">virtual</span> <span class="keywordtype">void</span> SetPublicElement(<span class="keyword">const</span> Element &y) {AccessPublicPrecomputation().SetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation(), y);}
00678 <span class="keyword">virtual</span> Element ExponentiatePublicElement(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &exponent)<span class="keyword"> const</span>
00679 <span class="keyword"> </span>{
00680 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
00681 <span class="keywordflow">return</span> GetPublicPrecomputation().Exponentiate(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa11">GetGroupPrecomputation</a>(), exponent);
00682 }
00683 <span class="keyword">virtual</span> Element CascadeExponentiateBaseAndPublicElement(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &baseExp, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &publicExp)<span class="keyword"> const</span>
00684 <span class="keyword"> </span>{
00685 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
00686 <span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa12">GetBasePrecomputation</a>().CascadeExponentiate(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa11">GetGroupPrecomputation</a>(), baseExp, GetPublicPrecomputation(), publicExp);
00687 }
00688
00689 <span class="keyword">virtual</span> <span class="keyword">const</span> DL_FixedBasePrecomputation<T> & GetPublicPrecomputation() <span class="keyword">const</span> =0;
00690 <span class="keyword">virtual</span> DL_FixedBasePrecomputation<T> & AccessPublicPrecomputation() =0;
00691 };
00692 <span class="comment"></span>
00693 <span class="comment">//! interface for DL private keys</span>
00694 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00695"></a><a class="code" href="class_d_l___private_key.html">00695</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_PrivateKey : <span class="keyword">public</span> DL_Key<T>
00696 {
00697 <span class="keyword">typedef</span> <a class="code" href="class_d_l___private_key.html">DL_PrivateKey<T></a> <a class="code" href="class_d_l___private_key.html">ThisClass</a>;
00698
00699 <span class="keyword">public</span>:
00700 <span class="keyword">typedef</span> T Element;
00701
00702 <span class="keywordtype">void</span> MakePublicKey(<a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> &pub)<span class="keyword"> const</span>
00703 <span class="keyword"> </span>{
00704 pub.<a class="code" href="class_d_l___key.html#_d_l___public_keya9">AccessAbstractGroupParameters</a>().AssignFrom(this->GetAbstractGroupParameters());
00705 pub.<a class="code" href="class_d_l___public_key.html#_d_l___public_keya3">SetPublicElement</a>(this->GetAbstractGroupParameters().ExponentiateBase(GetPrivateExponent()));
00706 }
00707
00708 <span class="keywordtype">bool</span> GetVoidValue(<span class="keyword">const</span> <span class="keywordtype">char</span> *name, <span class="keyword">const</span> std::type_info &valueType, <span class="keywordtype">void</span> *pValue)<span class="keyword"> const</span>
00709 <span class="keyword"> </span>{
00710 <span class="keywordflow">return</span> GetValueHelper(<span class="keyword">this</span>, name, valueType, pValue, &this->GetAbstractGroupParameters())
00711 CRYPTOPP_GET_FUNCTION_ENTRY(PrivateExponent);
00712 }
00713
00714 <span class="keywordtype">void</span> AssignFrom(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &source)
00715 {
00716 this->AccessAbstractGroupParameters().AssignFrom(source);
00717 AssignFromHelper(<span class="keyword">this</span>, source)
00718 CRYPTOPP_SET_FUNCTION_ENTRY(PrivateExponent);
00719 }
00720
00721 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> & GetPrivateExponent() <span class="keyword">const</span> =0;
00722 <span class="keyword">virtual</span> <span class="keywordtype">void</span> SetPrivateExponent(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x) =0;
00723 };
00724
00725 <span class="keyword">template</span> <<span class="keyword">class</span> T>
00726 <span class="keywordtype">void</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T>::AssignFrom</a>(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &source)
00727 {
00728 <a class="code" href="class_d_l___private_key.html">DL_PrivateKey<T></a> *pPrivateKey = NULL;
00729 <span class="keywordflow">if</span> (source.<a class="code" href="class_name_value_pairs.html#_x_t_r___d_ha38">GetThisPointer</a>(pPrivateKey))
00730 pPrivateKey-><a class="code" href="class_d_l___private_key.html#_d_l___private_keya0">MakePublicKey</a>(*<span class="keyword">this</span>);
00731 <span class="keywordflow">else</span>
00732 {
00733 this->AccessAbstractGroupParameters().AssignFrom(source);
00734 AssignFromHelper(<span class="keyword">this</span>, source)
00735 CRYPTOPP_SET_FUNCTION_ENTRY(PublicElement);
00736 }
00737 }
00738
00739 class <a class="code" href="class_o_i_d.html">OID</a>;
00740 <span class="comment"></span>
00741 <span class="comment">//! _</span>
00742 <span class="comment"></span>template <class PK, class GP, class O = OID>
<a name="l00743"></a><a class="code" href="class_d_l___key_impl.html">00743</a> class <a class="code" href="class_d_l___key_impl.html">DL_KeyImpl</a> : public PK
00744 {
00745 <span class="keyword">public</span>:
00746 <span class="keyword">typedef</span> GP GroupParameters;
00747
00748 O GetAlgorithmID()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetGroupParameters().GetAlgorithmID();}
00749 <span class="comment">// void BERDecode(BufferedTransformation &bt)</span>
00750 <span class="comment">// {PK::BERDecode(bt);}</span>
00751 <span class="comment">// void DEREncode(BufferedTransformation &bt) const</span>
00752 <span class="comment">// {PK::DEREncode(bt);}</span>
00753 <span class="keywordtype">bool</span> BERDecodeAlgorithmParameters(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &bt)
00754 {AccessGroupParameters().BERDecode(bt); <span class="keywordflow">return</span> <span class="keyword">true</span>;}
00755 <span class="keywordtype">bool</span> DEREncodeAlgorithmParameters(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &bt)<span class="keyword"> const</span>
00756 <span class="keyword"> </span>{GetGroupParameters().DEREncode(bt); <span class="keywordflow">return</span> <span class="keyword">true</span>;}
00757
00758 <span class="keyword">const</span> GP & GetGroupParameters()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_groupParameters;}
00759 GP & AccessGroupParameters() {<span class="keywordflow">return</span> m_groupParameters;}
00760
00761 <span class="keyword">private</span>:
00762 GP m_groupParameters;
00763 };
00764
00765 <span class="keyword">class </span><a class="code" href="class_x509_public_key.html">X509PublicKey</a>;
00766 <span class="keyword">class </span><a class="code" href="class_p_k_c_s8_private_key.html">PKCS8PrivateKey</a>;
00767 <span class="comment"></span>
00768 <span class="comment">//! _</span>
00769 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> GP>
<a name="l00770"></a><a class="code" href="class_d_l___private_key_impl.html">00770</a> <span class="keyword">class </span><a class="code" href="class_d_l___private_key_impl.html">DL_PrivateKeyImpl</a> : <span class="keyword">public</span> DL_PrivateKey<CPP_TYPENAME GP::Element>, <span class="keyword">public</span> <a class="code" href="class_d_l___key_impl.html">DL_KeyImpl</a><PKCS8PrivateKey, GP>
00771 {
00772 <span class="keyword">public</span>:
00773 <span class="keyword">typedef</span> <span class="keyword">typename</span> GP::Element Element;
00774
00775 <span class="comment">// GeneratableCryptoMaterial</span>
<a name="l00776"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla0">00776</a> <span class="keywordtype">bool</span> Validate(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> level)<span class="keyword"> const</span>
00777 <span class="keyword"> </span>{
00778 <span class="keywordtype">bool</span> pass = GetAbstractGroupParameters().Validate(rng, level);
00779
00780 <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &q = GetAbstractGroupParameters().GetSubgroupOrder();
00781 <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x = GetPrivateExponent();
00782
00783 pass = pass && x.IsPositive() && x < q;
00784 <span class="keywordflow">if</span> (level >= 1)
00785 pass = pass && Integer::Gcd(x, q) == <a class="code" href="class_integer.html#_integerz37_13">Integer::One</a>();
00786 <span class="keywordflow">return</span> pass;
00787 }
00788
00789 <span class="keywordtype">bool</span> GetVoidValue(<span class="keyword">const</span> <span class="keywordtype">char</span> *name, <span class="keyword">const</span> std::type_info &valueType, <span class="keywordtype">void</span> *pValue)<span class="keyword"> const</span>
00790 <span class="keyword"> </span>{
00791 <span class="keywordflow">return</span> GetValueHelper<DL_PrivateKey<Element> >(<span class="keyword">this</span>, name, valueType, pValue).Assignable();
00792 }
00793
00794 <span class="keywordtype">void</span> AssignFrom(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &source)
00795 {
00796 AssignFromHelper<DL_PrivateKey<Element> >(<span class="keyword">this</span>, source);
00797 }
00798
<a name="l00799"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla3">00799</a> <span class="keywordtype">void</span> GenerateRandom(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params)
00800 {
00801 <span class="keywordflow">if</span> (!params.<a class="code" href="class_name_value_pairs.html#_x_t_r___d_ha37">GetThisObject</a>(this->AccessGroupParameters()))
00802 this->AccessGroupParameters().GenerateRandom(rng, params);
00803 <span class="comment">// std::pair<const byte *, int> seed;</span>
00804 <a class="code" href="class_integer.html">Integer</a> x(rng, Integer::One(), GetAbstractGroupParameters().GetMaxExponent());
00805 <span class="comment">// Integer::ANY, Integer::Zero(), Integer::One(),</span>
00806 <span class="comment">// params.GetValue("DeterministicKeyGenerationSeed", seed) ? &seed : NULL);</span>
00807 SetPrivateExponent(x);
00808 }
00809
<a name="l00810"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla4">00810</a> <span class="keywordtype">bool</span> SupportsPrecomputation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00811
<a name="l00812"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla5">00812</a> <span class="keywordtype">void</span> Precompute(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> precomputationStorage=16)
00813 {AccessAbstractGroupParameters().Precompute(precomputationStorage);}
00814
<a name="l00815"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla6">00815</a> <span class="keywordtype">void</span> LoadPrecomputation(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &storedPrecomputation)
00816 {AccessAbstractGroupParameters().LoadPrecomputation(storedPrecomputation);}
00817
<a name="l00818"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla7">00818</a> <span class="keywordtype">void</span> SavePrecomputation(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &storedPrecomputation)<span class="keyword"> const</span>
00819 <span class="keyword"> </span>{GetAbstractGroupParameters().SavePrecomputation(storedPrecomputation);}
00820
00821 <span class="comment">// DL_Key</span>
00822 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> & GetAbstractGroupParameters()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetGroupParameters();}
00823 <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> & AccessAbstractGroupParameters() {<span class="keywordflow">return</span> this->AccessGroupParameters();}
00824
00825 <span class="comment">// DL_PrivateKey</span>
00826 <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> & GetPrivateExponent()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_x;}
00827 <span class="keywordtype">void</span> SetPrivateExponent(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &x) {m_x = x;}
00828
00829 <span class="comment">// PKCS8PrivateKey</span>
<a name="l00830"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla12">00830</a> <span class="keywordtype">void</span> BERDecodeKey(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &bt)
00831 {m_x.BERDecode(bt);}
<a name="l00832"></a><a class="code" href="class_d_l___private_key_impl.html#_d_l___private_key_impla13">00832</a> <span class="keywordtype">void</span> DEREncodeKey(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &bt)<span class="keyword"> const</span>
00833 <span class="keyword"> </span>{m_x.DEREncode(bt);}
00834
00835 <span class="keyword">private</span>:
00836 <a class="code" href="class_integer.html">Integer</a> m_x;
00837 };
00838 <span class="comment"></span>
00839 <span class="comment">//! _</span>
00840 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SIGNATURE_SCHEME>
<a name="l00841"></a><a class="code" href="class_d_l___private_key___with_signature_pairwise_consistency_test.html">00841</a> <span class="keyword">class </span><a class="code" href="class_d_l___private_key___with_signature_pairwise_consistency_test.html">DL_PrivateKey_WithSignaturePairwiseConsistencyTest</a> : <span class="keyword">public</span> BASE
00842 {
00843 <span class="keyword">public</span>:
00844 <span class="keywordtype">void</span> GenerateRandom(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params)
00845 {
00846 BASE::GenerateRandom(rng, params);
00847
00848 <span class="keywordflow">if</span> (FIPS_140_2_ComplianceEnabled())
00849 {
00850 <span class="keyword">typename</span> SIGNATURE_SCHEME::Signer signer(*<span class="keyword">this</span>);
00851 <span class="keyword">typename</span> SIGNATURE_SCHEME::Verifier verifier(signer);
00852 SignaturePairwiseConsistencyTest_FIPS_140_Only(signer, verifier);
00853 }
00854 }
00855 };
00856 <span class="comment"></span>
00857 <span class="comment">//! _</span>
00858 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> GP>
<a name="l00859"></a><a class="code" href="class_d_l___public_key_impl.html">00859</a> <span class="keyword">class </span><a class="code" href="class_d_l___public_key_impl.html">DL_PublicKeyImpl</a> : <span class="keyword">public</span> DL_PublicKey<typename GP::Element>, <span class="keyword">public</span> <a class="code" href="class_d_l___key_impl.html">DL_KeyImpl</a><X509PublicKey, GP>
00860 {
00861 <span class="keyword">public</span>:
00862 <span class="keyword">typedef</span> <span class="keyword">typename</span> GP::Element Element;
00863
00864 <span class="comment">// CryptoMaterial</span>
<a name="l00865"></a><a class="code" href="class_d_l___public_key_impl.html#_d_l___public_key_impla0">00865</a> <span class="keywordtype">bool</span> Validate(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> level)<span class="keyword"> const</span>
00866 <span class="keyword"> </span>{
00867 <span class="keywordtype">bool</span> pass = GetAbstractGroupParameters().Validate(rng, level);
00868 pass = pass && GetAbstractGroupParameters().ValidateElement(level, this->GetPublicElement(), &GetPublicPrecomputation());
00869 <span class="keywordflow">return</span> pass;
00870 }
00871
00872 <span class="keywordtype">bool</span> GetVoidValue(<span class="keyword">const</span> <span class="keywordtype">char</span> *name, <span class="keyword">const</span> std::type_info &valueType, <span class="keywordtype">void</span> *pValue)<span class="keyword"> const</span>
00873 <span class="keyword"> </span>{
00874 <span class="keywordflow">return</span> GetValueHelper<DL_PublicKey<Element> >(<span class="keyword">this</span>, name, valueType, pValue).Assignable();
00875 }
00876
00877 <span class="keywordtype">void</span> AssignFrom(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &source)
00878 {
00879 AssignFromHelper<DL_PublicKey<Element> >(<span class="keyword">this</span>, source);
00880 }
00881
<a name="l00882"></a><a class="code" href="class_d_l___public_key_impl.html#_d_l___public_key_impla3">00882</a> <span class="keywordtype">bool</span> SupportsPrecomputation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00883
<a name="l00884"></a><a class="code" href="class_d_l___public_key_impl.html#_d_l___public_key_impla4">00884</a> <span class="keywordtype">void</span> Precompute(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> precomputationStorage=16)
00885 {
00886 AccessAbstractGroupParameters().Precompute(precomputationStorage);
00887 AccessPublicPrecomputation().Precompute(GetAbstractGroupParameters().GetGroupPrecomputation(), GetAbstractGroupParameters().GetSubgroupOrder().BitCount(), precomputationStorage);
00888 }
00889
<a name="l00890"></a><a class="code" href="class_d_l___public_key_impl.html#_d_l___public_key_impla5">00890</a> <span class="keywordtype">void</span> LoadPrecomputation(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &storedPrecomputation)
00891 {
00892 AccessAbstractGroupParameters().LoadPrecomputation(storedPrecomputation);
00893 AccessPublicPrecomputation().Load(GetAbstractGroupParameters().GetGroupPrecomputation(), storedPrecomputation);
00894 }
00895
<a name="l00896"></a><a class="code" href="class_d_l___public_key_impl.html#_d_l___public_key_impla6">00896</a> <span class="keywordtype">void</span> SavePrecomputation(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &storedPrecomputation)<span class="keyword"> const</span>
00897 <span class="keyword"> </span>{
00898 GetAbstractGroupParameters().SavePrecomputation(storedPrecomputation);
00899 GetPublicPrecomputation().Save(GetAbstractGroupParameters().GetGroupPrecomputation(), storedPrecomputation);
00900 }
00901
00902 <span class="comment">// DL_Key</span>
00903 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> & GetAbstractGroupParameters()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetGroupParameters();}
00904 <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> & AccessAbstractGroupParameters() {<span class="keywordflow">return</span> this->AccessGroupParameters();}
00905
00906 <span class="comment">// DL_PublicKey</span>
00907 <span class="keyword">const</span> DL_FixedBasePrecomputation<Element> & GetPublicPrecomputation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_ypc;}
00908 DL_FixedBasePrecomputation<Element> & AccessPublicPrecomputation() {<span class="keywordflow">return</span> m_ypc;}
00909
00910 <span class="comment">// non-inherited</span>
00911 <span class="keywordtype">bool</span> operator==(<span class="keyword">const</span> <a class="code" href="class_d_l___public_key_impl.html">DL_PublicKeyImpl<GP></a> &rhs)<span class="keyword"> const</span>
00912 <span class="keyword"> </span>{<span class="keywordflow">return</span> this->GetGroupParameters() == rhs.<a class="code" href="class_d_l___key_impl.html#_d_l___key_impla3">GetGroupParameters</a>() && this->GetPublicElement() == rhs.<a class="code" href="class_d_l___public_key.html#_d_l___public_keya2">GetPublicElement</a>();}
00913
00914 <span class="keyword">private</span>:
00915 <span class="keyword">typename</span> GP::BasePrecomputation m_ypc;
00916 };
00917 <span class="comment"></span>
00918 <span class="comment">//! interface for Elgamal-like signature algorithms</span>
00919 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00920"></a><a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">00920</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_ElgamalLikeSignatureAlgorithm
00921 {
00922 <span class="keyword">public</span>:
00923 <span class="keyword">virtual</span> <span class="keywordtype">void</span> Sign(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &privateKey, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &k, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &e, <a class="code" href="class_integer.html">Integer</a> &r, <a class="code" href="class_integer.html">Integer</a> &s) <span class="keyword">const</span> =0;
00924 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> Verify(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params, <span class="keyword">const</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> &publicKey, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &e, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &r, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &s) <span class="keyword">const</span> =0;
00925 <span class="keyword">virtual</span> <a class="code" href="class_integer.html">Integer</a> RecoverPresignature(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params, <span class="keyword">const</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> &publicKey, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &r, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &s)<span class="keyword"> const</span>
00926 <span class="keyword"> </span>{<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"DL_ElgamalLikeSignatureAlgorithm: this signature scheme does not support message recovery"</span>);}
00927 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> RLen(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params)<span class="keyword"> const</span>
00928 <span class="keyword"> </span>{<span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa14">GetSubgroupOrder</a>().<a class="code" href="class_integer.html#_integerz41_3">ByteCount</a>();}
00929 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> SLen(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params)<span class="keyword"> const</span>
00930 <span class="keyword"> </span>{<span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa14">GetSubgroupOrder</a>().<a class="code" href="class_integer.html#_integerz41_3">ByteCount</a>();}
00931 };
00932 <span class="comment"></span>
00933 <span class="comment">//! interface for DL key agreement algorithms</span>
00934 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00935"></a><a class="code" href="class_d_l___key_agreement_algorithm.html">00935</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_KeyAgreementAlgorithm
00936 {
00937 <span class="keyword">public</span>:
00938 <span class="keyword">typedef</span> T Element;
00939
00940 <span class="keyword">virtual</span> Element AgreeWithEphemeralPrivateKey(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> &params, <span class="keyword">const</span> DL_FixedBasePrecomputation<Element> &publicPrecomputation, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &privateExponent) <span class="keyword">const</span> =0;
00941 <span class="keyword">virtual</span> Element AgreeWithStaticPrivateKey(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> &params, <span class="keyword">const</span> Element &publicElement, <span class="keywordtype">bool</span> validateOtherPublicKey, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &privateExponent) <span class="keyword">const</span> =0;
00942 };
00943 <span class="comment"></span>
00944 <span class="comment">//! interface for key derivation algorithms used in DL cryptosystems</span>
00945 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l00946"></a><a class="code" href="class_d_l___key_derivation_algorithm.html">00946</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_KeyDerivationAlgorithm
00947 {
00948 <span class="keyword">public</span>:
00949 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> ParameterSupported(<span class="keyword">const</span> <span class="keywordtype">char</span> *name)<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00950 <span class="keyword">virtual</span> <span class="keywordtype">void</span> Derive(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &groupParams, byte *derivedKey, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> derivedLength, <span class="keyword">const</span> T &agreedElement, <span class="keyword">const</span> T &ephemeralPublicKey, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &derivationParams) <span class="keyword">const</span> =0;
00951 };
00952 <span class="comment"></span>
00953 <span class="comment">//! interface for symmetric encryption algorithms used in DL cryptosystems</span>
<a name="l00954"></a><a class="code" href="class_d_l___symmetric_encryption_algorithm.html">00954</a> <span class="comment"></span><span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_SymmetricEncryptionAlgorithm
00955 {
00956 <span class="keyword">public</span>:
00957 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> ParameterSupported(<span class="keyword">const</span> <span class="keywordtype">char</span> *name)<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00958 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetSymmetricKeyLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength) <span class="keyword">const</span> =0;
00959 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetSymmetricCiphertextLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength) <span class="keyword">const</span> =0;
00960 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetMaxSymmetricPlaintextLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ciphertextLength) <span class="keyword">const</span> =0;
00961 <span class="keyword">virtual</span> <span class="keywordtype">void</span> SymmetricEncrypt(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *key, <span class="keyword">const</span> byte *plaintext, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength, byte *ciphertext, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters) <span class="keyword">const</span> =0;
00962 <span class="keyword">virtual</span> <a class="code" href="struct_decoding_result.html">DecodingResult</a> SymmetricDecrypt(<span class="keyword">const</span> byte *key, <span class="keyword">const</span> byte *ciphertext, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ciphertextLength, byte *plaintext, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters) <span class="keyword">const</span> =0;
00963 };
00964 <span class="comment"></span>
00965 <span class="comment">//! _</span>
00966 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> KI>
<a name="l00967"></a><a class="code" href="class_d_l___base.html">00967</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_Base
00968 {
00969 <span class="keyword">protected</span>:
00970 <span class="keyword">typedef</span> KI KeyInterface;
00971 <span class="keyword">typedef</span> <span class="keyword">typename</span> KI::Element Element;
00972
00973 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> & GetAbstractGroupParameters()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetKeyInterface().GetAbstractGroupParameters();}
00974 <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> & AccessAbstractGroupParameters() {<span class="keywordflow">return</span> AccessKeyInterface().AccessAbstractGroupParameters();}
00975
00976 <span class="keyword">virtual</span> KeyInterface & AccessKeyInterface() =0;
00977 <span class="keyword">virtual</span> <span class="keyword">const</span> KeyInterface & GetKeyInterface() <span class="keyword">const</span> =0;
00978 };
00979 <span class="comment"></span>
00980 <span class="comment">//! _</span>
00981 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> INTERFACE, <span class="keyword">class</span> KEY_INTERFACE>
<a name="l00982"></a><a class="code" href="class_d_l___signature_scheme_base.html">00982</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_SignatureSchemeBase : <span class="keyword">public</span> INTERFACE, <span class="keyword">public</span> DL_Base<KEY_INTERFACE>
00983 {
00984 <span class="keyword">public</span>:
00985 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> SignatureLength()<span class="keyword"> const</span>
00986 <span class="keyword"> </span>{
00987 <span class="keywordflow">return</span> GetSignatureAlgorithm().RLen(this->GetAbstractGroupParameters())
00988 + GetSignatureAlgorithm().SLen(this->GetAbstractGroupParameters());
00989 }
00990 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxRecoverableLength()<span class="keyword"> const </span>
00991 <span class="keyword"> </span>{<span class="keywordflow">return</span> GetMessageEncodingInterface().MaxRecoverableLength(0, GetHashIdentifier().second, GetDigestSize());}
00992 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxRecoverableLengthFromSignatureLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> signatureLength)<span class="keyword"> const</span>
00993 <span class="keyword"> </span>{assert(<span class="keyword">false</span>); <span class="keywordflow">return</span> 0;} <span class="comment">// TODO</span>
00994
00995 <span class="keywordtype">bool</span> IsProbabilistic()<span class="keyword"> const </span>
00996 <span class="keyword"> </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00997 <span class="keywordtype">bool</span> AllowNonrecoverablePart()<span class="keyword"> const </span>
00998 <span class="keyword"> </span>{<span class="keywordflow">return</span> GetMessageEncodingInterface().AllowNonrecoverablePart();}
00999 <span class="keywordtype">bool</span> RecoverablePartFirst()<span class="keyword"> const </span>
01000 <span class="keyword"> </span>{<span class="keywordflow">return</span> GetMessageEncodingInterface().RecoverablePartFirst();}
01001
01002 <span class="keyword">protected</span>:
01003 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MessageRepresentativeLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> BitsToBytes(MessageRepresentativeBitLength());}
01004 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MessageRepresentativeBitLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetAbstractGroupParameters().GetSubgroupOrder().BitCount();}
01005
01006 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<CPP_TYPENAME KEY_INTERFACE::Element></a> & GetSignatureAlgorithm() <span class="keyword">const</span> =0;
01007 <span class="keyword">virtual</span> <span class="keyword">const</span> PK_SignatureMessageEncodingMethod & GetMessageEncodingInterface() <span class="keyword">const</span> =0;
01008 <span class="keyword">virtual</span> HashIdentifier GetHashIdentifier() <span class="keyword">const</span> =0;
01009 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetDigestSize() <span class="keyword">const</span> =0;
01010 };
01011 <span class="comment"></span>
01012 <span class="comment">//! _</span>
01013 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l01014"></a><a class="code" href="class_d_l___signer_base.html">01014</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_SignerBase : <span class="keyword">public</span> DL_SignatureSchemeBase<PK_Signer, DL_PrivateKey<T> >
01015 {
01016 <span class="keyword">public</span>:
01017 <span class="comment">// for validation testing</span>
01018 <span class="keywordtype">void</span> RawSign(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &k, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &e, <a class="code" href="class_integer.html">Integer</a> &r, <a class="code" href="class_integer.html">Integer</a> &s)<span class="keyword"> const</span>
01019 <span class="keyword"> </span>{
01020 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<T></a> &alg = this->GetSignatureAlgorithm();
01021 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01022 <span class="keyword">const</span> <a class="code" href="class_d_l___private_key.html">DL_PrivateKey<T></a> &key = this->GetKeyInterface();
01023
01024 r = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa21">ConvertElementToInteger</a>(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa9">ExponentiateBase</a>(k));
01025 alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma0">Sign</a>(params, key.<a class="code" href="class_d_l___private_key.html#_d_l___private_keya3">GetPrivateExponent</a>(), k, e, r, s);
01026 }
01027
01028 <span class="keywordtype">void</span> InputRecoverableMessage(<a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator, <span class="keyword">const</span> byte *recoverableMessage, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> recoverableMessageLength)<span class="keyword"> const</span>
01029 <span class="keyword"> </span>{
01030 PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
01031 ma.m_recoverableMessage.Assign(recoverableMessage, recoverableMessageLength);
01032 this->GetMessageEncodingInterface().ProcessRecoverableMessage(ma.AccessHash(),
01033 recoverableMessage, recoverableMessageLength,
01034 ma.m_presignature, ma.m_presignature.size(),
01035 ma.m_semisignature);
01036 }
01037
<a name="l01038"></a><a class="code" href="class_d_l___signer_base.html#_d_l___signer_basea2">01038</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> SignAndRestart(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator, byte *signature, <span class="keywordtype">bool</span> restart)<span class="keyword"> const</span>
01039 <span class="keyword"> </span>{
01040 this->GetMaterial().DoQuickSanityCheck();
01041
01042 PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
01043 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<T></a> &alg = this->GetSignatureAlgorithm();
01044 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01045 <span class="keyword">const</span> <a class="code" href="class_d_l___private_key.html">DL_PrivateKey<T></a> &key = this->GetKeyInterface();
01046
01047 <a class="code" href="class_sec_block.html">SecByteBlock</a> representative(this->MessageRepresentativeLength());
01048 this->GetMessageEncodingInterface().ComputeMessageRepresentative(
01049 rng,
01050 ma.m_recoverableMessage, ma.m_recoverableMessage.size(),
01051 ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,
01052 representative, this->MessageRepresentativeBitLength());
01053 ma.m_empty = <span class="keyword">true</span>;
01054 <a class="code" href="class_integer.html">Integer</a> e(representative, representative.<a class="code" href="class_sec_block.html#_sec_block_with_hinta15">size</a>());
01055
01056 <a class="code" href="class_integer.html">Integer</a> r;
01057 <span class="keywordflow">if</span> (this->MaxRecoverableLength() > 0)
01058 r.<a class="code" href="class_integer.html#_integerz39_7">Decode</a>(ma.m_semisignature, ma.m_semisignature.size());
01059 <span class="keywordflow">else</span>
01060 r.<a class="code" href="class_integer.html#_integerz39_7">Decode</a>(ma.m_presignature, ma.m_presignature.size());
01061 <a class="code" href="class_integer.html">Integer</a> s;
01062 alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma0">Sign</a>(params, key.<a class="code" href="class_d_l___private_key.html#_d_l___private_keya3">GetPrivateExponent</a>(), ma.m_k, e, r, s);
01063
01064 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> rLen = alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma3">RLen</a>(params);
01065 r.Encode(signature, rLen);
01066 s.<a class="code" href="class_integer.html#_integerz39_1">Encode</a>(signature+rLen, alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma4">SLen</a>(params));
01067
01068 <span class="keywordflow">if</span> (restart)
01069 RestartMessageAccumulator(rng, ma);
01070
01071 <span class="keywordflow">return</span> this->SignatureLength();
01072 }
01073
01074 <span class="keyword">protected</span>:
01075 <span class="keywordtype">void</span> RestartMessageAccumulator(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, PK_MessageAccumulatorBase &ma)<span class="keyword"> const</span>
01076 <span class="keyword"> </span>{
01077 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<T></a> &alg = this->GetSignatureAlgorithm();
01078 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01079 ma.m_k.Randomize(rng, 1, params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa14">GetSubgroupOrder</a>()-1);
01080 ma.m_presignature.New(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa18">GetEncodedElementSize</a>(<span class="keyword">false</span>));
01081 params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa21">ConvertElementToInteger</a>(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa9">ExponentiateBase</a>(ma.m_k)).<a class="code" href="class_integer.html#_integerz39_1">Encode</a>(ma.m_presignature, ma.m_presignature.size());
01082 }
01083 };
01084 <span class="comment"></span>
01085 <span class="comment">//! _</span>
01086 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l01087"></a><a class="code" href="class_d_l___verifier_base.html">01087</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_VerifierBase : <span class="keyword">public</span> DL_SignatureSchemeBase<PK_Verifier, DL_PublicKey<T> >
01088 {
01089 <span class="keyword">public</span>:
<a name="l01090"></a><a class="code" href="class_d_l___verifier_base.html#_d_l___verifier_basea0">01090</a> <span class="keywordtype">void</span> InputSignature(<a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator, <span class="keyword">const</span> byte *signature, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> signatureLength)<span class="keyword"> const</span>
01091 <span class="keyword"> </span>{
01092 PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
01093 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<T></a> &alg = this->GetSignatureAlgorithm();
01094 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01095
01096 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> rLen = alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma3">RLen</a>(params);
01097 ma.m_semisignature.Assign(signature, rLen);
01098 ma.m_s.Decode(signature+rLen, alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma4">SLen</a>(params));
01099
01100 this->GetMessageEncodingInterface().ProcessSemisignature(ma.AccessHash(), ma.m_semisignature, ma.m_semisignature.size());
01101 }
01102
<a name="l01103"></a><a class="code" href="class_d_l___verifier_base.html#_d_l___verifier_basea1">01103</a> <span class="keywordtype">bool</span> VerifyAndRestart(<a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator)<span class="keyword"> const</span>
01104 <span class="keyword"> </span>{
01105 this->GetMaterial().DoQuickSanityCheck();
01106
01107 PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
01108 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<T></a> &alg = this->GetSignatureAlgorithm();
01109 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01110 <span class="keyword">const</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> &key = this->GetKeyInterface();
01111
01112 <a class="code" href="class_sec_block.html">SecByteBlock</a> representative(this->MessageRepresentativeLength());
01113 this->GetMessageEncodingInterface().ComputeMessageRepresentative(NullRNG(), ma.m_recoverableMessage, ma.m_recoverableMessage.size(),
01114 ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,
01115 representative, this->MessageRepresentativeBitLength());
01116 ma.m_empty = <span class="keyword">true</span>;
01117 <a class="code" href="class_integer.html">Integer</a> e(representative, representative.<a class="code" href="class_sec_block.html#_sec_block_with_hinta15">size</a>());
01118
01119 <a class="code" href="class_integer.html">Integer</a> r(ma.m_semisignature, ma.m_semisignature.size());
01120 <span class="keywordflow">return</span> alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma1">Verify</a>(params, key, e, r, ma.m_s);
01121 }
01122
<a name="l01123"></a><a class="code" href="class_d_l___verifier_base.html#_d_l___verifier_basea2">01123</a> <a class="code" href="struct_decoding_result.html">DecodingResult</a> RecoverAndRestart(byte *recoveredMessage, <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> &messageAccumulator)<span class="keyword"> const</span>
01124 <span class="keyword"> </span>{
01125 this->GetMaterial().DoQuickSanityCheck();
01126
01127 PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
01128 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<T></a> &alg = this->GetSignatureAlgorithm();
01129 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01130 <span class="keyword">const</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> &key = this->GetKeyInterface();
01131
01132 <a class="code" href="class_sec_block.html">SecByteBlock</a> representative(this->MessageRepresentativeLength());
01133 this->GetMessageEncodingInterface().ComputeMessageRepresentative(
01134 NullRNG(),
01135 ma.m_recoverableMessage, ma.m_recoverableMessage.size(),
01136 ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,
01137 representative, this->MessageRepresentativeBitLength());
01138 ma.m_empty = <span class="keyword">true</span>;
01139 <a class="code" href="class_integer.html">Integer</a> e(representative, representative.<a class="code" href="class_sec_block.html#_sec_block_with_hinta15">size</a>());
01140
01141 ma.m_presignature.New(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa18">GetEncodedElementSize</a>(<span class="keyword">false</span>));
01142 <a class="code" href="class_integer.html">Integer</a> r(ma.m_semisignature, ma.m_semisignature.size());
01143 alg.<a class="code" href="class_d_l___elgamal_like_signature_algorithm.html#_d_l___elgamal_like_signature_algorithma2">RecoverPresignature</a>(params, key, r, ma.m_s).<a class="code" href="class_integer.html#_integerz39_1">Encode</a>(ma.m_presignature, ma.m_presignature.size());
01144
01145 <span class="keywordflow">return</span> this->GetMessageEncodingInterface().RecoverMessageFromSemisignature(
01146 ma.AccessHash(), this->GetHashIdentifier(),
01147 ma.m_presignature, ma.m_presignature.size(),
01148 ma.m_semisignature, ma.m_semisignature.size(),
01149 recoveredMessage);
01150 }
01151 };
01152 <span class="comment"></span>
01153 <span class="comment">//! _</span>
01154 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> PK, <span class="keyword">class</span> KI>
<a name="l01155"></a><a class="code" href="class_d_l___crypto_system_base.html">01155</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_CryptoSystemBase : <span class="keyword">public</span> PK, <span class="keyword">public</span> DL_Base<KI>
01156 {
01157 <span class="keyword">public</span>:
01158 <span class="keyword">typedef</span> <span class="keyword">typename</span> <a class="code" href="class_d_l___base.html">DL_Base<KI></a><a class="code" href="class_d_l___base.html">::Element</a> <a class="code" href="class_d_l___base.html">Element</a>;
01159
01160 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MaxPlaintextLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ciphertextLength)<span class="keyword"> const</span>
01161 <span class="keyword"> </span>{
01162 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> minLen = this->GetAbstractGroupParameters().GetEncodedElementSize(<span class="keyword">true</span>);
01163 <span class="keywordflow">return</span> ciphertextLength < minLen ? 0 : GetSymmetricEncryptionAlgorithm().GetMaxSymmetricPlaintextLength(ciphertextLength - minLen);
01164 }
01165
01166 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> CiphertextLength(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength)<span class="keyword"> const</span>
01167 <span class="keyword"> </span>{
01168 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> len = GetSymmetricEncryptionAlgorithm().GetSymmetricCiphertextLength(plaintextLength);
01169 <span class="keywordflow">return</span> len == 0 ? 0 : this->GetAbstractGroupParameters().GetEncodedElementSize(<span class="keyword">true</span>) + len;
01170 }
01171
01172 <span class="keywordtype">bool</span> ParameterSupported(<span class="keyword">const</span> <span class="keywordtype">char</span> *name)<span class="keyword"> const</span>
01173 <span class="keyword"> </span>{<span class="keywordflow">return</span> GetKeyDerivationAlgorithm().ParameterSupported(name) || GetSymmetricEncryptionAlgorithm().ParameterSupported(name);}
01174
01175 <span class="keyword">protected</span>:
01176 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_d_l___key_agreement_algorithm.html">DL_KeyAgreementAlgorithm<Element></a> & GetKeyAgreementAlgorithm() <span class="keyword">const</span> =0;
01177 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_d_l___key_derivation_algorithm.html">DL_KeyDerivationAlgorithm<Element></a> & GetKeyDerivationAlgorithm() <span class="keyword">const</span> =0;
01178 <span class="keyword">virtual</span> <span class="keyword">const</span> DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm() <span class="keyword">const</span> =0;
01179 };
01180 <span class="comment"></span>
01181 <span class="comment">//! _</span>
01182 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l01183"></a><a class="code" href="class_d_l___decryptor_base.html">01183</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_DecryptorBase : <span class="keyword">public</span> DL_CryptoSystemBase<PK_Decryptor, DL_PrivateKey<T> >
01184 {
01185 <span class="keyword">public</span>:
01186 <span class="keyword">typedef</span> T Element;
01187
<a name="l01188"></a><a class="code" href="class_d_l___decryptor_base.html#_d_l___decryptor_basea0">01188</a> <a class="code" href="struct_decoding_result.html">DecodingResult</a> Decrypt(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *ciphertext, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ciphertextLength, byte *plaintext, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters = g_nullNameValuePairs)<span class="keyword"> const</span>
01189 <span class="keyword"> </span>{
01190 <span class="keywordflow">try</span>
01191 {
01192 <span class="keyword">const</span> <a class="code" href="class_d_l___key_agreement_algorithm.html">DL_KeyAgreementAlgorithm<T></a> &agreeAlg = this->GetKeyAgreementAlgorithm();
01193 <span class="keyword">const</span> <a class="code" href="class_d_l___key_derivation_algorithm.html">DL_KeyDerivationAlgorithm<T></a> &derivAlg = this->GetKeyDerivationAlgorithm();
01194 <span class="keyword">const</span> DL_SymmetricEncryptionAlgorithm &encAlg = this->GetSymmetricEncryptionAlgorithm();
01195 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01196 <span class="keyword">const</span> <a class="code" href="class_d_l___private_key.html">DL_PrivateKey<T></a> &key = this->GetKeyInterface();
01197
01198 Element q = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa20">DecodeElement</a>(ciphertext, <span class="keyword">true</span>);
01199 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> elementSize = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa18">GetEncodedElementSize</a>(<span class="keyword">true</span>);
01200 ciphertext += elementSize;
01201 ciphertextLength -= elementSize;
01202
01203 Element z = agreeAlg.<a class="code" href="class_d_l___key_agreement_algorithm.html#_d_l___key_agreement_algorithma1">AgreeWithStaticPrivateKey</a>(params, q, <span class="keyword">true</span>, key.<a class="code" href="class_d_l___private_key.html#_d_l___private_keya3">GetPrivateExponent</a>());
01204
01205 <a class="code" href="class_sec_block.html">SecByteBlock</a> derivedKey(encAlg.<a class="code" href="class_d_l___symmetric_encryption_algorithm.html#_d_l___symmetric_encryption_algorithma1">GetSymmetricKeyLength</a>(encAlg.<a class="code" href="class_d_l___symmetric_encryption_algorithm.html#_d_l___symmetric_encryption_algorithma3">GetMaxSymmetricPlaintextLength</a>(ciphertextLength)));
01206 derivAlg.<a class="code" href="class_d_l___key_derivation_algorithm.html#_d_l___key_derivation_algorithma1">Derive</a>(params, derivedKey, derivedKey.<a class="code" href="class_sec_block.html#_sec_block_with_hinta15">size</a>(), z, q, parameters);
01207
01208 <span class="keywordflow">return</span> encAlg.<a class="code" href="class_d_l___symmetric_encryption_algorithm.html#_d_l___symmetric_encryption_algorithma5">SymmetricDecrypt</a>(derivedKey, ciphertext, ciphertextLength, plaintext, parameters);
01209 }
01210 <span class="keywordflow">catch</span> (<a class="code" href="class_d_l___bad_element.html">DL_BadElement</a> &)
01211 {
01212 <span class="keywordflow">return</span> <a class="code" href="struct_decoding_result.html">DecodingResult</a>();
01213 }
01214 }
01215 };
01216 <span class="comment"></span>
01217 <span class="comment">//! _</span>
01218 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l01219"></a><a class="code" href="class_d_l___encryptor_base.html">01219</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_EncryptorBase : <span class="keyword">public</span> DL_CryptoSystemBase<PK_Encryptor, DL_PublicKey<T> >
01220 {
01221 <span class="keyword">public</span>:
01222 <span class="keyword">typedef</span> T Element;
01223
<a name="l01224"></a><a class="code" href="class_d_l___encryptor_base.html#_d_l___encryptor_basea0">01224</a> <span class="keywordtype">void</span> Encrypt(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *plaintext, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> plaintextLength, byte *ciphertext, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &parameters = g_nullNameValuePairs)<span class="keyword"> const</span>
01225 <span class="keyword"> </span>{
01226 <span class="keyword">const</span> <a class="code" href="class_d_l___key_agreement_algorithm.html">DL_KeyAgreementAlgorithm<T></a> &agreeAlg = this->GetKeyAgreementAlgorithm();
01227 <span class="keyword">const</span> <a class="code" href="class_d_l___key_derivation_algorithm.html">DL_KeyDerivationAlgorithm<T></a> &derivAlg = this->GetKeyDerivationAlgorithm();
01228 <span class="keyword">const</span> DL_SymmetricEncryptionAlgorithm &encAlg = this->GetSymmetricEncryptionAlgorithm();
01229 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = this->GetAbstractGroupParameters();
01230 <span class="keyword">const</span> <a class="code" href="class_d_l___public_key.html">DL_PublicKey<T></a> &key = this->GetKeyInterface();
01231
01232 <a class="code" href="class_integer.html">Integer</a> x(rng, Integer::One(), params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa15">GetMaxExponent</a>());
01233 Element q = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa9">ExponentiateBase</a>(x);
01234 params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa19">EncodeElement</a>(<span class="keyword">true</span>, q, ciphertext);
01235 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> elementSize = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa18">GetEncodedElementSize</a>(<span class="keyword">true</span>);
01236 ciphertext += elementSize;
01237
01238 Element z = agreeAlg.<a class="code" href="class_d_l___key_agreement_algorithm.html#_d_l___key_agreement_algorithma0">AgreeWithEphemeralPrivateKey</a>(params, key.<a class="code" href="class_d_l___public_key.html#_d_l___public_keya6">GetPublicPrecomputation</a>(), x);
01239
01240 <a class="code" href="class_sec_block.html">SecByteBlock</a> derivedKey(encAlg.<a class="code" href="class_d_l___symmetric_encryption_algorithm.html#_d_l___symmetric_encryption_algorithma1">GetSymmetricKeyLength</a>(plaintextLength));
01241 derivAlg.<a class="code" href="class_d_l___key_derivation_algorithm.html#_d_l___key_derivation_algorithma1">Derive</a>(params, derivedKey, derivedKey.<a class="code" href="class_sec_block.html#_sec_block_with_hinta15">size</a>(), z, q, parameters);
01242
01243 encAlg.<a class="code" href="class_d_l___symmetric_encryption_algorithm.html#_d_l___symmetric_encryption_algorithma4">SymmetricEncrypt</a>(rng, derivedKey, plaintext, plaintextLength, ciphertext, parameters);
01244 }
01245 };
01246 <span class="comment"></span>
01247 <span class="comment">//! _</span>
01248 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2>
<a name="l01249"></a><a class="code" href="struct_d_l___scheme_options_base.html">01249</a> <span class="keyword">struct </span><a class="code" href="struct_d_l___scheme_options_base.html">DL_SchemeOptionsBase</a>
01250 {
01251 <span class="keyword">typedef</span> T1 AlgorithmInfo;
01252 <span class="keyword">typedef</span> T2 GroupParameters;
01253 <span class="keyword">typedef</span> <span class="keyword">typename</span> GroupParameters::Element Element;
01254 };
01255 <span class="comment"></span>
01256 <span class="comment">//! _</span>
01257 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2>
<a name="l01258"></a><a class="code" href="struct_d_l___keyed_scheme_options.html">01258</a> <span class="keyword">struct </span><a class="code" href="struct_d_l___keyed_scheme_options.html">DL_KeyedSchemeOptions</a> : <span class="keyword">public</span> <a class="code" href="struct_d_l___scheme_options_base.html">DL_SchemeOptionsBase</a><T1, typename T2::PublicKey::GroupParameters>
01259 {
01260 <span class="keyword">typedef</span> T2 Keys;
01261 <span class="keyword">typedef</span> <span class="keyword">typename</span> Keys::PrivateKey PrivateKey;
01262 <span class="keyword">typedef</span> <span class="keyword">typename</span> Keys::PublicKey PublicKey;
01263 };
01264 <span class="comment"></span>
01265 <span class="comment">//! _</span>
01266 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5>
<a name="l01267"></a><a class="code" href="struct_d_l___signature_scheme_options.html">01267</a> <span class="keyword">struct </span><a class="code" href="struct_d_l___signature_scheme_options.html">DL_SignatureSchemeOptions</a> : <span class="keyword">public</span> <a class="code" href="struct_d_l___keyed_scheme_options.html">DL_KeyedSchemeOptions</a><T1, T2>
01268 {
01269 <span class="keyword">typedef</span> T3 SignatureAlgorithm;
01270 <span class="keyword">typedef</span> T4 MessageEncodingMethod;
01271 <span class="keyword">typedef</span> T5 HashFunction;
01272 };
01273 <span class="comment"></span>
01274 <span class="comment">//! _</span>
01275 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5>
<a name="l01276"></a><a class="code" href="struct_d_l___crypto_scheme_options.html">01276</a> <span class="keyword">struct </span><a class="code" href="struct_d_l___crypto_scheme_options.html">DL_CryptoSchemeOptions</a> : <span class="keyword">public</span> <a class="code" href="struct_d_l___keyed_scheme_options.html">DL_KeyedSchemeOptions</a><T1, T2>
01277 {
01278 <span class="keyword">typedef</span> T3 KeyAgreementAlgorithm;
01279 <span class="keyword">typedef</span> T4 KeyDerivationAlgorithm;
01280 <span class="keyword">typedef</span> T5 SymmetricEncryptionAlgorithm;
01281 };
01282 <span class="comment"></span>
01283 <span class="comment">//! _</span>
01284 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS, <span class="keyword">class</span> KEY>
<a name="l01285"></a><a class="code" href="class_d_l___object_impl_base.html">01285</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_ObjectImplBase : <span class="keyword">public</span> <a class="code" href="class_algorithm_impl.html">AlgorithmImpl</a><BASE, typename SCHEME_OPTIONS::AlgorithmInfo>
01286 {
01287 <span class="keyword">public</span>:
01288 <span class="keyword">typedef</span> SCHEME_OPTIONS SchemeOptions;
01289 <span class="keyword">typedef</span> <span class="keyword">typename</span> KEY::Element Element;
01290
01291 <a class="code" href="class_private_key.html">PrivateKey</a> & AccessPrivateKey() {<span class="keywordflow">return</span> m_key;}
01292 <a class="code" href="class_public_key.html">PublicKey</a> & AccessPublicKey() {<span class="keywordflow">return</span> m_key;}
01293
01294 <span class="comment">// KeyAccessor</span>
01295 <span class="keyword">const</span> KEY & GetKey()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_key;}
01296 KEY & AccessKey() {<span class="keywordflow">return</span> m_key;}
01297
01298 <span class="keyword">protected</span>:
01299 <span class="keyword">typename</span> BASE::KeyInterface & AccessKeyInterface() {<span class="keywordflow">return</span> m_key;}
01300 <span class="keyword">const</span> <span class="keyword">typename</span> BASE::KeyInterface & GetKeyInterface()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_key;}
01301
01302 <span class="comment">// for signature scheme</span>
01303 HashIdentifier GetHashIdentifier()<span class="keyword"> const</span>
01304 <span class="keyword"> </span>{
01305 <span class="keyword">typedef</span> <span class="keyword">typename</span> SchemeOptions::MessageEncodingMethod::HashIdentifierLookup HashLookup;
01306 <span class="keywordflow">return</span> HashLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction>::Lookup();
01307 }
01308 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetDigestSize()<span class="keyword"> const</span>
01309 <span class="keyword"> </span>{
01310 <span class="keyword">typedef</span> CPP_TYPENAME SchemeOptions::HashFunction H;
01311 <span class="keywordflow">return</span> H::DIGESTSIZE;
01312 }
01313
01314 <span class="keyword">private</span>:
01315 KEY m_key;
01316 };
01317 <span class="comment"></span>
01318 <span class="comment">//! _</span>
01319 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS, <span class="keyword">class</span> KEY>
<a name="l01320"></a><a class="code" href="class_d_l___object_impl.html">01320</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_ObjectImpl : <span class="keyword">public</span> DL_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>
01321 {
01322 <span class="keyword">public</span>:
01323 <span class="keyword">typedef</span> <span class="keyword">typename</span> KEY::Element Element;
01324
01325 <span class="keyword">protected</span>:
01326 <span class="keyword">const</span> <a class="code" href="class_d_l___elgamal_like_signature_algorithm.html">DL_ElgamalLikeSignatureAlgorithm<Element></a> & GetSignatureAlgorithm()<span class="keyword"> const</span>
01327 <span class="keyword"> </span>{<span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<CPP_TYPENAME SCHEME_OPTIONS::SignatureAlgorithm></a>().Ref();}
01328 <span class="keyword">const</span> <a class="code" href="class_d_l___key_agreement_algorithm.html">DL_KeyAgreementAlgorithm<Element></a> & GetKeyAgreementAlgorithm()<span class="keyword"> const</span>
01329 <span class="keyword"> </span>{<span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<CPP_TYPENAME SCHEME_OPTIONS::KeyAgreementAlgorithm></a>().Ref();}
01330 <span class="keyword">const</span> <a class="code" href="class_d_l___key_derivation_algorithm.html">DL_KeyDerivationAlgorithm<Element></a> & GetKeyDerivationAlgorithm()<span class="keyword"> const</span>
01331 <span class="keyword"> </span>{<span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<CPP_TYPENAME SCHEME_OPTIONS::KeyDerivationAlgorithm></a>().Ref();}
01332 <span class="keyword">const</span> DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm()<span class="keyword"> const</span>
01333 <span class="keyword"> </span>{<span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<CPP_TYPENAME SCHEME_OPTIONS::SymmetricEncryptionAlgorithm></a>().Ref();}
01334 HashIdentifier GetHashIdentifier()<span class="keyword"> const</span>
01335 <span class="keyword"> </span>{<span class="keywordflow">return</span> HashIdentifier();}
01336 <span class="keyword">const</span> PK_SignatureMessageEncodingMethod & GetMessageEncodingInterface()<span class="keyword"> const </span>
01337 <span class="keyword"> </span>{<span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<CPP_TYPENAME SCHEME_OPTIONS::MessageEncodingMethod></a>().Ref();}
01338 };
01339 <span class="comment"></span>
01340 <span class="comment">//! _</span>
01341 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l01342"></a><a class="code" href="class_d_l___public_object_impl.html">01342</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_PublicObjectImpl : <span class="keyword">public</span> DL_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>, <span class="keyword">public</span> PublicKeyCopier<SCHEME_OPTIONS>
01343 {
01344 <span class="keyword">public</span>:
01345 <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> SCHEME_OPTIONS::PublicKey &key)<span class="keyword"> const</span>
01346 <span class="keyword"> </span>{key = this->GetKey();}
01347 };
01348 <span class="comment"></span>
01349 <span class="comment">//! _</span>
01350 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l01351"></a><a class="code" href="class_d_l___private_object_impl.html">01351</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_PrivateObjectImpl : <span class="keyword">public</span> DL_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>, <span class="keyword">public</span> PrivateKeyCopier<SCHEME_OPTIONS>
01352 {
01353 <span class="keyword">public</span>:
01354 <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> SCHEME_OPTIONS::PublicKey &key)<span class="keyword"> const</span>
01355 <span class="keyword"> </span>{this->GetKey().MakePublicKey(key);}
01356 <span class="keywordtype">void</span> CopyKeyInto(<span class="keyword">typename</span> SCHEME_OPTIONS::PrivateKey &key)<span class="keyword"> const</span>
01357 <span class="keyword"> </span>{key = this->GetKey();}
01358 };
01359 <span class="comment"></span>
01360 <span class="comment">//! _</span>
01361 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l01362"></a><a class="code" href="class_d_l___signer_impl.html">01362</a> <span class="keyword">class </span><a class="code" href="class_d_l___signer_impl.html">DL_SignerImpl</a> : <span class="keyword">public</span> DL_PrivateObjectImpl<DL_SignerBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
01363 {
01364 <span class="keyword">public</span>:
<a name="l01365"></a><a class="code" href="class_d_l___signer_impl.html#_d_l___signer_impla0">01365</a> <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> * NewSignatureAccumulator(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng)<span class="keyword"> const</span>
01366 <span class="keyword"> </span>{
01367 std::auto_ptr<PK_MessageAccumulatorBase> p(<span class="keyword">new</span> PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>);
01368 this->RestartMessageAccumulator(rng, *p);
01369 <span class="keywordflow">return</span> p.release();
01370 }
01371 };
01372 <span class="comment"></span>
01373 <span class="comment">//! _</span>
01374 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l01375"></a><a class="code" href="class_d_l___verifier_impl.html">01375</a> <span class="keyword">class </span><a class="code" href="class_d_l___verifier_impl.html">DL_VerifierImpl</a> : <span class="keyword">public</span> DL_PublicObjectImpl<DL_VerifierBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
01376 {
01377 <span class="keyword">public</span>:
<a name="l01378"></a><a class="code" href="class_d_l___verifier_impl.html#_d_l___verifier_impla0">01378</a> <a class="code" href="class_p_k___message_accumulator.html">PK_MessageAccumulator</a> * NewVerificationAccumulator()<span class="keyword"> const</span>
01379 <span class="keyword"> </span>{
01380 <span class="keywordflow">return</span> <span class="keyword">new</span> PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>;
01381 }
01382 };
01383 <span class="comment"></span>
01384 <span class="comment">//! _</span>
01385 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l01386"></a><a class="code" href="class_d_l___encryptor_impl.html">01386</a> <span class="keyword">class </span><a class="code" href="class_d_l___encryptor_impl.html">DL_EncryptorImpl</a> : <span class="keyword">public</span> DL_PublicObjectImpl<DL_EncryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
01387 {
01388 };
01389 <span class="comment"></span>
01390 <span class="comment">//! _</span>
01391 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> SCHEME_OPTIONS>
<a name="l01392"></a><a class="code" href="class_d_l___decryptor_impl.html">01392</a> <span class="keyword">class </span><a class="code" href="class_d_l___decryptor_impl.html">DL_DecryptorImpl</a> : <span class="keyword">public</span> DL_PrivateObjectImpl<DL_DecryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
01393 {
01394 };
01395
01396 <span class="comment">// ********************************************************</span>
01397 <span class="comment"></span>
01398 <span class="comment">//! _</span>
01399 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l01400"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html">01400</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE DL_SimpleKeyAgreementDomainBase : <span class="keyword">public</span> <a class="code" href="class_simple_key_agreement_domain.html">SimpleKeyAgreementDomain</a>
01401 {
01402 <span class="keyword">public</span>:
01403 <span class="keyword">typedef</span> T Element;
01404
01405 <a class="code" href="class_crypto_parameters.html">CryptoParameters</a> & AccessCryptoParameters() {<span class="keywordflow">return</span> AccessAbstractGroupParameters();}
<a name="l01406"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html#_d_l___simple_key_agreement_domain_basea1">01406</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> AgreedValueLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetAbstractGroupParameters().GetEncodedElementSize(<span class="keyword">false</span>);}
<a name="l01407"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html#_d_l___simple_key_agreement_domain_basea2">01407</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> PrivateKeyLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetAbstractGroupParameters().GetSubgroupOrder().ByteCount();}
<a name="l01408"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html#_d_l___simple_key_agreement_domain_basea3">01408</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> PublicKeyLength()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetAbstractGroupParameters().GetEncodedElementSize(<span class="keyword">true</span>);}
01409
<a name="l01410"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html#_d_l___simple_key_agreement_domain_basea4">01410</a> <span class="keywordtype">void</span> GeneratePrivateKey(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, byte *privateKey)<span class="keyword"> const</span>
01411 <span class="keyword"> </span>{
01412 <a class="code" href="class_integer.html">Integer</a> x(rng, Integer::One(), GetAbstractGroupParameters().GetMaxExponent());
01413 x.Encode(privateKey, PrivateKeyLength());
01414 }
01415
<a name="l01416"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html#_d_l___simple_key_agreement_domain_basea5">01416</a> <span class="keywordtype">void</span> GeneratePublicKey(<a class="code" href="class_random_number_generator.html">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> byte *privateKey, byte *publicKey)<span class="keyword"> const</span>
01417 <span class="keyword"> </span>{
01418 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = GetAbstractGroupParameters();
01419 <a class="code" href="class_integer.html">Integer</a> x(privateKey, PrivateKeyLength());
01420 Element y = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa9">ExponentiateBase</a>(x);
01421 params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa19">EncodeElement</a>(<span class="keyword">true</span>, y, publicKey);
01422 }
01423
<a name="l01424"></a><a class="code" href="class_d_l___simple_key_agreement_domain_base.html#_d_l___simple_key_agreement_domain_basea6">01424</a> <span class="keywordtype">bool</span> Agree(byte *agreedValue, <span class="keyword">const</span> byte *privateKey, <span class="keyword">const</span> byte *otherPublicKey, <span class="keywordtype">bool</span> validateOtherPublicKey=<span class="keyword">true</span>)<span class="keyword"> const</span>
01425 <span class="keyword"> </span>{
01426 <span class="keywordflow">try</span>
01427 {
01428 <span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<T></a> &params = GetAbstractGroupParameters();
01429 <a class="code" href="class_integer.html">Integer</a> x(privateKey, PrivateKeyLength());
01430 Element w = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa20">DecodeElement</a>(otherPublicKey, validateOtherPublicKey);
01431
01432 Element z = GetKeyAgreementAlgorithm().AgreeWithStaticPrivateKey(
01433 GetAbstractGroupParameters(), w, validateOtherPublicKey, x);
01434 params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa19">EncodeElement</a>(<span class="keyword">false</span>, z, agreedValue);
01435 }
01436 <span class="keywordflow">catch</span> (<a class="code" href="class_d_l___bad_element.html">DL_BadElement</a> &)
01437 {
01438 <span class="keywordflow">return</span> <span class="keyword">false</span>;
01439 }
01440 <span class="keywordflow">return</span> <span class="keyword">true</span>;
01441 }
01442
01443 <span class="keyword">const</span> Element &GetGenerator()<span class="keyword"> const </span>{<span class="keywordflow">return</span> GetAbstractGroupParameters().GetSubgroupGenerator();}
01444
01445 <span class="keyword">protected</span>:
01446 <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="class_d_l___key_agreement_algorithm.html">DL_KeyAgreementAlgorithm<Element></a> & GetKeyAgreementAlgorithm() const =0;
01447 virtual DL_GroupParameters<Element> & AccessAbstractGroupParameters() =0;
01448 const DL_GroupParameters<Element> & GetAbstractGroupParameters()<span class="keyword"> const </span>{<span class="keywordflow">return</span> const_cast<DL_SimpleKeyAgreementDomainBase<Element> *>(<span class="keyword">this</span>)->AccessAbstractGroupParameters();}
01449 };
01450
01451 <span class="keyword">enum</span> CofactorMultiplicationOption {NO_COFACTOR_MULTIPLICTION, COMPATIBLE_COFACTOR_MULTIPLICTION, INCOMPATIBLE_COFACTOR_MULTIPLICTION};
01452 <span class="keyword">typedef</span> EnumToType<CofactorMultiplicationOption, NO_COFACTOR_MULTIPLICTION> NoCofactorMultiplication;
01453 <span class="keyword">typedef</span> EnumToType<CofactorMultiplicationOption, COMPATIBLE_COFACTOR_MULTIPLICTION> CompatibleCofactorMultiplication;
01454 <span class="keyword">typedef</span> EnumToType<CofactorMultiplicationOption, INCOMPATIBLE_COFACTOR_MULTIPLICTION> IncompatibleCofactorMultiplication;
01455 <span class="comment"></span>
01456 <span class="comment">//! DH key agreement algorithm</span>
01457 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> ELEMENT, <span class="keyword">class</span> COFACTOR_OPTION>
<a name="l01458"></a><a class="code" href="class_d_l___key_agreement_algorithm___d_h.html">01458</a> <span class="keyword">class </span><a class="code" href="class_d_l___key_agreement_algorithm___d_h.html">DL_KeyAgreementAlgorithm_DH</a> : <span class="keyword">public</span> DL_KeyAgreementAlgorithm<ELEMENT>
01459 {
01460 <span class="keyword">public</span>:
01461 <span class="keyword">typedef</span> ELEMENT Element;
01462
01463 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> *StaticAlgorithmName()
01464 {<span class="keywordflow">return</span> COFACTOR_OPTION::ToEnum() == INCOMPATIBLE_COFACTOR_MULTIPLICTION ? <span class="stringliteral">"DHC"</span> : <span class="stringliteral">"DH"</span>;}
01465
01466 Element AgreeWithEphemeralPrivateKey(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> &params, <span class="keyword">const</span> DL_FixedBasePrecomputation<Element> &publicPrecomputation, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &privateExponent)<span class="keyword"> const</span>
01467 <span class="keyword"> </span>{
01468 <span class="keywordflow">return</span> publicPrecomputation.Exponentiate(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa11">GetGroupPrecomputation</a>(),
01469 COFACTOR_OPTION::ToEnum() == INCOMPATIBLE_COFACTOR_MULTIPLICTION ? privateExponent*params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa17">GetCofactor</a>() : privateExponent);
01470 }
01471
01472 Element AgreeWithStaticPrivateKey(<span class="keyword">const</span> <a class="code" href="class_d_l___group_parameters.html">DL_GroupParameters<Element></a> &params, <span class="keyword">const</span> Element &publicElement, <span class="keywordtype">bool</span> validateOtherPublicKey, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &privateExponent)<span class="keyword"> const</span>
01473 <span class="keyword"> </span>{
01474 <span class="keywordflow">if</span> (COFACTOR_OPTION::ToEnum() == COMPATIBLE_COFACTOR_MULTIPLICTION)
01475 {
01476 <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &k = params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa17">GetCofactor</a>();
01477 <span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa10">ExponentiateElement</a>(publicElement,
01478 <a class="code" href="class_modular_arithmetic.html">ModularArithmetic</a>(params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa14">GetSubgroupOrder</a>()).Divide(privateExponent, k)*k);
01479 }
01480 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (COFACTOR_OPTION::ToEnum() == INCOMPATIBLE_COFACTOR_MULTIPLICTION)
01481 <span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa10">ExponentiateElement</a>(publicElement, privateExponent*params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa17">GetCofactor</a>());
01482 <span class="keywordflow">else</span>
01483 {
01484 assert(COFACTOR_OPTION::ToEnum() == NO_COFACTOR_MULTIPLICTION);
01485
01486 <span class="keywordflow">if</span> (!validateOtherPublicKey)
01487 <span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa10">ExponentiateElement</a>(publicElement, privateExponent);
01488
01489 <span class="keywordflow">if</span> (params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa24">FastSubgroupCheckAvailable</a>())
01490 {
01491 <span class="keywordflow">if</span> (!params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa23">ValidateElement</a>(2, publicElement, NULL))
01492 <span class="keywordflow">throw</span> <a class="code" href="class_d_l___bad_element.html">DL_BadElement</a>();
01493 <span class="keywordflow">return</span> params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa10">ExponentiateElement</a>(publicElement, privateExponent);
01494 }
01495 <span class="keywordflow">else</span>
01496 {
01497 <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> e[2] = {params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa14">GetSubgroupOrder</a>(), privateExponent};
01498 Element r[2];
01499 params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa26">SimultaneousExponentiate</a>(r, publicElement, e, 2);
01500 <span class="keywordflow">if</span> (!params.<a class="code" href="class_d_l___group_parameters.html#_d_l___group_parametersa25">IsIdentity</a>(r[0]))
01501 <span class="keywordflow">throw</span> <a class="code" href="class_d_l___bad_element.html">DL_BadElement</a>();
01502 <span class="keywordflow">return</span> r[1];
01503 }
01504 }
01505 }
01506 };
01507
01508 <span class="comment">// ********************************************************</span>
01509 <span class="comment"></span>
01510 <span class="comment">//! A template implementing constructors for public key algorithm classes</span>
01511 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE>
<a name="l01512"></a><a class="code" href="class_p_k___final_template.html">01512</a> <span class="keyword">class </span>CRYPTOPP_NO_VTABLE PK_FinalTemplate : <span class="keyword">public</span> BASE
01513 {
01514 <span class="keyword">public</span>:
01515 PK_FinalTemplate() {}
01516
01517 PK_FinalTemplate(<span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &v1)
01518 {this->AccessKey().Initialize(v1);}
01519
01520 PK_FinalTemplate(<span class="keyword">const</span> <span class="keyword">typename</span> BASE::KeyClass &key) {this->AccessKey().operator=(key);}
01521
01522 <span class="keyword">template</span> <<span class="keyword">class</span> T>
01523 PK_FinalTemplate(<span class="keyword">const</span> <a class="code" href="class_public_key_copier.html">PublicKeyCopier<T></a> &key)
01524 {key.<a class="code" href="class_public_key_copier.html#_public_key_copiera0">CopyKeyInto</a>(this->AccessKey());}
01525
01526 <span class="keyword">template</span> <<span class="keyword">class</span> T>
01527 PK_FinalTemplate(<span class="keyword">const</span> <a class="code" href="class_private_key_copier.html">PrivateKeyCopier<T></a> &key)
01528 {key.<a class="code" href="class_private_key_copier.html#_private_key_copiera0">CopyKeyInto</a>(this->AccessKey());}
01529
01530 PK_FinalTemplate(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &bt) {this->AccessKey().BERDecode(bt);}
01531
01532 <span class="preprocessor">#if (defined(_MSC_VER) && _MSC_VER < 1300)</span>
01533 <span class="preprocessor"></span>
01534 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2>
01535 PK_FinalTemplate(T1 &v1, T2 &v2)
01536 {this->AccessKey().Initialize(v1, v2);}
01537
01538 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3>
01539 PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3)
01540 {this->AccessKey().Initialize(v1, v2, v3);}
01541
01542 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4>
01543 PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4)
01544 {this->AccessKey().Initialize(v1, v2, v3, v4);}
01545
01546 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5>
01547 PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5)
01548 {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
01549
01550 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6>
01551 PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6)
01552 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
01553
01554 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6, <span class="keyword">class</span> T7>
01555 PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7)
01556 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
01557
01558 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6, <span class="keyword">class</span> T7, <span class="keyword">class</span> T8>
01559 PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8)
01560 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
01561
01562 <span class="preprocessor">#else</span>
01563 <span class="preprocessor"></span>
01564 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2>
01565 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2)
01566 {this->AccessKey().Initialize(v1, v2);}
01567
01568 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3>
01569 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3)
01570 {this->AccessKey().Initialize(v1, v2, v3);}
01571
01572 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4>
01573 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4)
01574 {this->AccessKey().Initialize(v1, v2, v3, v4);}
01575
01576 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5>
01577 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5)
01578 {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
01579
01580 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6>
01581 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5, <span class="keyword">const</span> T6 &v6)
01582 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
01583
01584 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6, <span class="keyword">class</span> T7>
01585 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5, <span class="keyword">const</span> T6 &v6, <span class="keyword">const</span> T7 &v7)
01586 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
01587
01588 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6, <span class="keyword">class</span> T7, <span class="keyword">class</span> T8>
01589 PK_FinalTemplate(<span class="keyword">const</span> T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5, <span class="keyword">const</span> T6 &v6, <span class="keyword">const</span> T7 &v7, <span class="keyword">const</span> T8 &v8)
01590 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
01591
01592 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2>
01593 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2)
01594 {this->AccessKey().Initialize(v1, v2);}
01595
01596 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3>
01597 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3)
01598 {this->AccessKey().Initialize(v1, v2, v3);}
01599
01600 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4>
01601 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4)
01602 {this->AccessKey().Initialize(v1, v2, v3, v4);}
01603
01604 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5>
01605 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5)
01606 {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
01607
01608 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6>
01609 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5, <span class="keyword">const</span> T6 &v6)
01610 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
01611
01612 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6, <span class="keyword">class</span> T7>
01613 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5, <span class="keyword">const</span> T6 &v6, <span class="keyword">const</span> T7 &v7)
01614 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
01615
01616 <span class="keyword">template</span> <<span class="keyword">class</span> T1, <span class="keyword">class</span> T2, <span class="keyword">class</span> T3, <span class="keyword">class</span> T4, <span class="keyword">class</span> T5, <span class="keyword">class</span> T6, <span class="keyword">class</span> T7, <span class="keyword">class</span> T8>
01617 PK_FinalTemplate(T1 &v1, <span class="keyword">const</span> T2 &v2, <span class="keyword">const</span> T3 &v3, <span class="keyword">const</span> T4 &v4, <span class="keyword">const</span> T5 &v5, <span class="keyword">const</span> T6 &v6, <span class="keyword">const</span> T7 &v7, <span class="keyword">const</span> T8 &v8)
01618 {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
01619
01620 <span class="preprocessor">#endif</span>
01621 <span class="preprocessor"></span>};
01622 <span class="comment"></span>
01623 <span class="comment">//! Base class for public key encryption standard classes. These classes are used to select from variants of algorithms. Note that not all standards apply to all algorithms.</span>
<a name="l01624"></a><a class="code" href="struct_encryption_standard.html">01624</a> <span class="comment"></span><span class="keyword">struct </span><a class="code" href="struct_encryption_standard.html">EncryptionStandard</a> {};
01625 <span class="comment"></span>
01626 <span class="comment">//! Base class for public key signature standard classes. These classes are used to select from variants of algorithms. Note that not all standards apply to all algorithms.</span>
<a name="l01627"></a><a class="code" href="struct_signature_standard.html">01627</a> <span class="comment"></span><span class="keyword">struct </span><a class="code" href="struct_signature_standard.html">SignatureStandard</a> {};
01628
01629 <span class="keyword">template</span> <<span class="keyword">class</span> STANDARD, <span class="keyword">class</span> KEYS, <span class="keyword">class</span> ALG_INFO>
01630 <span class="keyword">class </span><a class="code" href="class_t_f___e_s.html">TF_ES</a>;
01631 <span class="comment"></span>
01632 <span class="comment">//! Trapdoor Function Based Encryption Scheme</span>
01633 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> STANDARD, <span class="keyword">class</span> KEYS, <span class="keyword">class</span> ALG_INFO = TF_ES<STANDARD, KEYS, <span class="keywordtype">int</span>> >
<a name="l01634"></a><a class="code" href="class_t_f___e_s.html">01634</a> <span class="keyword">class </span><a class="code" href="class_t_f___e_s.html">TF_ES</a> : <span class="keyword">public</span> KEYS
01635 {
01636 <span class="keyword">typedef</span> <span class="keyword">typename</span> STANDARD::EncryptionMessageEncodingMethod MessageEncodingMethod;
01637
01638 <span class="keyword">public</span>:<span class="comment"></span>
01639 <span class="comment"> //! see EncryptionStandard for a list of standards</span>
<a name="l01640"></a><a class="code" href="class_t_f___e_s.html#_t_f___e_sw0">01640</a> <span class="comment"></span> <span class="keyword">typedef</span> STANDARD <a class="code" href="class_t_f___e_s.html#_t_f___e_sw0">Standard</a>;
01641 <span class="keyword">typedef</span> <a class="code" href="struct_t_f___crypto_scheme_options.html">TF_CryptoSchemeOptions<ALG_INFO, KEYS, MessageEncodingMethod></a> <a class="code" href="struct_t_f___crypto_scheme_options.html">SchemeOptions</a>;
01642
01643 <span class="keyword">static</span> std::string StaticAlgorithmName() {<span class="keywordflow">return</span> KEYS::StaticAlgorithmName() + <span class="stringliteral">"/"</span> + MessageEncodingMethod::StaticAlgorithmName();}
01644 <span class="comment"></span>
01645 <span class="comment"> //! implements PK_Decryptor interface</span>
<a name="l01646"></a><a class="code" href="class_t_f___e_s.html#_t_f___e_sw2">01646</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<TF_DecryptorImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Decryptor</a>;<span class="comment"></span>
01647 <span class="comment"> //! implements PK_Encryptor interface</span>
<a name="l01648"></a><a class="code" href="class_t_f___e_s.html#_t_f___e_sw3">01648</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<TF_EncryptorImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Encryptor</a>;
01649 };
01650
01651 <span class="keyword">template</span> <<span class="keyword">class</span> STANDARD, <span class="keyword">class</span> H, <span class="keyword">class</span> KEYS, <span class="keyword">class</span> ALG_INFO> <span class="comment">// VC60 workaround: doesn't work if KEYS is first parameter</span>
01652 <span class="keyword">class </span><a class="code" href="class_t_f___s_s.html">TF_SS</a>;
01653 <span class="comment"></span>
01654 <span class="comment">//! Trapdoor Function Based Signature Scheme</span>
01655 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> STANDARD, <span class="keyword">class</span> H, <span class="keyword">class</span> KEYS, <span class="keyword">class</span> ALG_INFO = TF_SS<STANDARD, H, KEYS, <span class="keywordtype">int</span>> > <span class="comment">// VC60 workaround: doesn't work if KEYS is first parameter</span>
<a name="l01656"></a><a class="code" href="class_t_f___s_s.html">01656</a> <span class="keyword">class </span><a class="code" href="class_t_f___s_s.html">TF_SS</a> : <span class="keyword">public</span> KEYS
01657 {
01658 <span class="keyword">public</span>:<span class="comment"></span>
01659 <span class="comment"> //! see SignatureStandard for a list of standards</span>
<a name="l01660"></a><a class="code" href="class_t_f___s_s.html#_t_f___s_sw0">01660</a> <span class="comment"></span> <span class="keyword">typedef</span> STANDARD <a class="code" href="class_t_f___s_s.html#_t_f___s_sw0">Standard</a>;
01661 <span class="keyword">typedef</span> <span class="keyword">typename</span> Standard::SignatureMessageEncodingMethod MessageEncodingMethod;
01662 <span class="keyword">typedef</span> <a class="code" href="struct_t_f___signature_scheme_options.html">TF_SignatureSchemeOptions<ALG_INFO, KEYS, MessageEncodingMethod, H></a> <a class="code" href="struct_t_f___signature_scheme_options.html">SchemeOptions</a>;
01663
01664 <span class="keyword">static</span> std::string StaticAlgorithmName() {<span class="keywordflow">return</span> KEYS::StaticAlgorithmName() + <span class="stringliteral">"/"</span> + MessageEncodingMethod::StaticAlgorithmName() + <span class="stringliteral">"("</span> + H::StaticAlgorithmName() + <span class="stringliteral">")"</span>;}
01665 <span class="comment"></span>
01666 <span class="comment"> //! implements PK_Signer interface</span>
<a name="l01667"></a><a class="code" href="class_t_f___s_s.html#_t_f___s_sw3">01667</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<TF_SignerImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Signer</a>;<span class="comment"></span>
01668 <span class="comment"> //! implements PK_Verifier interface</span>
<a name="l01669"></a><a class="code" href="class_t_f___s_s.html#_t_f___s_sw4">01669</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<TF_VerifierImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Verifier</a>;
01670 };
01671
01672 <span class="keyword">template</span> <<span class="keyword">class</span> KEYS, <span class="keyword">class</span> SA, <span class="keyword">class</span> MEM, <span class="keyword">class</span> H, <span class="keyword">class</span> ALG_INFO>
01673 <span class="keyword">class </span><a class="code" href="class_d_l___s_s.html">DL_SS</a>;
01674 <span class="comment"></span>
01675 <span class="comment">//! Discrete Log Based Signature Scheme</span>
01676 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> KEYS, <span class="keyword">class</span> SA, <span class="keyword">class</span> MEM, <span class="keyword">class</span> H, <span class="keyword">class</span> ALG_INFO = DL_SS<KEYS, SA, MEM, H, <span class="keywordtype">int</span>> >
<a name="l01677"></a><a class="code" href="class_d_l___s_s.html">01677</a> <span class="keyword">class </span><a class="code" href="class_d_l___s_s.html">DL_SS</a> : <span class="keyword">public</span> KEYS
01678 {
01679 <span class="keyword">typedef</span> <a class="code" href="struct_d_l___signature_scheme_options.html">DL_SignatureSchemeOptions<ALG_INFO, KEYS, SA, MEM, H></a> <a class="code" href="struct_d_l___signature_scheme_options.html">SchemeOptions</a>;
01680
01681 <span class="keyword">public</span>:
01682 <span class="keyword">static</span> std::string StaticAlgorithmName() {<span class="keywordflow">return</span> SA::StaticAlgorithmName() + std::string(<span class="stringliteral">"/EMSA1("</span>) + H::StaticAlgorithmName() + <span class="stringliteral">")"</span>;}
01683 <span class="comment"></span>
01684 <span class="comment"> //! implements PK_Signer interface</span>
<a name="l01685"></a><a class="code" href="class_d_l___s_s.html#_d_l___s_sw0">01685</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<DL_SignerImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Signer</a>;<span class="comment"></span>
01686 <span class="comment"> //! implements PK_Verifier interface</span>
<a name="l01687"></a><a class="code" href="class_d_l___s_s.html#_d_l___s_sw1">01687</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<DL_VerifierImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Verifier</a>;
01688 };
01689 <span class="comment"></span>
01690 <span class="comment">//! Discrete Log Based Encryption Scheme</span>
01691 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> KEYS, <span class="keyword">class</span> AA, <span class="keyword">class</span> DA, <span class="keyword">class</span> EA, <span class="keyword">class</span> ALG_INFO>
<a name="l01692"></a><a class="code" href="class_d_l___e_s.html">01692</a> <span class="keyword">class </span><a class="code" href="class_d_l___e_s.html">DL_ES</a> : <span class="keyword">public</span> KEYS
01693 {
01694 <span class="keyword">typedef</span> <a class="code" href="struct_d_l___crypto_scheme_options.html">DL_CryptoSchemeOptions<ALG_INFO, KEYS, AA, DA, EA></a> <a class="code" href="struct_d_l___crypto_scheme_options.html">SchemeOptions</a>;
01695
01696 <span class="keyword">public</span>:<span class="comment"></span>
01697 <span class="comment"> //! implements PK_Decryptor interface</span>
<a name="l01698"></a><a class="code" href="class_d_l___e_s.html#_d_l___e_sw0">01698</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<DL_DecryptorImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Decryptor</a>;<span class="comment"></span>
01699 <span class="comment"> //! implements PK_Encryptor interface</span>
<a name="l01700"></a><a class="code" href="class_d_l___e_s.html#_d_l___e_sw1">01700</a> <span class="comment"></span> <span class="keyword">typedef</span> <a class="code" href="class_p_k___final_template.html">PK_FinalTemplate<DL_EncryptorImpl<SchemeOptions></a> > <a class="code" href="class_p_k___final_template.html">Encryptor</a>;
01701 };
01702
01703 NAMESPACE_END
01704
01705 <span class="preprocessor">#endif</span>
</div></pre><hr size="1"><address style="align: right;"><small>Generated on Sun Nov 7 08:23:58 2004 for Crypto++ by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 ></a> 1.3.7 </small></address>
</body>
</html>
distrib
>
Mandriva
>
10.2
>
i586
>
media
>
contrib
>
by-pkgid
>
7457b841ac8136d3a1a9d3d960c5252e
>
files
>
1356
