Botan  1.10.9
Public Types | Public Member Functions | List of all members
Botan::AES_256_NI Class Reference

#include <aes_ni.h>

Inheritance diagram for Botan::AES_256_NI:
Botan::Block_Cipher_Fixed_Params< 16, 32 > Botan::BlockCipher Botan::SymmetricAlgorithm Botan::Algorithm

Public Types

enum  
 

Public Member Functions

 AES_256_NI ()
 
size_t block_size () const
 
void clear ()
 
BlockCipherclone () const
 
void decrypt (const byte in[], byte out[]) const
 
void decrypt (byte block[]) const
 
void decrypt_n (const byte in[], byte out[], size_t blocks) const
 
void encrypt (const byte in[], byte out[]) const
 
void encrypt (byte block[]) const
 
void encrypt_n (const byte in[], byte out[], size_t blocks) const
 
Key_Length_Specification key_spec () const
 
size_t maximum_keylength () const
 
size_t minimum_keylength () const
 
std::string name () const
 
size_t parallel_bytes () const
 
size_t parallelism () const
 
void set_key (const SymmetricKey &key)
 
void set_key (const byte key[], size_t length)
 
bool valid_keylength (size_t length) const
 

Detailed Description

AES-256 using AES-NI

Definition at line 62 of file aes_ni.h.

Member Enumeration Documentation

anonymous enum
inherited

Constructor & Destructor Documentation

Botan::AES_256_NI::AES_256_NI ( )
inline

Definition at line 74 of file aes_ni.h.

74 : EK(60), DK(60) { }

Member Function Documentation

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::block_size ( ) const
inlinevirtualinherited
Returns
block size of this algorithm

Implements Botan::BlockCipher.

Definition at line 108 of file block_cipher.h.

108 { return BS; }
void Botan::AES_256_NI::clear ( )
virtual

Zeroize internal state

Implements Botan::Algorithm.

Definition at line 773 of file aes_ni.cpp.

References Botan::zeroise().

774  {
775  zeroise(EK);
776  zeroise(DK);
777  }
void zeroise(MemoryRegion< T > &vec)
Definition: secmem.h:415
BlockCipher* Botan::AES_256_NI::clone ( ) const
inlinevirtual

Get a new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 72 of file aes_ni.h.

72 { return new AES_256_NI; }
void Botan::BlockCipher::decrypt ( const byte  in[],
byte  out[] 
) const
inlineinherited

Decrypt a block.

Parameters
inThe ciphertext block to be decypted as a byte array. Must be of length block_size().
outThe byte array designated to hold the decrypted block. Must be of length block_size().

Definition at line 57 of file block_cipher.h.

Referenced by Botan::DESX::decrypt_n().

58  { decrypt_n(in, out, 1); }
virtual void decrypt_n(const byte in[], byte out[], size_t blocks) const =0
void Botan::BlockCipher::decrypt ( byte  block[]) const
inlineinherited

Decrypt a block.

Parameters
blockthe ciphertext block to be decrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 74 of file block_cipher.h.

74 { decrypt_n(block, block, 1); }
virtual void decrypt_n(const byte in[], byte out[], size_t blocks) const =0
void Botan::AES_256_NI::decrypt_n ( const byte  in[],
byte  out[],
size_t  blocks 
) const
virtual

Decrypt one or more blocks

Parameters
inthe input buffer (multiple of block_size())
outthe output buffer (same size as in)
blocksthe number of blocks to process

Implements Botan::BlockCipher.

Definition at line 620 of file aes_ni.cpp.

References AES_DEC_4_LAST_ROUNDS, and AES_DEC_4_ROUNDS.

