#include <botan/serp_simd.h>
#include <botan/internal/simd_32.h>
#include <botan/loadstor.h>
Go to the source code of this file.
|  | 
| #define | i_transform(B0,  B1,  B2,  B3) | 
|  | 
| #define | key_xor(round,  B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD1(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD2(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD3(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD4(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD5(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD6(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD7(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxD8(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE1(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE2(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE3(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE4(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE5(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE6(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE7(B0,  B1,  B2,  B3) | 
|  | 
| #define | SBoxE8(B0,  B1,  B2,  B3) | 
|  | 
| #define | transform(B0,  B1,  B2,  B3) | 
|  | 
◆ i_transform
      
        
          | #define i_transform | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                                            \
      B2.rotate_right(22);                                         \
      B0.rotate_right(5);                                          \
      B2 ^= B3 ^ (B1 << 7);                                        \
      B0 ^= B1 ^ B3;                                               \
      B3.rotate_right(7);                                          \
      B1.rotate_right(1);                                          \
      B3 ^= B2 ^ (B0 << 3);                                        \
      B1 ^= B0 ^ B2;                                               \
      B2.rotate_right(3);                                          \
      B0.rotate_right(13);                                         \
   } while(0);
Definition at line 455 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ key_xor
      
        
          | #define key_xor | ( |  | round, | 
        
          |  |  |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                                            \
      B0 ^= SIMD_32(keys[4*round  ]);                              \
      B1 ^= SIMD_32(keys[4*round+1]);                              \
      B2 ^= SIMD_32(keys[4*round+2]);                              \
      B3 ^= SIMD_32(keys[4*round+3]);                              \
   } while(0);
Definition at line 430 of file serp_simd.cpp.
 
 
◆ SBoxD1
      
        
          | #define SBoxD1 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B2 = ~B2;                                   \
      SIMD_32 B4 = B1;                            \
      B1 |= B0;                                   \
      B4 = ~B4;                                   \
      B1 ^= B2;                                   \
      B2 |= B4;                                   \
      B1 ^= B3;                                   \
      B0 ^= B4;                                   \
      B2 ^= B0;                                   \
      B0 &= B3;                                   \
      B4 ^= B0;                                   \
      B0 |= B1;                                   \
      B0 ^= B2;                                   \
      B3 ^= B4;                                   \
      B2 ^= B1;                                   \
      B3 ^= B0;                                   \
      B3 ^= B1;                                   \
      B2 &= B3;                                   \
      B4 ^= B2;                                   \
      B2 = B1;                                    \
      B1 = B4;                                    \
      } while(0);
Definition at line 221 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD2
      
        
          | #define SBoxD2 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B1;                            \
      B1 ^= B3;                                   \
      B3 &= B1;                                   \
      B4 ^= B2;                                   \
      B3 ^= B0;                                   \
      B0 |= B1;                                   \
      B2 ^= B3;                                   \
      B0 ^= B4;                                   \
      B0 |= B2;                                   \
      B1 ^= B3;                                   \
      B0 ^= B1;                                   \
      B1 |= B3;                                   \
      B1 ^= B0;                                   \
      B4 = ~B4;                                   \
      B4 ^= B1;                                   \
      B1 |= B0;                                   \
      B1 ^= B0;                                   \
      B1 |= B4;                                   \
      B3 ^= B1;                                   \
      B1 = B0;                                    \
      B0 = B4;                                    \
      B4 = B2;                                    \
      B2 = B3;                                    \
      B3 = B4;                                    \
      } while(0);
Definition at line 246 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD3
      
        
          | #define SBoxD3 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B2 ^= B3;                                   \
      B3 ^= B0;                                   \
      SIMD_32 B4 = B3;                            \
      B3 &= B2;                                   \
      B3 ^= B1;                                   \
      B1 |= B2;                                   \
      B1 ^= B4;                                   \
      B4 &= B3;                                   \
      B2 ^= B3;                                   \
      B4 &= B0;                                   \
      B4 ^= B2;                                   \
      B2 &= B1;                                   \
      B2 |= B0;                                   \
      B3 = ~B3;                                   \
      B2 ^= B3;                                   \
      B0 ^= B3;                                   \
      B0 &= B1;                                   \
      B3 ^= B4;                                   \
      B3 ^= B0;                                   \
      B0 = B1;                                    \
      B1 = B4;                                    \
      } while(0);
