<!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++: strciphr.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>strciphr.h</h1><a href="strciphr_8h.html">Go to the documentation of this file.</a><pre class="fragment"><div>00001 <span class="comment">/*! \file</span>
00002 <span class="comment"> This file contains helper classes for implementing stream ciphers.</span>
00003 <span class="comment"></span>
00004 <span class="comment"> All this infrastructure may look very complex compared to what's in Crypto++ 4.x,</span>
00005 <span class="comment"> but stream ciphers implementations now support a lot of new functionality,</span>
00006 <span class="comment"> including better performance (minimizing copying), resetting of keys and IVs, and methods to</span>
00007 <span class="comment"> query which features are supported by a cipher.</span>
00008 <span class="comment"></span>
00009 <span class="comment"> Here's an explanation of these classes. The word "policy" is used here to mean a class with a</span>
00010 <span class="comment"> set of methods that must be implemented by individual stream cipher implementations.</span>
00011 <span class="comment"> This is usually much simpler than the full stream cipher API, which is implemented by</span>
00012 <span class="comment"> either AdditiveCipherTemplate or CFB_CipherTemplate using the policy. So for example, an</span>
00013 <span class="comment"> implementation of SEAL only needs to implement the AdditiveCipherAbstractPolicy interface</span>
00014 <span class="comment"> (since it's an additive cipher, i.e., it xors a keystream into the plaintext).</span>
00015 <span class="comment"> See this line in seal.h:</span>
00016 <span class="comment"></span>
00017 <span class="comment"> typedef SymmetricCipherFinal<ConcretePolicyHolder<SEAL_Policy<B>, AdditiveCipherTemplate<> > > Encryption;</span>
00018 <span class="comment"></span>
00019 <span class="comment"> AdditiveCipherTemplate and CFB_CipherTemplate are designed so that they don't need</span>
00020 <span class="comment"> to take a policy class as a template parameter (although this is allowed), so that</span>
00021 <span class="comment"> their code is not duplicated for each new cipher. Instead they each</span>
00022 <span class="comment"> get a reference to an abstract policy interface by calling AccessPolicy() on itself, so</span>
00023 <span class="comment"> AccessPolicy() must be overriden to return the actual policy reference. This is done</span>
00024 <span class="comment"> by the ConceretePolicyHolder class. Finally, SymmetricCipherFinal implements the constructors and</span>
00025 <span class="comment"> other functions that must be implemented by the most derived class.</span>
00026 <span class="comment">*/</span>
00027
00028 <span class="preprocessor">#ifndef CRYPTOPP_STRCIPHR_H</span>
00029 <span class="preprocessor"></span><span class="preprocessor">#define CRYPTOPP_STRCIPHR_H</span>
00030 <span class="preprocessor"></span>
00031 <span class="preprocessor">#include "seckey.h"</span>
00032 <span class="preprocessor">#include "secblock.h"</span>
00033 <span class="preprocessor">#include "argnames.h"</span>
00034
00035 NAMESPACE_BEGIN(CryptoPP)
00036
00037 template <class POLICY_INTERFACE, class BASE = Empty>
00038 class CRYPTOPP_NO_VTABLE AbstractPolicyHolder : public BASE
00039 {
00040 <span class="keyword">public</span>:
00041 <span class="keyword">typedef</span> POLICY_INTERFACE PolicyInterface;
00042
00043 <span class="keyword">protected</span>:
00044 <span class="keyword">virtual</span> <span class="keyword">const</span> POLICY_INTERFACE & GetPolicy() const =0;
00045 virtual POLICY_INTERFACE & AccessPolicy() =0;
00046 };
00047
00048 template <class POLICY, class BASE, class POLICY_INTERFACE = CPP_TYPENAME BASE::PolicyInterface>
00049 class ConcretePolicyHolder : public BASE, protected POLICY
00050 {
00051 <span class="keyword">protected</span>:
00052 <span class="keyword">const</span> POLICY_INTERFACE & GetPolicy()<span class="keyword"> const </span>{<span class="keywordflow">return</span> *<span class="keyword">this</span>;}
00053 POLICY_INTERFACE & AccessPolicy() {<span class="keywordflow">return</span> *<span class="keyword">this</span>;}
00054 };
00055
00056 <span class="keyword">enum</span> KeystreamOperation {WRITE_KEYSTREAM, XOR_KEYSTREAM, XOR_KEYSTREAM_INPLACE};
00057
00058 <span class="keyword">struct </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
00059 {
00060 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetAlignment() const =0;
00061 virtual <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetBytesPerIteration() const =0;
00062 virtual <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetIterationsToBuffer() const =0;
00063 virtual <span class="keywordtype">void</span> WriteKeystream(byte *keystreamBuffer, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> iterationCount) =0;
00064 virtual <span class="keywordtype">bool</span> CanOperateKeystream()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00065 <span class="keyword">virtual</span> <span class="keywordtype">void</span> OperateKeystream(KeystreamOperation operation, byte *output, <span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> iterationCount) {assert(<span class="keyword">false</span>);}
00066 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CipherSetKey(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params, <span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length) =0;
00067 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CipherResynchronize(byte *keystreamBuffer, <span class="keyword">const</span> byte *iv) {<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"StreamTransformation: this object doesn't support resynchronization"</span>);}
00068 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> IsRandomAccess() const =0;
00069 virtual <span class="keywordtype">void</span> SeekToIteration(lword iterationCount) {assert(!IsRandomAccess()); <span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"StreamTransformation: this object doesn't support random access"</span>);}
00070 };
00071
00072 <span class="keyword">template</span> <<span class="keyword">typename</span> WT, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> W, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> X = 1, <span class="keyword">class</span> BASE = AdditiveCipherAbstractPolicy>
00073 <span class="keyword">struct </span>CRYPTOPP_NO_VTABLE AdditiveCipherConcretePolicy : <span class="keyword">public</span> BASE
00074 {
00075 <span class="keyword">typedef</span> WT WordType;
00076
00077 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetAlignment()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">sizeof</span>(WordType);}
00078 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetBytesPerIteration()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">sizeof</span>(WordType) * W;}
00079 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetIterationsToBuffer()<span class="keyword"> const </span>{<span class="keywordflow">return</span> X;}
00080 <span class="keywordtype">void</span> WriteKeystream(byte *buffer, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> iterationCount)
00081 {OperateKeystream(WRITE_KEYSTREAM, buffer, NULL, iterationCount);}
00082 <span class="keywordtype">bool</span> CanOperateKeystream()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00083 <span class="keyword">virtual</span> <span class="keywordtype">void</span> OperateKeystream(KeystreamOperation operation, byte *output, <span class="keyword">const</span> byte *input, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> iterationCount) =0;
00084
00085 <span class="keyword">template</span> <<span class="keyword">class</span> B>
00086 <span class="keyword">struct </span>KeystreamOutput
00087 {
00088 KeystreamOutput(KeystreamOperation operation, byte *output, <span class="keyword">const</span> byte *input)
00089 : m_operation(operation), m_output(output), m_input(input) {}
00090
00091 <span class="keyword">inline</span> KeystreamOutput & operator()(WordType keystreamWord)
00092 {
00093 assert(IsAligned<WordType>(m_input));
00094 assert(IsAligned<WordType>(m_output));
00095
00096 <span class="keywordflow">if</span> (!NativeByteOrderIs(B::ToEnum()))
00097 keystreamWord = ByteReverse(keystreamWord);
00098
00099 <span class="keywordflow">if</span> (m_operation == WRITE_KEYSTREAM)
00100 *(WordType*)m_output = keystreamWord;
00101 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (m_operation == XOR_KEYSTREAM)
00102 {
00103 *(WordType*)m_output = keystreamWord ^ *(WordType*)m_input;
00104 m_input += <span class="keyword">sizeof</span>(WordType);
00105 }
00106 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (m_operation == XOR_KEYSTREAM_INPLACE)
00107 *(WordType*)m_output ^= keystreamWord;
00108
00109 m_output += <span class="keyword">sizeof</span>(WordType);
00110
00111 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00112 }
00113
00114 KeystreamOperation m_operation;
00115 byte *m_output;
00116 <span class="keyword">const</span> byte *m_input;
00117 };
00118 };
00119
00120 <span class="keyword">template</span> <<span class="keyword">class</span> BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, TwoBases<SymmetricCipher, RandomNumberGenerator> > >
00121 <span class="keyword">class </span>CRYPTOPP_NO_VTABLE AdditiveCipherTemplate : <span class="keyword">public</span> BASE
00122 {
00123 <span class="keyword">public</span>:
00124 byte GenerateByte();
00125 <span class="keywordtype">void</span> ProcessData(byte *outString, <span class="keyword">const</span> byte *inString, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length);
00126 <span class="keywordtype">void</span> Resynchronize(<span class="keyword">const</span> byte *iv);
00127 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> OptimalBlockSize()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetPolicy().GetBytesPerIteration();}
00128 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetOptimalNextBlockSize()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->m_leftOver;}
00129 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> OptimalDataAlignment()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetPolicy().GetAlignment();}
00130 <span class="keywordtype">bool</span> IsSelfInverting()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00131 <span class="keywordtype">bool</span> IsForwardTransformation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00132 <span class="keywordtype">bool</span> IsRandomAccess()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetPolicy().IsRandomAccess();}
00133 <span class="keywordtype">void</span> Seek(lword position);
00134
00135 <span class="keyword">typedef</span> <span class="keyword">typename</span> BASE::PolicyInterface PolicyInterface;
00136
00137 <span class="keyword">protected</span>:
00138 <span class="keywordtype">void</span> UncheckedSetKey(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params, <span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length, <span class="keyword">const</span> byte *iv);
00139
00140 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetBufferByteSize(<span class="keyword">const</span> PolicyInterface &policy)<span class="keyword"> const </span>{<span class="keywordflow">return</span> policy.GetBytesPerIteration() * policy.GetIterationsToBuffer();}
00141
00142 <span class="keyword">inline</span> byte * KeystreamBufferBegin() {<span class="keywordflow">return</span> this->m_buffer.data();}
00143 <span class="keyword">inline</span> byte * KeystreamBufferEnd() {<span class="keywordflow">return</span> (this->m_buffer.data() + this->m_buffer.size());}
00144
00145 <a class="code" href="class_sec_block.html">SecByteBlock</a> m_buffer;
00146 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> m_leftOver;
00147 };
00148
00149 CRYPTOPP_DLL_TEMPLATE_CLASS <a class="code" href="class_two_bases.html">TwoBases<SymmetricCipher, RandomNumberGenerator></a>;
00150 CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<AdditiveCipherAbstractPolicy, TwoBases<SymmetricCipher, RandomNumberGenerator> >;
00151 CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<>;
00152
00153 <span class="keyword">class </span>CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy
00154 {
00155 <span class="keyword">public</span>:
00156 <span class="keyword">virtual</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetAlignment() const =0;
00157 virtual <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetBytesPerIteration() const =0;
00158 virtual byte * GetRegisterBegin() =0;
00159 virtual <span class="keywordtype">void</span> TransformRegister() =0;
00160 virtual <span class="keywordtype">bool</span> CanIterate()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00161 <span class="keyword">virtual</span> <span class="keywordtype">void</span> Iterate(byte *output, <span class="keyword">const</span> byte *input, CipherDir dir, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> iterationCount) {assert(<span class="keyword">false</span>);}
00162 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CipherSetKey(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params, <span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length) =0;
00163 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CipherResynchronize(<span class="keyword">const</span> byte *iv) {<span class="keywordflow">throw</span> <a class="code" href="class_not_implemented.html">NotImplemented</a>(<span class="stringliteral">"StreamTransformation: this object doesn't support resynchronization"</span>);}
00164 };
00165
00166 <span class="keyword">template</span> <<span class="keyword">typename</span> WT, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> W, <span class="keyword">class</span> BASE = CFB_CipherAbstractPolicy>
00167 <span class="keyword">struct </span>CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : <span class="keyword">public</span> BASE
00168 {
00169 <span class="keyword">typedef</span> WT WordType;
00170
00171 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetAlignment()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">sizeof</span>(WordType);}
00172 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetBytesPerIteration()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">sizeof</span>(WordType) * W;}
00173 <span class="keywordtype">bool</span> CanIterate()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00174 <span class="keywordtype">void</span> TransformRegister() {this->Iterate(NULL, NULL, ENCRYPTION, 1);}
00175
00176 <span class="keyword">template</span> <<span class="keyword">class</span> B>
00177 <span class="keyword">struct </span>RegisterOutput
00178 {
00179 RegisterOutput(byte *output, <span class="keyword">const</span> byte *input, CipherDir dir)
00180 : m_output(output), m_input(input), m_dir(dir) {}
00181
00182 <span class="keyword">inline</span> RegisterOutput& operator()(WordType &registerWord)
00183 {
00184 assert(IsAligned<WordType>(m_output));
00185 assert(IsAligned<WordType>(m_input));
00186
00187 <span class="keywordflow">if</span> (!NativeByteOrderIs(B::ToEnum()))
00188 registerWord = ByteReverse(registerWord);
00189
00190 <span class="keywordflow">if</span> (m_dir == ENCRYPTION)
00191 {
00192 WordType ct = *(<span class="keyword">const</span> WordType *)m_input ^ registerWord;
00193 registerWord = ct;
00194 *(WordType*)m_output = ct;
00195 m_input += <span class="keyword">sizeof</span>(WordType);
00196 m_output += <span class="keyword">sizeof</span>(WordType);
00197 }
00198 <span class="keywordflow">else</span>
00199 {
00200 WordType ct = *(<span class="keyword">const</span> WordType *)m_input;
00201 *(WordType*)m_output = registerWord ^ ct;
00202 registerWord = ct;
00203 m_input += <span class="keyword">sizeof</span>(WordType);
00204 m_output += <span class="keyword">sizeof</span>(WordType);
00205 }
00206
00207 <span class="comment">// registerWord is left unreversed so it can be xor-ed with further input</span>
00208
00209 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00210 }
00211
00212 byte *m_output;
00213 <span class="keyword">const</span> byte *m_input;
00214 <a class="code" href="cryptlib_8h.html#a11">CipherDir</a> m_dir;
00215 };
00216 };
00217
00218 <span class="keyword">template</span> <<span class="keyword">class</span> BASE>
00219 <span class="keyword">class </span>CRYPTOPP_NO_VTABLE CFB_CipherTemplate : <span class="keyword">public</span> BASE
00220 {
00221 <span class="keyword">public</span>:
00222 <span class="keywordtype">void</span> ProcessData(byte *outString, <span class="keyword">const</span> byte *inString, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length);
00223 <span class="keywordtype">void</span> Resynchronize(<span class="keyword">const</span> byte *iv);
00224 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> OptimalBlockSize()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetPolicy().GetBytesPerIteration();}
00225 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetOptimalNextBlockSize()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_leftOver;}
00226 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> OptimalDataAlignment()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->GetPolicy().GetAlignment();}
00227 <span class="keywordtype">bool</span> IsRandomAccess()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00228 <span class="keywordtype">bool</span> IsSelfInverting()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00229
00230 <span class="keyword">typedef</span> <span class="keyword">typename</span> BASE::PolicyInterface PolicyInterface;
00231
00232 <span class="keyword">protected</span>:
00233 <span class="keyword">virtual</span> <span class="keywordtype">void</span> CombineMessageAndShiftRegister(byte *output, byte *reg, <span class="keyword">const</span> byte *message, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length) =0;
00234
00235 <span class="keywordtype">void</span> UncheckedSetKey(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params, <span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length, <span class="keyword">const</span> byte *iv);
00236
00237 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> m_leftOver;
00238 };
00239
00240 <span class="keyword">template</span> <<span class="keyword">class</span> BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
00241 <span class="keyword">class </span>CRYPTOPP_NO_VTABLE CFB_EncryptionTemplate : <span class="keyword">public</span> CFB_CipherTemplate<BASE>
00242 {
00243 <span class="keywordtype">bool</span> IsForwardTransformation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">true</span>;}
00244 <span class="keywordtype">void</span> CombineMessageAndShiftRegister(byte *output, byte *reg, <span class="keyword">const</span> byte *message, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length);
00245 };
00246
00247 <span class="keyword">template</span> <<span class="keyword">class</span> BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
00248 <span class="keyword">class </span>CRYPTOPP_NO_VTABLE CFB_DecryptionTemplate : <span class="keyword">public</span> CFB_CipherTemplate<BASE>
00249 {
00250 <span class="keywordtype">bool</span> IsForwardTransformation()<span class="keyword"> const </span>{<span class="keywordflow">return</span> <span class="keyword">false</span>;}
00251 <span class="keywordtype">void</span> CombineMessageAndShiftRegister(byte *output, byte *reg, <span class="keyword">const</span> byte *message, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length);
00252 };
00253
00254 <span class="keyword">template</span> <<span class="keyword">class</span> BASE>
00255 <span class="keyword">class </span>CFB_RequireFullDataBlocks : <span class="keyword">public</span> BASE
00256 {
00257 <span class="keyword">public</span>:
00258 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> MandatoryBlockSize()<span class="keyword"> const </span>{<span class="keywordflow">return</span> this->OptimalBlockSize();}
00259 };
00260
00261 <span class="comment">// for Darwin</span>
00262 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
00263 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<>;
00264 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<>;
00265 <span class="comment"></span>
<a name="l00266"></a><a class="code" href="class_symmetric_cipher_final.html">00266</a> <span class="comment">//! _</span>
00267 <span class="comment"></span><span class="keyword">template</span> <<span class="keyword">class</span> BASE, <span class="keyword">class</span> INFO = BASE>
00268 <span class="keyword">class </span><a class="code" href="class_symmetric_cipher_final.html">SymmetricCipherFinal</a> : <span class="keyword">public</span> <a class="code" href="class_algorithm_impl.html">AlgorithmImpl</a><SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>
00269 {
00270 <span class="keyword">public</span>:
00271 <a class="code" href="class_symmetric_cipher_final.html">SymmetricCipherFinal</a>() {}
00272 <a class="code" href="class_symmetric_cipher_final.html">SymmetricCipherFinal</a>(<span class="keyword">const</span> byte *key)
00273 {SetKey(key, this->DEFAULT_KEYLENGTH);}
00274 <a class="code" href="class_symmetric_cipher_final.html">SymmetricCipherFinal</a>(<span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length)
00275 {SetKey(key, length);}
00276 <a class="code" href="class_symmetric_cipher_final.html">SymmetricCipherFinal</a>(<span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length, <span class="keyword">const</span> byte *iv)
00277 {this->SetKeyWithIV(key, length, iv);}
00278
00279 <span class="keywordtype">void</span> SetKey(<span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params = g_nullNameValuePairs)
00280 {
00281 this->ThrowIfInvalidKeyLength(length);
00282 this->UncheckedSetKey(params, key, length, this->GetIVAndThrowIfInvalid(params));
00283 }
00284
00285 <a class="code" href="class_clonable.html">Clonable</a> * Clone()<span class="keyword"> const </span>{<span class="keywordflow">return</span> static_cast<SymmetricCipher *>(<span class="keyword">new</span> <a class="code" href="class_symmetric_cipher_final.html">SymmetricCipherFinal<BASE, INFO></a>(*this));}
00286 };
00287
00288 <span class="keyword">template</span> <<span class="keyword">class</span> S>
00289 <span class="keywordtype">void</span> AdditiveCipherTemplate<S>::UncheckedSetKey(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params, <span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length, <span class="keyword">const</span> byte *iv)
00290 {
00291 PolicyInterface &policy = this->AccessPolicy();
00292 policy.CipherSetKey(params, key, length);
00293 m_leftOver = 0;
00294 m_buffer.New(GetBufferByteSize(policy));
00295
00296 <span class="keywordflow">if</span> (this->IsResynchronizable())
00297 policy.CipherResynchronize(m_buffer, iv);
00298 }
00299
00300 <span class="keyword">template</span> <<span class="keyword">class</span> BASE>
00301 <span class="keywordtype">void</span> CFB_CipherTemplate<BASE>::UncheckedSetKey(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &params, <span class="keyword">const</span> byte *key, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length, <span class="keyword">const</span> byte *iv)
00302 {
00303 PolicyInterface &policy = this->AccessPolicy();
00304 policy.CipherSetKey(params, key, length);
00305
00306 <span class="keywordflow">if</span> (this->IsResynchronizable())
00307 policy.CipherResynchronize(iv);
00308
00309 m_leftOver = policy.GetBytesPerIteration();
00310 }
00311
00312 NAMESPACE_END
00313
00314 <span class="preprocessor">#endif</span>
</div></pre><hr size="1"><address style="align: right;"><small>Generated on Sun Nov 7 08:23:59 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
>
1425
