1 files changed, 165 insertions, 0 deletions

diff --git a/all_pairs/source/rijndael_enc/aes.h b/all_pairs/source/rijndael_enc/aes.h
new file mode 100644
index 0000000..908f95f
--- /dev/null
+++ b/all_pairs/source/rijndael_enc/aes.h
@@ -0,0 +1,165 @@
+/*
+  -----------------------------------------------------------------------
+  Copyright (c) 2001 Dr Brian Gladman <brg@gladman.uk.net>, Worcester, UK
+
+  TERMS
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  This software is provided 'as is' with no guarantees of correctness or
+  fitness for purpose.
+  -----------------------------------------------------------------------
+
+  1. FUNCTION
+
+  The AES algorithm Rijndael implemented for block and key sizes of
+  128 bits (16 bytes) by Brian Gladman.
+
+  This is an implementation of the AES encryption algorithm (Rijndael)
+  designed by Joan Daemen and Vincent Rijmen.
+
+  2. THE CIPHER INTERFACE
+
+  byte                    (an unsigned 8-bit type)
+  word                    (an unsigned 32-bit type)
+  aes_ret:                (a signed 16 bit type for function return values)
+       aes_good            (value != 0, a good return)
+       aes_bad             (value == 0, an error return)
+  enum aes_key:           (encryption direction)
+       enc                 (set key for encryption)
+       dec                 (set key for decryption)
+       both                (set key for both)
+  class or struct aes     (structure for context)
+
+  C subroutine calls:
+
+  aes_ret set_blk(const word block_length, aes *cx)  (variable block size)
+  aes_ret set_key(const byte key[], const word key_length,
+                  const enum aes_key direction, aes *cx)
+  aes_ret encrypt(const byte input_blk[], byte output_blk[], const aes *cx)
+  aes_ret decrypt(const byte input_blk[], byte output_blk[], const aes *cx)
+
+  IMPORTANT NOTE: If you are using this C interface and your compiler does
+  not set the memory used for objects to zero before use, you will need to
+  ensure that cx.mode is set to zero before using the C subroutine calls.
+
+  The block length inputs to set_block and set_key are in numbers of
+  BYTES, not bits.  The calls to subroutines must be made in the above
+  order but multiple calls can be made without repeating earlier calls
+  if their parameters have not changed. If the cipher block length is
+  variable but set_blk has not been called before cipher operations a
+  value of 16 is assumed (that is, the AES block size). In contrast to
+  earlier versions the block and key length parameters are now checked
+  for correctness and the encryption and decryption routines check to
+  ensure that an appropriate key has been set before they are called.
+
+*/
+
+#ifndef _AES_H
+#define _AES_H
+
+/* The only supported block size for the benchmark is 16 */
+#define BLOCK_SIZE  16
+
+/*
+  The number of key schedule words for different block and key lengths
+  (allowing for the method of computation which requires the length to
+  be a multiple of the key length):
+
+  Key Schedule    key length (bytes)
+  Length          16  20  24  28  32
+               ---------------------
+  block     16 |  44  60  54  56  64
+  length    20 |  60  60  66  70  80
+  (bytes)   24 |  80  80  78  84  96
+            28 | 100 100 102  98 112
+            32 | 120 120 120 126 120
+
+  Rcon Table      key length (bytes)
+  Length          16  20  24  28  32
+               ---------------------
+  block     16 |  10   9   8   7   7
+  length    20 |  14  11  10   9   9
+  (bytes)   24 |  19  15  12  11  11
+            28 |  24  19  16  13  13
+            32 |  29  23  19  17  14
+
+  The following values assume that the key length will be variable and may
+  be of maximum length (32 bytes).
+
+  Nk = number_of_key_bytes / 4
+  Nc = number_of_columns_in_state / 4
+  Nr = number of encryption/decryption rounds
+  Rc = number of elements in rcon table
+  Ks = number of 32-bit words in key schedule
+*/
+
+#define Nr(Nk,Nc)   ((Nk > Nc ? Nk : Nc) + 6)
+#define Rc(Nk,Nc)   ((Nb * (Nr(Nk,Nc) + 1) - 1) / Nk)
+#define Ks(Nk,Nc)   (Nk * (Rc(Nk,Nc) + 1))
+
+#define RC_LENGTH   5 * BLOCK_SIZE / 4 - (BLOCK_SIZE == 16 ? 10 : 11)
+#define KS_LENGTH   4 * BLOCK_SIZE
+
+/* End of configuration options, but see also aes.c */
+
+typedef unsigned char   byte;           /* must be an 8-bit storage unit */
+typedef unsigned long   word;           /* must be a 32-bit storage unit */
+typedef short           aes_ret;        /* function return value         */
+
+#define aes_bad     0
+#define aes_good    1
+
+/*
+  upr(x,n): rotates bytes within words by n positions, moving bytes
+  to higher index positions with wrap around into low positions
+  ups(x,n): moves bytes by n positions to higher index positions in
+  words but without wrap around
+  bval(x,n): extracts a byte from a word
+*/
+
+#define upr(x,n)        (((x) << 8 * (n)) | ((x) >> (32 - 8 * (n))))
+#define ups(x,n)        ((x) << 8 * (n))
+#define bval(x,n)       ((byte)((x) >> 8 * (n)))
+#define byte_swap(x)    (upr(x,1) & 0x00ff00ff | upr(x,3) & 0xff00ff00)
+#define bytes2word(b0, b1, b2, b3) ((word)(b3) << 24 | (word)(b2) << 16 | \
+                                    (word)(b1) << 8 | (b0))
+
+#define word_in(x)      *(word*)(x)
+#define word_out(x,v)   *(word*)(x) = (v)
+
+enum aes_const  {   Nrow =  4,  /* the number of rows in the cipher state       */
+                    Mcol =  8,  /* maximum number of columns in the state       */
+                    Ncol =  BLOCK_SIZE / 4,
+                    Shr0 =  0,  /* the cyclic shift values for rows 0, 1, 2 & 3 */
+                    Shr1 =  1,
+                    Shr2 =  BLOCK_SIZE == 32 ? 3 : 2,
+                    Shr3 =  BLOCK_SIZE == 32 ? 4 : 3
+                };
+
+enum aes_key    {   enc  =  1,  /* set if encryption is needed */
+                    dec  =  2,  /* set if decryption is needed */
+                    both =  3   /* set if both are needed      */
+                };
+
+struct aes {
+  word    Nkey;               /* the number of words in the key input block */
+  word    Nrnd;               /* the number of cipher rounds                */
+  word    e_key[KS_LENGTH];   /* the encryption key schedule                */
+  word    d_key[KS_LENGTH];   /* the decryption key schedule                */
+  byte    mode;               /* encrypt, decrypt or both                   */
+};
+
+aes_ret rijndael_enc_set_key( byte key[], const word n_bytes,
+                              const enum aes_key f, struct aes *cx );
+aes_ret rijndael_enc_encrypt( byte in_blk[], byte out_blk[],
+                              const struct aes *cx );
+
+#endif