Definition at line 274 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD4
      
        
          | #define SBoxD4 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B2;                            \
      B2 ^= B1;                                   \
      B0 ^= B2;                                   \
      B4 &= B2;                                   \
      B4 ^= B0;                                   \
      B0 &= B1;                                   \
      B1 ^= B3;                                   \
      B3 |= B4;                                   \
      B2 ^= B3;                                   \
      B0 ^= B3;                                   \
      B1 ^= B4;                                   \
      B3 &= B2;                                   \
      B3 ^= B1;                                   \
      B1 ^= B0;                                   \
      B1 |= B2;                                   \
      B0 ^= B3;                                   \
      B1 ^= B4;                                   \
      B0 ^= B1;                                   \
      B4 = B0;                                    \
      B0 = B2;                                    \
      B2 = B3;                                    \
      B3 = B4;                                    \
      } while(0);
Definition at line 299 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD5
      
        
          | #define SBoxD5 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B2;                            \
      B2 &= B3;                                   \
      B2 ^= B1;                                   \
      B1 |= B3;                                   \
      B1 &= B0;                                   \
      B4 ^= B2;                                   \
      B4 ^= B1;                                   \
      B1 &= B2;                                   \
      B0 = ~B0;                                   \
      B3 ^= B4;                                   \
      B1 ^= B3;                                   \
      B3 &= B0;                                   \
      B3 ^= B2;                                   \
      B0 ^= B1;                                   \
      B2 &= B0;                                   \
      B3 ^= B0;                                   \
      B2 ^= B4;                                   \
      B2 |= B3;                                   \
      B3 ^= B0;                                   \
      B2 ^= B1;                                   \
      B1 = B3;                                    \
      B3 = B4;                                    \
      } while(0);
Definition at line 325 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD6
      
        
          | #define SBoxD6 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B1 = ~B1;                                   \
      SIMD_32 B4 = B3;                            \
      B2 ^= B1;                                   \
      B3 |= B0;                                   \
      B3 ^= B2;                                   \
      B2 |= B1;                                   \
      B2 &= B0;                                   \
      B4 ^= B3;                                   \
      B2 ^= B4;                                   \
      B4 |= B0;                                   \
      B4 ^= B1;                                   \
      B1 &= B2;                                   \
      B1 ^= B3;                                   \
      B4 ^= B2;                                   \
      B3 &= B4;                                   \
      B4 ^= B1;                                   \
      B3 ^= B4;                                   \
      B4 = ~B4;                                   \
      B3 ^= B0;                                   \
      B0 = B1;                                    \
      B1 = B4;                                    \
      B4 = B3;                                    \
      B3 = B2;                                    \
      B2 = B4;                                    \
      } while(0);
Definition at line 351 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD7
      
        
          | #define SBoxD7 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B0 ^= B2;                                   \
      SIMD_32 B4 = B2;                            \
      B2 &= B0;                                   \
      B4 ^= B3;                                   \
      B2 = ~B2;                                   \
      B3 ^= B1;                                   \
      B2 ^= B3;                                   \
      B4 |= B0;                                   \
      B0 ^= B2;                                   \
      B3 ^= B4;                                   \
      B4 ^= B1;                                   \
      B1 &= B3;                                   \
      B1 ^= B0;                                   \
      B0 ^= B3;                                   \
      B0 |= B2;                                   \
      B3 ^= B1;                                   \
      B4 ^= B0;                                   \
      B0 = B1;                                    \
      B1 = B2;                                    \
      B2 = B4;                                    \
      } while(0);
Definition at line 379 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxD8
      
        
          | #define SBoxD8 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B2;                            \
      B2 ^= B0;                                   \
      B0 &= B3;                                   \
      B4 |= B3;                                   \
      B2 = ~B2;                                   \
      B3 ^= B1;                                   \
      B1 |= B0;                                   \
      B0 ^= B2;                                   \
      B2 &= B4;                                   \
      B3 &= B4;                                   \
      B1 ^= B2;                                   \
      B2 ^= B0;                                   \
      B0 |= B2;                                   \
      B4 ^= B1;                                   \
      B0 ^= B3;                                   \
      B3 ^= B4;                                   \
      B4 |= B0;                                   \
      B3 ^= B2;                                   \
      B4 ^= B2;                                   \
      B2 = B1;                                    \
      B1 = B0;                                    \
      B0 = B3;                                    \
      B3 = B4;                                    \
      } while(0);
