misc_8h-source.html

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

00228         assert(y &lt; <span class="keyword">sizeof</span>(T)*8);
00229         <span class="keywordflow">return</span> (x&gt;&gt;y) | (x&lt;&lt;(<span class="keyword">sizeof</span>(T)*8-y));
00230 }
00231 
00232 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt; <span class="keyword">inline</span> T rotlMod(T x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00233 {
00234         y %= <span class="keyword">sizeof</span>(T)*8;
00235         <span class="keywordflow">return</span> (x&lt;&lt;y) | (x&gt;&gt;(<span class="keyword">sizeof</span>(T)*8-y));
00236 }
00237 
00238 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt; <span class="keyword">inline</span> T rotrMod(T x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00239 {
00240         y %= <span class="keyword">sizeof</span>(T)*8;
00241         <span class="keywordflow">return</span> (x&gt;&gt;y) | (x&lt;&lt;(<span class="keyword">sizeof</span>(T)*8-y));
00242 }
00243 
00244 <span class="preprocessor">#ifdef INTEL_INTRINSICS</span>
00245 <span class="preprocessor"></span>
00246 <span class="preprocessor">#pragma intrinsic(_lrotl, _lrotr)</span>
00247 <span class="preprocessor"></span>
00248 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotlFixed&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00249 {
00250         assert(y &lt; 32);
00251         <span class="keywordflow">return</span> y ? _lrotl(x, y) : x;
00252 }
00253 
00254 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotrFixed&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00255 {
00256         assert(y &lt; 32);
00257         <span class="keywordflow">return</span> y ? _lrotr(x, y) : x;
00258 }
00259 
00260 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotlVariable&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00261 {
00262         assert(y &lt; 32);
00263         <span class="keywordflow">return</span> _lrotl(x, y);
00264 }
00265 
00266 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotrVariable&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00267 {
00268         assert(y &lt; 32);
00269         <span class="keywordflow">return</span> _lrotr(x, y);
00270 }
00271 
00272 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotlMod&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00273 {
00274         <span class="keywordflow">return</span> _lrotl(x, y);
00275 }
00276 
00277 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotrMod&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00278 {
00279         <span class="keywordflow">return</span> _lrotr(x, y);
00280 }
00281 
00282 <span class="preprocessor">#endif // #ifdef INTEL_INTRINSICS</span>
00283 <span class="preprocessor"></span>
00284 <span class="preprocessor">#ifdef PPC_INTRINSICS</span>
00285 <span class="preprocessor"></span>
00286 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotlFixed&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00287 {
00288         assert(y &lt; 32);
00289         <span class="keywordflow">return</span> y ? __rlwinm(x,y,0,31) : x;
00290 }
00291 
00292 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotrFixed&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00293 {
00294         assert(y &lt; 32);
00295         <span class="keywordflow">return</span> y ? __rlwinm(x,32-y,0,31) : x;
00296 }
00297 
00298 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotlVariable&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00299 {
00300         assert(y &lt; 32);
00301         <span class="keywordflow">return</span> (__rlwnm(x,y,0,31));
00302 }
00303 
00304 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotrVariable&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00305 {
00306         assert(y &lt; 32);
00307         <span class="keywordflow">return</span> (__rlwnm(x,32-y,0,31));
00308 }
00309 
00310 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotlMod&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00311 {
00312         <span class="keywordflow">return</span> (__rlwnm(x,y,0,31));
00313 }
00314 
00315 <span class="keyword">template</span>&lt;&gt; <span class="keyword">inline</span> word32 rotrMod&lt;word32&gt;(word32 x, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> y)
00316 {
00317         <span class="keywordflow">return</span> (__rlwnm(x,32-y,0,31));
00318 }
00319 
00320 <span class="preprocessor">#endif // #ifdef PPC_INTRINSICS</span>
00321 <span class="preprocessor"></span>
00322 <span class="comment">// ************** endian reversal ***************</span>
00323 
00324 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00325 <span class="keyword">inline</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> GetByte(ByteOrder order, T value, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> index)
00326 {
00327         <span class="keywordflow">if</span> (order == LITTLE_ENDIAN_ORDER)
00328                 <span class="keywordflow">return</span> GETBYTE(value, index);
00329         <span class="keywordflow">else</span>
00330                 <span class="keywordflow">return</span> GETBYTE(value, <span class="keyword">sizeof</span>(T)-index-1);
00331 }
00332 
00333 <span class="keyword">inline</span> byte ByteReverse(byte value)
00334 {
00335         <span class="keywordflow">return</span> value;
00336 }
00337 
00338 <span class="keyword">inline</span> word16 ByteReverse(word16 value)
00339 {
00340         <span class="keywordflow">return</span> rotlFixed(value, 8U);
00341 }
00342 
00343 <span class="keyword">inline</span> word32 ByteReverse(word32 value)
00344 {
00345 <span class="preprocessor">#ifdef PPC_INTRINSICS</span>
00346 <span class="preprocessor"></span>        <span class="comment">// PPC: load reverse indexed instruction</span>
00347         <span class="keywordflow">return</span> (word32)__lwbrx(&amp;value,0);
00348 <span class="preprocessor">#elif defined(FAST_ROTATE)</span>
00349 <span class="preprocessor"></span>        <span class="comment">// 5 instructions with rotate instruction, 9 without</span>
00350         <span class="keywordflow">return</span> (rotrFixed(value, 8U) &amp; 0xff00ff00) | (rotlFixed(value, 8U) &amp; 0x00ff00ff);
00351 <span class="preprocessor">#else</span>
00352 <span class="preprocessor"></span>        <span class="comment">// 6 instructions with rotate instruction, 8 without</span>
00353         value = ((value &amp; 0xFF00FF00) &gt;&gt; 8) | ((value &amp; 0x00FF00FF) &lt;&lt; 8);
00354         <span class="keywordflow">return</span> rotlFixed(value, 16U);
00355 <span class="preprocessor">#endif</span>
00356 <span class="preprocessor"></span>}
00357 
00358 <span class="preprocessor">#ifdef WORD64_AVAILABLE</span>
00359 <span class="preprocessor"></span><span class="keyword">inline</span> word64 ByteReverse(word64 value)
00360 {
00361 <span class="preprocessor">#ifdef SLOW_WORD64</span>
00362 <span class="preprocessor"></span>        <span class="keywordflow">return</span> (word64(ByteReverse(word32(value))) &lt;&lt; 32) | ByteReverse(word32(value&gt;&gt;32));
00363 <span class="preprocessor">#else</span>
00364 <span class="preprocessor"></span>        value = ((value &amp; W64LIT(0xFF00FF00FF00FF00)) &gt;&gt; 8) | ((value &amp; W64LIT(0x00FF00FF00FF00FF)) &lt;&lt; 8);
00365         value = ((value &amp; W64LIT(0xFFFF0000FFFF0000)) &gt;&gt; 16) | ((value &amp; W64LIT(0x0000FFFF0000FFFF)) &lt;&lt; 16);
00366         <span class="keywordflow">return</span> rotlFixed(value, 32U);
00367 <span class="preprocessor">#endif</span>
00368 <span class="preprocessor"></span>}
00369 <span class="preprocessor">#endif</span>
00370 <span class="preprocessor"></span>
00371 <span class="keyword">inline</span> byte BitReverse(byte value)
00372 {
00373         value = ((value &amp; 0xAA) &gt;&gt; 1) | ((value &amp; 0x55) &lt;&lt; 1);
00374         value = ((value &amp; 0xCC) &gt;&gt; 2) | ((value &amp; 0x33) &lt;&lt; 2);
00375         <span class="keywordflow">return</span> rotlFixed(value, 4);
00376 }
00377 
00378 <span class="keyword">inline</span> word16 BitReverse(word16 value)
00379 {
00380         value = ((value &amp; 0xAAAA) &gt;&gt; 1) | ((value &amp; 0x5555) &lt;&lt; 1);
00381         value = ((value &amp; 0xCCCC) &gt;&gt; 2) | ((value &amp; 0x3333) &lt;&lt; 2);
00382         value = ((value &amp; 0xF0F0) &gt;&gt; 4) | ((value &amp; 0x0F0F) &lt;&lt; 4);
00383         <span class="keywordflow">return</span> ByteReverse(value);
00384 }
00385 
00386 <span class="keyword">inline</span> word32 BitReverse(word32 value)
00387 {
00388         value = ((value &amp; 0xAAAAAAAA) &gt;&gt; 1) | ((value &amp; 0x55555555) &lt;&lt; 1);
00389         value = ((value &amp; 0xCCCCCCCC) &gt;&gt; 2) | ((value &amp; 0x33333333) &lt;&lt; 2);
00390         value = ((value &amp; 0xF0F0F0F0) &gt;&gt; 4) | ((value &amp; 0x0F0F0F0F) &lt;&lt; 4);
00391         <span class="keywordflow">return</span> ByteReverse(value);
00392 }
00393 
00394 <span class="preprocessor">#ifdef WORD64_AVAILABLE</span>
00395 <span class="preprocessor"></span><span class="keyword">inline</span> word64 BitReverse(word64 value)
00396 {
00397 <span class="preprocessor">#ifdef SLOW_WORD64</span>
00398 <span class="preprocessor"></span>        <span class="keywordflow">return</span> (word64(BitReverse(word32(value))) &lt;&lt; 32) | BitReverse(word32(value&gt;&gt;32));
00399 <span class="preprocessor">#else</span>
00400 <span class="preprocessor"></span>        value = ((value &amp; W64LIT(0xAAAAAAAAAAAAAAAA)) &gt;&gt; 1) | ((value &amp; W64LIT(0x5555555555555555)) &lt;&lt; 1);
00401         value = ((value &amp; W64LIT(0xCCCCCCCCCCCCCCCC)) &gt;&gt; 2) | ((value &amp; W64LIT(0x3333333333333333)) &lt;&lt; 2);
00402         value = ((value &amp; W64LIT(0xF0F0F0F0F0F0F0F0)) &gt;&gt; 4) | ((value &amp; W64LIT(0x0F0F0F0F0F0F0F0F)) &lt;&lt; 4);
00403         <span class="keywordflow">return</span> ByteReverse(value);
00404 <span class="preprocessor">#endif</span>
00405 <span class="preprocessor"></span>}
00406 <span class="preprocessor">#endif</span>
00407 <span class="preprocessor"></span>
00408 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00409 <span class="keyword">inline</span> T BitReverse(T value)
00410 {
00411         <span class="keywordflow">if</span> (<span class="keyword">sizeof</span>(T) == 1)
00412                 <span class="keywordflow">return</span> (T)BitReverse((byte)value);
00413         <span class="keywordflow">else</span> <span class="keywordflow">if</span> (<span class="keyword">sizeof</span>(T) == 2)
00414                 <span class="keywordflow">return</span> (T)BitReverse((word16)value);
00415         <span class="keywordflow">else</span> <span class="keywordflow">if</span> (<span class="keyword">sizeof</span>(T) == 4)
00416                 <span class="keywordflow">return</span> (T)BitReverse((word32)value);
00417         <span class="keywordflow">else</span>
00418         {
00419 <span class="preprocessor">#ifdef WORD64_AVAILABLE</span>
00420 <span class="preprocessor"></span>                assert(<span class="keyword">sizeof</span>(T) == 8);
00421                 <span class="keywordflow">return</span> (T)BitReverse((word64)value);
00422 <span class="preprocessor">#else</span>
00423 <span class="preprocessor"></span>                assert(<span class="keyword">false</span>);
00424                 <span class="keywordflow">return</span> 0;
00425 <span class="preprocessor">#endif</span>
00426 <span class="preprocessor"></span>        }
00427 }
00428 
00429 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00430 <span class="keyword">inline</span> T ConditionalByteReverse(ByteOrder order, T value)
00431 {
00432         <span class="keywordflow">return</span> NativeByteOrderIs(order) ? value : ByteReverse(value);
00433 }
00434 
00435 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00436 <span class="keywordtype">void</span> ByteReverse(T *out, <span class="keyword">const</span> T *in, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> byteCount)
00437 {
00438         assert(byteCount % <span class="keyword">sizeof</span>(T) == 0);
00439         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count = byteCount/<span class="keyword">sizeof</span>(T);
00440         <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;count; i++)
00441                 out[i] = ByteReverse(in[i]);
00442 }
00443 
00444 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00445 <span class="keyword">inline</span> <span class="keywordtype">void</span> ConditionalByteReverse(ByteOrder order, T *out, <span class="keyword">const</span> T *in, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> byteCount)
00446 {
00447         <span class="keywordflow">if</span> (!NativeByteOrderIs(order))
00448                 ByteReverse(out, in, byteCount);
00449         <span class="keywordflow">else</span> <span class="keywordflow">if</span> (in != out)
00450                 memcpy(out, in, byteCount);
00451 }
00452 
00453 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00454 <span class="keyword">inline</span> <span class="keywordtype">void</span> GetUserKey(ByteOrder order, T *out, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> outlen, <span class="keyword">const</span> byte *in, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> inlen)
00455 {
00456         <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> U = <span class="keyword">sizeof</span>(T);
00457         assert(inlen &lt;= outlen*U);
00458         memcpy(out, in, inlen);
00459         memset((byte *)out+inlen, 0, outlen*U-inlen);
00460         ConditionalByteReverse(order, out, out, RoundUpToMultipleOf(inlen, U));
00461 }