621  {
622  const __m128i* in_mm = (const __m128i*)in;
623  __m128i* out_mm = (__m128i*)out;
624 
625  const __m128i* key_mm = (const __m128i*)&DK[0];
626 
627  __m128i K0 = _mm_loadu_si128(key_mm);
628  __m128i K1 = _mm_loadu_si128(key_mm + 1);
629  __m128i K2 = _mm_loadu_si128(key_mm + 2);
630  __m128i K3 = _mm_loadu_si128(key_mm + 3);
631  __m128i K4 = _mm_loadu_si128(key_mm + 4);
632  __m128i K5 = _mm_loadu_si128(key_mm + 5);
633  __m128i K6 = _mm_loadu_si128(key_mm + 6);
634  __m128i K7 = _mm_loadu_si128(key_mm + 7);
635  __m128i K8 = _mm_loadu_si128(key_mm + 8);
636  __m128i K9 = _mm_loadu_si128(key_mm + 9);
637  __m128i K10 = _mm_loadu_si128(key_mm + 10);
638  __m128i K11 = _mm_loadu_si128(key_mm + 11);
639  __m128i K12 = _mm_loadu_si128(key_mm + 12);
640  __m128i K13 = _mm_loadu_si128(key_mm + 13);
641  __m128i K14 = _mm_loadu_si128(key_mm + 14);
642 
643  while(blocks >= 4)
644  {
645  __m128i B0 = _mm_loadu_si128(in_mm + 0);
646  __m128i B1 = _mm_loadu_si128(in_mm + 1);
647  __m128i B2 = _mm_loadu_si128(in_mm + 2);
648  __m128i B3 = _mm_loadu_si128(in_mm + 3);
649 
650  B0 = _mm_xor_si128(B0, K0);
651  B1 = _mm_xor_si128(B1, K0);
652  B2 = _mm_xor_si128(B2, K0);
653  B3 = _mm_xor_si128(B3, K0);
654 
655  AES_DEC_4_ROUNDS(K1);
656  AES_DEC_4_ROUNDS(K2);
657  AES_DEC_4_ROUNDS(K3);
658  AES_DEC_4_ROUNDS(K4);
659  AES_DEC_4_ROUNDS(K5);
660  AES_DEC_4_ROUNDS(K6);
661  AES_DEC_4_ROUNDS(K7);
662  AES_DEC_4_ROUNDS(K8);
663  AES_DEC_4_ROUNDS(K9);
664  AES_DEC_4_ROUNDS(K10);
665  AES_DEC_4_ROUNDS(K11);
666  AES_DEC_4_ROUNDS(K12);
667  AES_DEC_4_ROUNDS(K13);
669 
670  _mm_storeu_si128(out_mm + 0, B0);
671  _mm_storeu_si128(out_mm + 1, B1);
672  _mm_storeu_si128(out_mm + 2, B2);
673  _mm_storeu_si128(out_mm + 3, B3);
674 
675  blocks -= 4;
676  in_mm += 4;
677  out_mm += 4;
678  }
679 
680  for(size_t i = 0; i != blocks; ++i)
681  {
682  __m128i B = _mm_loadu_si128(in_mm + i);
683 
684  B = _mm_xor_si128(B, K0);
685 
686  B = _mm_aesdec_si128(B, K1);
687  B = _mm_aesdec_si128(B, K2);
688  B = _mm_aesdec_si128(B, K3);
689  B = _mm_aesdec_si128(B, K4);
690  B = _mm_aesdec_si128(B, K5);
691  B = _mm_aesdec_si128(B, K6);
692  B = _mm_aesdec_si128(B, K7);
693  B = _mm_aesdec_si128(B, K8);
694  B = _mm_aesdec_si128(B, K9);
695  B = _mm_aesdec_si128(B, K10);
696  B = _mm_aesdec_si128(B, K11);
697  B = _mm_aesdec_si128(B, K12);
698  B = _mm_aesdec_si128(B, K13);
699  B = _mm_aesdeclast_si128(B, K14);
700 
701  _mm_storeu_si128(out_mm + i, B);
702  }
703  }
#define AES_DEC_4_LAST_ROUNDS(K)
Definition: aes_ni.cpp:94
#define AES_DEC_4_ROUNDS(K)
Definition: aes_ni.cpp:85
void Botan::BlockCipher::encrypt ( const byte  in[],
byte  out[] 
) const
inlineinherited

Encrypt a block.

Parameters
inThe plaintext block to be encrypted as a byte array. Must be of length block_size().
outThe byte array designated to hold the encrypted block. Must be of length block_size().

Definition at line 47 of file block_cipher.h.

Referenced by Botan::aont_package(), Botan::aont_unpackage(), Botan::OFB::cipher(), Botan::DESX::encrypt_n(), Botan::CFB_Encryption::set_iv(), Botan::OFB::set_iv(), Botan::XTS_Encryption::set_iv(), Botan::CFB_Decryption::set_iv(), and Botan::XTS_Decryption::set_iv().

