misc_8h-source.html

Crypto++是一个非常强大的密码学库,主要是功能全

00462 
00463 <span class="keyword">inline</span> byte UnalignedGetWordNonTemplate(ByteOrder order, <span class="keyword">const</span> byte *block, byte*)
00464 {
00465         <span class="keywordflow">return</span> block[0];
00466 }
00467 
00468 <span class="keyword">inline</span> word16 UnalignedGetWordNonTemplate(ByteOrder order, <span class="keyword">const</span> byte *block, word16*)
00469 {
00470         <span class="keywordflow">return</span> (order == BIG_ENDIAN_ORDER)
00471                 ? block[1] | (block[0] &lt;&lt; 8)
00472                 : block[0] | (block[1] &lt;&lt; 8);
00473 }
00474 
00475 <span class="keyword">inline</span> word32 UnalignedGetWordNonTemplate(ByteOrder order, <span class="keyword">const</span> byte *block, word32*)
00476 {
00477         <span class="keywordflow">return</span> (order == BIG_ENDIAN_ORDER)
00478                 ? word32(block[3]) | (word32(block[2]) &lt;&lt; 8) | (word32(block[1]) &lt;&lt; 16) | (word32(block[0]) &lt;&lt; 24)
00479                 : word32(block[0]) | (word32(block[1]) &lt;&lt; 8) | (word32(block[2]) &lt;&lt; 16) | (word32(block[3]) &lt;&lt; 24);
00480 }
00481 
00482 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00483 <span class="keyword">inline</span> T UnalignedGetWord(ByteOrder order, <span class="keyword">const</span> byte *block, T*dummy=NULL)
00484 {
00485         <span class="keywordflow">return</span> UnalignedGetWordNonTemplate(order, block, dummy);
00486 }
00487 
00488 <span class="keyword">inline</span> <span class="keywordtype">void</span> UnalignedPutWord(ByteOrder order, byte *block, byte value, <span class="keyword">const</span> byte *xorBlock = NULL)
00489 {
00490         block[0] = xorBlock ? (value ^ xorBlock[0]) : value;
00491 }
00492 
00493 <span class="keyword">inline</span> <span class="keywordtype">void</span> UnalignedPutWord(ByteOrder order, byte *block, word16 value, <span class="keyword">const</span> byte *xorBlock = NULL)
00494 {
00495         <span class="keywordflow">if</span> (order == BIG_ENDIAN_ORDER)
00496         {
00497                 block[0] = GETBYTE(value, 1);
00498                 block[1] = GETBYTE(value, 0);
00499         }
00500         <span class="keywordflow">else</span>
00501         {
00502                 block[0] = GETBYTE(value, 0);
00503                 block[1] = GETBYTE(value, 1);
00504         }
00505 
00506         <span class="keywordflow">if</span> (xorBlock)
00507         {
00508                 block[0] ^= xorBlock[0];
00509                 block[1] ^= xorBlock[1];
00510         }
00511 }
00512 
00513 <span class="keyword">inline</span> <span class="keywordtype">void</span> UnalignedPutWord(ByteOrder order, byte *block, word32 value, <span class="keyword">const</span> byte *xorBlock = NULL)
00514 {
00515         <span class="keywordflow">if</span> (order == BIG_ENDIAN_ORDER)
00516         {
00517                 block[0] = GETBYTE(value, 3);
00518                 block[1] = GETBYTE(value, 2);
00519                 block[2] = GETBYTE(value, 1);
00520                 block[3] = GETBYTE(value, 0);
00521         }
00522         <span class="keywordflow">else</span>
00523         {
00524                 block[0] = GETBYTE(value, 0);
00525                 block[1] = GETBYTE(value, 1);
00526                 block[2] = GETBYTE(value, 2);
00527                 block[3] = GETBYTE(value, 3);
00528         }
00529 
00530         <span class="keywordflow">if</span> (xorBlock)
00531         {
00532                 block[0] ^= xorBlock[0];
00533                 block[1] ^= xorBlock[1];
00534                 block[2] ^= xorBlock[2];
00535                 block[3] ^= xorBlock[3];
00536         }
00537 }
00538 
00539 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00540 <span class="keyword">inline</span> T GetWord(<span class="keywordtype">bool</span> assumeAligned, ByteOrder order, <span class="keyword">const</span> byte *block)
00541 {
00542         <span class="keywordflow">if</span> (assumeAligned)
00543         {
00544                 assert(IsAligned&lt;T&gt;(block));
00545                 <span class="keywordflow">return</span> ConditionalByteReverse(order, *reinterpret_cast&lt;const T *&gt;(block));
00546         }
00547         <span class="keywordflow">else</span>
00548                 <span class="keywordflow">return</span> UnalignedGetWord&lt;T&gt;(order, block);
00549 }
00550 
00551 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00552 <span class="keyword">inline</span> <span class="keywordtype">void</span> GetWord(<span class="keywordtype">bool</span> assumeAligned, ByteOrder order, T &amp;result, <span class="keyword">const</span> byte *block)
00553 {
00554         result = GetWord&lt;T&gt;(assumeAligned, order, block);
00555 }
00556 
00557 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00558 <span class="keyword">inline</span> <span class="keywordtype">void</span> PutWord(<span class="keywordtype">bool</span> assumeAligned, ByteOrder order, byte *block, T value, <span class="keyword">const</span> byte *xorBlock = NULL)
00559 {
00560         <span class="keywordflow">if</span> (assumeAligned)
00561         {
00562                 assert(IsAligned&lt;T&gt;(block));
00563                 <span class="keywordflow">if</span> (xorBlock)
00564                         *reinterpret_cast&lt;T *&gt;(block) = ConditionalByteReverse(order, value) ^ *reinterpret_cast&lt;const T *&gt;(xorBlock);
00565                 <span class="keywordflow">else</span>
00566                         *reinterpret_cast&lt;T *&gt;(block) = ConditionalByteReverse(order, value);
00567         }
00568         <span class="keywordflow">else</span>
00569                 UnalignedPutWord(order, block, value, xorBlock);
00570 }
00571 
00572 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keyword">class</span> B, <span class="keywordtype">bool</span> A=true&gt;
00573 <span class="keyword">class </span>GetBlock
00574 {
00575 <span class="keyword">public</span>:
00576         GetBlock(<span class="keyword">const</span> <span class="keywordtype">void</span> *block)
00577                 : m_block((const byte *)block) {}
00578 
00579         <span class="keyword">template</span> &lt;<span class="keyword">class</span> U&gt;
00580         <span class="keyword">inline</span> GetBlock&lt;T, B, A&gt; &amp; operator()(U &amp;x)
00581         {
00582                 CRYPTOPP_COMPILE_ASSERT(<span class="keyword">sizeof</span>(U) &gt;= <span class="keyword">sizeof</span>(T));
00583                 x = GetWord&lt;T&gt;(A, B::ToEnum(), m_block);
00584                 m_block += <span class="keyword">sizeof</span>(T);
00585                 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00586         }
00587 
00588 <span class="keyword">private</span>:
00589         <span class="keyword">const</span> byte *m_block;
00590 };
00591 
00592 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keyword">class</span> B, <span class="keywordtype">bool</span> A=true&gt;
00593 <span class="keyword">class </span>PutBlock
00594 {
00595 <span class="keyword">public</span>:
00596         PutBlock(<span class="keyword">const</span> <span class="keywordtype">void</span> *xorBlock, <span class="keywordtype">void</span> *block)
00597                 : m_xorBlock((const byte *)xorBlock), m_block((byte *)block) {}
00598 
00599         <span class="keyword">template</span> &lt;<span class="keyword">class</span> U&gt;
00600         <span class="keyword">inline</span> PutBlock&lt;T, B, A&gt; &amp; operator()(U x)
00601         {
00602                 PutWord(A, B::ToEnum(), m_block, (T)x, m_xorBlock);
00603                 m_block += <span class="keyword">sizeof</span>(T);
00604                 <span class="keywordflow">if</span> (m_xorBlock)
00605                         m_xorBlock += <span class="keyword">sizeof</span>(T);
00606                 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00607         }
00608 
00609 <span class="keyword">private</span>:
00610         <span class="keyword">const</span> byte *m_xorBlock;
00611         byte *m_block;
00612 };
00613 
00614 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keyword">class</span> B, <span class="keywordtype">bool</span> A=true&gt;
00615 <span class="keyword">struct </span>BlockGetAndPut
00616 {
00617         <span class="comment">// function needed because of C++ grammatical ambiguity between expression-statements and declarations</span>
00618         <span class="keyword">static</span> <span class="keyword">inline</span> GetBlock&lt;T, B, A&gt; Get(<span class="keyword">const</span> <span class="keywordtype">void</span> *block) {<span class="keywordflow">return</span> GetBlock&lt;T, B, A&gt;(block);}
00619         <span class="keyword">typedef</span> PutBlock&lt;T, B, A&gt; Put;
00620 };
00621 
00622 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00623 std::string WordToString(T value, ByteOrder order = BIG_ENDIAN_ORDER)
00624 {
00625         <span class="keywordflow">if</span> (!NativeByteOrderIs(order))
00626                 value = ByteReverse(value);
00627 
00628         <span class="keywordflow">return</span> std::string((<span class="keywordtype">char</span> *)&amp;value, <span class="keyword">sizeof</span>(value));
00629 }
00630 
00631 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00632 T StringToWord(<span class="keyword">const</span> std::string &amp;str, ByteOrder order = BIG_ENDIAN_ORDER)
00633 {
00634         T value = 0;
00635         memcpy(&amp;value, str.data(), STDMIN(<span class="keyword">sizeof</span>(value), str.size()));
00636         <span class="keywordflow">return</span> NativeByteOrderIs(order) ? value : ByteReverse(value);
00637 }
00638 
00639 <span class="comment">// ************** help remove warning on g++ ***************</span>
00640 
00641 <span class="keyword">template</span> &lt;<span class="keywordtype">bool</span> overflow&gt; <span class="keyword">struct </span>SafeShifter;
00642 
00643 <span class="keyword">template</span>&lt;&gt; <span class="keyword">struct </span>SafeShifter&lt;true&gt;
00644 {
00645         <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00646         <span class="keyword">static</span> <span class="keyword">inline</span> T RightShift(T value, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bits)
00647         {
00648                 <span class="keywordflow">return</span> 0;
00649         }
00650 
00651         <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00652         <span class="keyword">static</span> <span class="keyword">inline</span> T LeftShift(T value, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bits)
00653         {
00654                 <span class="keywordflow">return</span> 0;
00655         }
00656 };
00657 
00658 <span class="keyword">template</span>&lt;&gt; <span class="keyword">struct </span>SafeShifter&lt;false&gt;
00659 {
00660         <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00661         <span class="keyword">static</span> <span class="keyword">inline</span> T RightShift(T value, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bits)
00662         {
00663                 <span class="keywordflow">return</span> value &gt;&gt; bits;
00664         }
00665 
00666         <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00667         <span class="keyword">static</span> <span class="keyword">inline</span> T LeftShift(T value, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bits)
00668         {
00669                 <span class="keywordflow">return</span> value &lt;&lt; bits;
00670         }
00671 };
00672 
00673 <span class="keyword">template</span> &lt;<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bits, <span class="keyword">class</span> T&gt;
00674 <span class="keyword">inline</span> T SafeRightShift(T value)
00675 {
00676         <span class="keywordflow">return</span> SafeShifter&lt;(bits&gt;=(8*<span class="keyword">sizeof</span>(T)))&gt;::RightShift(value, bits);
00677 }
00678 
00679 <span class="keyword">template</span> &lt;<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bits, <span class="keyword">class</span> T&gt;
00680 <span class="keyword">inline</span> T SafeLeftShift(T value)
00681 {
00682         <span class="keywordflow">return</span> SafeShifter&lt;(bits&gt;=(8*<span class="keyword">sizeof</span>(T)))&gt;::LeftShift(value, bits);
00683 }
00684 
00685 NAMESPACE_END
00686 
00687 <span class="preprocessor">#endif // MISC_H</span>
</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue Jul 8 23:34:20 2003 for Crypto++ by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 > 
</a>1.3.2 </small></address>
</body>
</html>