Definition at line 403 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n().
 
 
◆ SBoxE1
      
        
          | #define SBoxE1 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B3 ^= B0;                                   \
      SIMD_32 B4 = B1;                            \
      B1 &= B3;                                   \
      B4 ^= B2;                                   \
      B1 ^= B0;                                   \
      B0 |= B3;                                   \
      B0 ^= B4;                                   \
      B4 ^= B3;                                   \
      B3 ^= B2;                                   \
      B2 |= B1;                                   \
      B2 ^= B4;                                   \
      B4 = ~B4;                                   \
      B4 |= B1;                                   \
      B1 ^= B3;                                   \
      B1 ^= B4;                                   \
      B3 |= B0;                                   \
      B1 ^= B3;                                   \
      B4 ^= B3;                                   \
      B3 = B0;                                    \
      B0 = B1;                                    \
      B1 = B4;                                    \
   } while(0);
Definition at line 16 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE2
      
        
          | #define SBoxE2 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B0 = ~B0;                                   \
      B2 = ~B2;                                   \
      SIMD_32 B4 = B0;                            \
      B0 &= B1;                                   \
      B2 ^= B0;                                   \
      B0 |= B3;                                   \
      B3 ^= B2;                                   \
      B1 ^= B0;                                   \
      B0 ^= B4;                                   \
      B4 |= B1;                                   \
      B1 ^= B3;                                   \
      B2 |= B0;                                   \
      B2 &= B4;                                   \
      B0 ^= B1;                                   \
      B1 &= B2;                                   \
      B1 ^= B0;                                   \
      B0 &= B2;                                   \
      B4 ^= B0;                                   \
      B0 = B2;                                    \
      B2 = B3;                                    \
      B3 = B1;                                    \
      B1 = B4;                                    \
   } while(0);
Definition at line 41 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE3
      
        
          | #define SBoxE3 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B0;                            \
      B0 &= B2;                                   \
      B0 ^= B3;                                   \
      B2 ^= B1;                                   \
      B2 ^= B0;                                   \
      B3 |= B4;                                   \
      B3 ^= B1;                                   \
      B4 ^= B2;                                   \
      B1 = B3;                                    \
      B3 |= B4;                                   \
      B3 ^= B0;                                   \
      B0 &= B1;                                   \
      B4 ^= B0;                                   \
      B1 ^= B3;                                   \
      B1 ^= B4;                                   \
      B0 = B2;                                    \
      B2 = B1;                                    \
      B1 = B3;                                    \
      B3 = ~B4;                                   \
   } while(0);
Definition at line 67 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE4
      
        
          | #define SBoxE4 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B0;                            \
      B0 |= B3;                                   \
      B3 ^= B1;                                   \
      B1 &= B4;                                   \
      B4 ^= B2;                                   \
      B2 ^= B3;                                   \
      B3 &= B0;                                   \
      B4 |= B1;                                   \
      B3 ^= B4;                                   \
      B0 ^= B1;                                   \
      B4 &= B0;                                   \
      B1 ^= B3;                                   \
      B4 ^= B2;                                   \
      B1 |= B0;                                   \
      B1 ^= B2;                                   \
      B0 ^= B3;                                   \
      B2 = B1;                                    \
      B1 |= B3;                                   \
      B0 ^= B1;                                   \
      B1 = B2;                                    \
      B2 = B3;                                    \
      B3 = B4;                                    \
   } while(0);
Definition at line 90 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE5
      
        
          | #define SBoxE5 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B1 ^= B3;                                   \
      B3 = ~B3;                                   \
      B2 ^= B3;                                   \
      B3 ^= B0;                                   \
      SIMD_32 B4 = B1;                            \
      B1 &= B3;                                   \
      B1 ^= B2;                                   \
      B4 ^= B3;                                   \
      B0 ^= B4;                                   \
      B2 &= B4;                                   \
      B2 ^= B0;                                   \
      B0 &= B1;                                   \
      B3 ^= B0;                                   \
      B4 |= B1;                                   \
      B4 ^= B0;                                   \
      B0 |= B3;                                   \
      B0 ^= B2;                                   \
      B2 &= B3;                                   \
      B0 = ~B0;                                   \
      B4 ^= B2;                                   \
      B2 = B0;                                    \
      B0 = B1;                                    \
      B1 = B4;                                    \
   } while(0);
Definition at line 116 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE6
      
        
          | #define SBoxE6 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B0 ^= B1;                                   \
      B1 ^= B3;                                   \
      B3 = ~B3;                                   \
      SIMD_32 B4 = B1;                            \
      B1 &= B0;                                   \
      B2 ^= B3;                                   \
      B1 ^= B2;                                   \
      B2 |= B4;                                   \
      B4 ^= B3;                                   \
      B3 &= B1;                                   \
      B3 ^= B0;                                   \
      B4 ^= B1;                                   \
      B4 ^= B2;                                   \
      B2 ^= B0;                                   \
      B0 &= B3;                                   \
      B2 = ~B2;                                   \
      B0 ^= B4;                                   \
      B4 |= B3;                                   \
      B4 ^= B2;                                   \
      B2 = B0;                                    \
      B0 = B1;                                    \
      B1 = B3;                                    \
      B3 = B4;                                    \
   } while(0);
Definition at line 143 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE7
      
        
          | #define SBoxE7 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      B2 = ~B2;                                   \
      SIMD_32 B4 = B3;                            \
      B3 &= B0;                                   \
      B0 ^= B4;                                   \
      B3 ^= B2;                                   \
      B2 |= B4;                                   \
      B1 ^= B3;                                   \
      B2 ^= B0;                                   \
      B0 |= B1;                                   \
      B2 ^= B1;                                   \
      B4 ^= B0;                                   \
      B0 |= B3;                                   \
      B0 ^= B2;                                   \
      B4 ^= B3;                                   \
      B4 ^= B0;                                   \
      B3 = ~B3;                                   \
      B2 &= B4;                                   \
      B3 ^= B2;                                   \
      B2 = B4;                                    \
   } while(0);
Definition at line 170 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ SBoxE8
      
        
          | #define SBoxE8 | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                           \
      SIMD_32 B4 = B1;                            \
      B1 |= B2;                                   \
      B1 ^= B3;                                   \
      B4 ^= B2;                                   \
      B2 ^= B1;                                   \
      B3 |= B4;                                   \
      B3 &= B0;                                   \
      B4 ^= B2;                                   \
      B3 ^= B1;                                   \
      B1 |= B4;                                   \
      B1 ^= B0;                                   \
      B0 |= B4;                                   \
      B0 ^= B2;                                   \
      B1 ^= B4;                                   \
      B2 ^= B1;                                   \
      B1 &= B0;                                   \
      B1 ^= B4;                                   \
      B2 = ~B2;                                   \
      B2 |= B0;                                   \
      B4 ^= B2;                                   \
      B2 = B1;                                    \
      B1 = B3;                                    \
      B3 = B0;                                    \
      B0 = B4;                                    \
   } while(0);
Definition at line 193 of file serp_simd.cpp.
Referenced by Botan::Serpent::decrypt_n(), and Botan::Serpent::encrypt_n().
 
 
◆ transform
      
        
          | #define transform | ( |  | B0, | 
        
          |  |  |  | B1, | 
        
          |  |  |  | B2, | 
        
          |  |  |  | B3 | 
        
          |  | ) |  |  | 
      
 
Value:do {                                                            \
      B0.rotate_left(13);                                          \
      B2.rotate_left(3);                                           \
      B1 ^= B0 ^ B2;                                               \
      B3 ^= B2 ^ (B0 << 3);                                        \
      B1.rotate_left(1);                                           \
      B3.rotate_left(7);                                           \
      B0 ^= B1 ^ B3;                                               \
      B2 ^= B3 ^ (B1 << 7);                                        \
      B0.rotate_left(5);                                           \
      B2.rotate_left(22);                                          \
   } while(0);
Definition at line 441 of file serp_simd.cpp.
Referenced by Botan::Serpent::encrypt_n(), and Botan::Square::Square().