48  { encrypt_n(in, out, 1); }
virtual void encrypt_n(const byte in[], byte out[], size_t blocks) const =0
void Botan::BlockCipher::encrypt ( byte  block[]) const
inlineinherited

Encrypt a block.

Parameters
blockthe plaintext block to be encrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 66 of file block_cipher.h.

66 { encrypt_n(block, block, 1); }
virtual void encrypt_n(const byte in[], byte out[], size_t blocks) const =0
void Botan::AES_256_NI::encrypt_n ( const byte  in[],
byte  out[],
size_t  blocks 
) const
virtual

Encrypt one or more blocks

Parameters
inthe input buffer (multiple of block_size())
outthe output buffer (same size as in)
blocksthe number of blocks to process

Implements Botan::BlockCipher.

Definition at line 532 of file aes_ni.cpp.

References AES_ENC_4_LAST_ROUNDS, and AES_ENC_4_ROUNDS.

533  {
534  const __m128i* in_mm = (const __m128i*)in;
535  __m128i* out_mm = (__m128i*)out;
536 
537  const __m128i* key_mm = (const __m128i*)&EK[0];
538 
539  __m128i K0 = _mm_loadu_si128(key_mm);
540  __m128i K1 = _mm_loadu_si128(key_mm + 1);
541  __m128i K2 = _mm_loadu_si128(key_mm + 2);
542  __m128i K3 = _mm_loadu_si128(key_mm + 3);
543  __m128i K4 = _mm_loadu_si128(key_mm + 4);
544  __m128i K5 = _mm_loadu_si128(key_mm + 5);
545  __m128i K6 = _mm_loadu_si128(key_mm + 6);
546  __m128i K7 = _mm_loadu_si128(key_mm + 7);
547  __m128i K8 = _mm_loadu_si128(key_mm + 8);
548  __m128i K9 = _mm_loadu_si128(key_mm + 9);
549  __m128i K10 = _mm_loadu_si128(key_mm + 10);
550  __m128i K11 = _mm_loadu_si128(key_mm + 11);
551  __m128i K12 = _mm_loadu_si128(key_mm + 12);
552  __m128i K13 = _mm_loadu_si128(key_mm + 13);
553  __m128i K14 = _mm_loadu_si128(key_mm + 14);
554 
555  while(blocks >= 4)
556  {
557  __m128i B0 = _mm_loadu_si128(in_mm + 0);
558  __m128i B1 = _mm_loadu_si128(in_mm + 1);
559  __m128i B2 = _mm_loadu_si128(in_mm + 2);
560  __m128i B3 = _mm_loadu_si128(in_mm + 3);
561 
562  B0 = _mm_xor_si128(B0, K0);
563  B1 = _mm_xor_si128(B1, K0);
564  B2 = _mm_xor_si128(B2, K0);
565  B3 = _mm_xor_si128(B3, K0);
566 
567  AES_ENC_4_ROUNDS(K1);
568  AES_ENC_4_ROUNDS(K2);
569  AES_ENC_4_ROUNDS(K3);
570  AES_ENC_4_ROUNDS(K4);
571  AES_ENC_4_ROUNDS(K5);
572  AES_ENC_4_ROUNDS(K6);
573  AES_ENC_4_ROUNDS(K7);
574  AES_ENC_4_ROUNDS(K8);
575  AES_ENC_4_ROUNDS(K9);
576  AES_ENC_4_ROUNDS(K10);
577  AES_ENC_4_ROUNDS(K11);
578  AES_ENC_4_ROUNDS(K12);
579  AES_ENC_4_ROUNDS(K13);
581 
582  _mm_storeu_si128(out_mm + 0, B0);
583  _mm_storeu_si128(out_mm + 1, B1);
584  _mm_storeu_si128(out_mm + 2, B2);
585  _mm_storeu_si128(out_mm + 3, B3);
586 
587  blocks -= 4;
588  in_mm += 4;
589  out_mm += 4;
590  }
591 
592  for(size_t i = 0; i != blocks; ++i)
593  {
594  __m128i B = _mm_loadu_si128(in_mm + i);
595 
596  B = _mm_xor_si128(B, K0);
597 
598  B = _mm_aesenc_si128(B, K1);
599  B = _mm_aesenc_si128(B, K2);
600  B = _mm_aesenc_si128(B, K3);
601  B = _mm_aesenc_si128(B, K4);
602  B = _mm_aesenc_si128(B, K5);
603  B = _mm_aesenc_si128(B, K6);
604  B = _mm_aesenc_si128(B, K7);
605  B = _mm_aesenc_si128(B, K8);
606  B = _mm_aesenc_si128(B, K9);
607  B = _mm_aesenc_si128(B, K10);
608  B = _mm_aesenc_si128(B, K11);
609  B = _mm_aesenc_si128(B, K12);
610  B = _mm_aesenc_si128(B, K13);
611  B = _mm_aesenclast_si128(B, K14);
612 
613  _mm_storeu_si128(out_mm + i, B);
614  }
615  }
#define AES_ENC_4_ROUNDS(K)
Definition: aes_ni.cpp:67
#define AES_ENC_4_LAST_ROUNDS(K)
Definition: aes_ni.cpp:76
Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::key_spec ( ) const
inlinevirtualinherited
Returns
object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 110 of file block_cipher.h.

111  {
112  return Key_Length_Specification(KMIN, KMAX, KMOD);
113  }
size_t Botan::SymmetricAlgorithm::maximum_keylength ( ) const
inlineinherited
Returns
minimum allowed key length

Definition at line 33 of file sym_algo.h.

34  {
35  return key_spec().maximum_keylength();
36  }
size_t maximum_keylength() const
Definition: key_spec.h:69
virtual Key_Length_Specification key_spec() const =0
size_t Botan::SymmetricAlgorithm::minimum_keylength ( ) const
inlineinherited
Returns
maxmium allowed key length

Definition at line 41 of file sym_algo.h.

42  {
43  return key_spec().minimum_keylength();
44  }
size_t minimum_keylength() const
Definition: key_spec.h:61
virtual Key_Length_Specification key_spec() const =0
std::string Botan::AES_256_NI::name ( ) const
inlinevirtual
Returns
name of this algorithm

Implements Botan::Algorithm.

Definition at line 71 of file aes_ni.h.

71 { return "AES-256"; }
size_t Botan::BlockCipher::parallel_bytes ( ) const
inlineinherited
Returns
prefererred parallelism of this cipher in bytes

Definition at line 35 of file block_cipher.h.

References block_size.

36  {
37  return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
38  }
virtual size_t parallelism() const
Definition: block_cipher.h:30
virtual size_t block_size() const =0
size_t Botan::AES_256_NI::parallelism ( ) const
inlinevirtual
Returns
native parallelism of this cipher in blocks

Reimplemented from Botan::BlockCipher.

Definition at line 65 of file aes_ni.h.

65 { return 4; }
void Botan::SymmetricAlgorithm::set_key ( const SymmetricKey key)
inlineinherited
void Botan::SymmetricAlgorithm::set_key ( const byte  key[],
size_t  length 
)
inlineinherited

Set the symmetric key of this object.

Parameters
keythe to be set as a byte array.
lengthin bytes of key param

Definition at line 68 of file sym_algo.h.

69  {
70  if(!valid_keylength(length))
71  throw Invalid_Key_Length(name(), length);
72  key_schedule(key, length);
73  }
bool valid_keylength(size_t length) const
Definition: sym_algo.h:51
virtual std::string name() const =0
bool Botan::SymmetricAlgorithm::valid_keylength ( size_t  length) const
inlineinherited

Check whether a given key length is valid for this algorithm.

Parameters
lengththe key length to be checked.
Returns
true if the key length is valid.

Definition at line 51 of file sym_algo.h.

Referenced by Botan::aont_package(), Botan::aont_unpackage(), Botan::HMAC_RNG::HMAC_RNG(), Botan::Lion::Lion(), Botan::Randpool::Randpool(), and Botan::EAX_Base::valid_keylength().

52  {
53  return key_spec().valid_keylength(length);
54  }
bool valid_keylength(size_t length) const
Definition: key_spec.h:51
virtual Key_Length_Specification key_spec() const =0

The documentation for this class was generated from the following files: