A lot of cleanups as well as minor API changes.
[libgcrypt.git] / cipher / serpent.c
index f3fe2a5..6b7e655 100644 (file)
@@ -1,5 +1,5 @@
 /* serpent.c - Implementation of the Serpent encryption algorithm.
- *     Copyright (C) 2003 Free Software Foundation, Inc.
+ *     Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
 /* Magic number, used during generating of the subkeys.  */
 #define PHI 0x9E3779B9
 
-/* Internal types.  */
-typedef byte byte_t;
-typedef u32 u32_t;
-
 /* Serpent works on 128 bit blocks.  */
-typedef u32_t serpent_block_t[4];
+typedef u32 serpent_block_t[4];
 
 /* Serpent key, provided by the user.  If the original key is shorter
    than 256 bits, it is padded.  */
-typedef u32_t serpent_key_t[8];
+typedef u32 serpent_key_t[8];
 
 /* The key schedule consists of 33 128 bit subkeys.  */
-typedef u32_t serpent_subkeys_t[ROUNDS + 1][4];
+typedef u32 serpent_subkeys_t[ROUNDS + 1][4];
 
 /* A Serpent context.  */
 typedef struct serpent_context
@@ -55,10 +51,15 @@ typedef struct serpent_context
   serpent_subkeys_t keys;      /* Generated subkeys.  */
 } serpent_context_t;
 
+
+/* A prototype.  */
+static const char *serpent_test (void);
+      
+
 #define byte_swap_32(x) \
   (0 \
    | (((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) \
-   | (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24));
+   | (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
 
 /* These are the S-Boxes of Serpent.  They are copied from Serpents
    reference implementation (the optimized one, contained in
@@ -78,8 +79,8 @@ typedef struct serpent_context
 
 #define SBOX0(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t05, t06, t07, t08, t09; \
-    register unsigned long t11, t12, t13, t14, t15, t17, t01; \
+    u32 t02, t03, t05, t06, t07, t08, t09; \
+    u32 t11, t12, t13, t14, t15, t17, t01; \
     t01 = b   ^ c  ; \
     t02 = a   | d  ; \
     t03 = a   ^ b  ; \
@@ -102,8 +103,8 @@ typedef struct serpent_context
 
 #define SBOX0_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t08, t09, t10; \
-    register unsigned long t12, t13, t14, t15, t17, t18, t01; \
+    u32 t02, t03, t04, t05, t06, t08, t09, t10; \
+    u32 t12, t13, t14, t15, t17, t18, t01; \
     t01 = c   ^ d  ; \
     t02 = a   | b  ; \
     t03 = b   | c  ; \
@@ -127,8 +128,8 @@ typedef struct serpent_context
 
 #define SBOX1(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t07, t08; \
-    register unsigned long t10, t11, t12, t13, t16, t17, t01; \
+    u32 t02, t03, t04, t05, t06, t07, t08; \
+    u32 t10, t11, t12, t13, t16, t17, t01; \
     t01 = a   | d  ; \
     t02 = c   ^ d  ; \
     t03 =     ~ b  ; \
@@ -151,8 +152,8 @@ typedef struct serpent_context
 
 #define SBOX1_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t07, t08; \
-    register unsigned long t09, t10, t11, t14, t15, t17, t01; \
+    u32 t02, t03, t04, t05, t06, t07, t08; \
+    u32 t09, t10, t11, t14, t15, t17, t01; \
     t01 = a   ^ b  ; \
     t02 = b   | d  ; \
     t03 = a   & c  ; \
@@ -175,8 +176,8 @@ typedef struct serpent_context
 
 #define SBOX2(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t05, t06, t07, t08; \
-    register unsigned long t09, t10, t12, t13, t14, t01; \
+    u32 t02, t03, t05, t06, t07, t08; \
+    u32 t09, t10, t12, t13, t14, t01; \
     t01 = a   | c  ; \
     t02 = a   ^ b  ; \
     t03 = d   ^ t01; \
@@ -197,8 +198,8 @@ typedef struct serpent_context
 
 #define SBOX2_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t06, t07, t08, t09; \
-    register unsigned long t10, t11, t12, t15, t16, t17, t01; \
+    u32 t02, t03, t04, t06, t07, t08, t09; \
+    u32 t10, t11, t12, t15, t16, t17, t01; \
     t01 = a   ^ d  ; \
     t02 = c   ^ d  ; \
     t03 = a   & c  ; \
@@ -221,8 +222,8 @@ typedef struct serpent_context
 
 #define SBOX3(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t07, t08; \
-    register unsigned long t09, t10, t11, t13, t14, t15, t01; \
+    u32 t02, t03, t04, t05, t06, t07, t08; \
+    u32 t09, t10, t11, t13, t14, t15, t01; \
     t01 = a   ^ c  ; \
     t02 = a   | d  ; \
     t03 = a   & d  ; \
@@ -245,8 +246,8 @@ typedef struct serpent_context
 
 #define SBOX3_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t07, t09; \
-    register unsigned long t11, t12, t13, t14, t16, t01; \
+    u32 t02, t03, t04, t05, t06, t07, t09; \
+    u32 t11, t12, t13, t14, t16, t01; \
     t01 = c   | d  ; \
     t02 = a   | d  ; \
     t03 = c   ^ t02; \
@@ -268,8 +269,8 @@ typedef struct serpent_context
 
 #define SBOX4(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t08, t09; \
-    register unsigned long t10, t11, t12, t13, t14, t15, t16, t01; \
+    u32 t02, t03, t04, t05, t06, t08, t09; \
+    u32 t10, t11, t12, t13, t14, t15, t16, t01; \
     t01 = a   | b  ; \
     t02 = b   | c  ; \
     t03 = a   ^ t02; \
@@ -293,8 +294,8 @@ typedef struct serpent_context
 
 #define SBOX4_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t07, t09; \
-    register unsigned long t10, t11, t12, t13, t15, t01; \
+    u32 t02, t03, t04, t05, t06, t07, t09; \
+    u32 t10, t11, t12, t13, t15, t01; \
     t01 = b   | d  ; \
     t02 = c   | d  ; \
     t03 = a   & t01; \
@@ -316,8 +317,8 @@ typedef struct serpent_context
 
 #define SBOX5(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t07, t08, t09; \
-    register unsigned long t10, t11, t12, t13, t14, t01; \
+    u32 t02, t03, t04, t05, t07, t08, t09; \
+    u32 t10, t11, t12, t13, t14, t01; \
     t01 = b   ^ d  ; \
     t02 = b   | d  ; \
     t03 = a   & t01; \
@@ -339,8 +340,8 @@ typedef struct serpent_context
 
 #define SBOX5_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t07, t08, t09; \
-    register unsigned long t10, t12, t13, t15, t16, t01; \
+    u32 t02, t03, t04, t05, t07, t08, t09; \
+    u32 t10, t12, t13, t15, t16, t01; \
     t01 = a   & d  ; \
     t02 = c   ^ t01; \
     t03 = a   ^ d  ; \
@@ -362,8 +363,8 @@ typedef struct serpent_context
 
 #define SBOX6(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t07, t08, t09, t10; \
-    register unsigned long t11, t12, t13, t15, t17, t18, t01; \
+    u32 t02, t03, t04, t05, t07, t08, t09, t10; \
+    u32 t11, t12, t13, t15, t17, t18, t01; \
     t01 = a   & d  ; \
     t02 = b   ^ c  ; \
     t03 = a   ^ d  ; \
@@ -387,8 +388,8 @@ typedef struct serpent_context
 
 #define SBOX6_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t07, t08, t09; \
-    register unsigned long t12, t13, t14, t15, t16, t17, t01; \
+    u32 t02, t03, t04, t05, t06, t07, t08, t09; \
+    u32 t12, t13, t14, t15, t16, t17, t01; \
     t01 = a   ^ c  ; \
     t02 =     ~ c  ; \
     t03 = b   & t01; \
@@ -412,8 +413,8 @@ typedef struct serpent_context
 
 #define SBOX7(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t05, t06, t08, t09, t10; \
-    register unsigned long t11, t13, t14, t15, t16, t17, t01; \
+    u32 t02, t03, t04, t05, t06, t08, t09, t10; \
+    u32 t11, t13, t14, t15, t16, t17, t01; \
     t01 = a   & c  ; \
     t02 =     ~ d  ; \
     t03 = a   & t02; \
@@ -437,8 +438,8 @@ typedef struct serpent_context
 
 #define SBOX7_INVERSE(a, b, c, d, w, x, y, z) \
   { \
-    register unsigned long t02, t03, t04, t06, t07, t08, t09; \
-    register unsigned long t10, t11, t13, t14, t15, t16, t01; \
+    u32 t02, t03, t04, t06, t07, t08, t09; \
+    u32 t10, t11, t13, t14, t15, t16, t01; \
     t01 = a   & b  ; \
     t02 = a   | b  ; \
     t03 = c   | t01; \
@@ -578,7 +579,7 @@ typedef struct serpent_context
 /* Convert the user provided key KEY of KEY_LENGTH bytes into the
    internally used format.  */
 static void
-serpent_key_prepare (const byte_t *key, unsigned int key_length,
+serpent_key_prepare (const byte *key, unsigned int key_length,
                     serpent_key_t key_prepared)
 {
   int i;
@@ -587,9 +588,9 @@ serpent_key_prepare (const byte_t *key, unsigned int key_length,
   for (i = 0; i < key_length / 4; i++)
     {
 #ifdef WORDS_BIGENDIAN
-      key_prepared[i] = byte_swap_32 (((u32_t *) key)[i]);
+      key_prepared[i] = byte_swap_32 (((u32 *) key)[i]);
 #else
-      key_prepared[i] = ((u32_t *) key)[i];
+      key_prepared[i] = ((u32 *) key)[i];
 #endif
     }
 
@@ -608,9 +609,9 @@ serpent_key_prepare (const byte_t *key, unsigned int key_length,
 static void
 serpent_subkeys_generate (serpent_key_t key, serpent_subkeys_t subkeys)
 {
-  u32_t w_real[140];           /* The `prekey'.  */
-  u32_t k[132];
-  u32_t *w = &w_real[8];
+  u32 w_real[140];             /* The `prekey'.  */
+  u32 k[132];
+  u32 *w = &w_real[8];
   int i, j;
 
   /* Initialize with key values.  */
@@ -665,21 +666,21 @@ serpent_subkeys_generate (serpent_key_t key, serpent_subkeys_t subkeys)
 /* Initialize CONTEXT with the key KEY of KEY_LENGTH bits.  */
 static void
 serpent_setkey_internal (serpent_context_t *context,
-                        const byte_t *key, unsigned int key_length)
+                        const byte *key, unsigned int key_length)
 {
   serpent_key_t key_prepared;
 
   serpent_key_prepare (key, key_length, key_prepared);
   serpent_subkeys_generate (key_prepared, context->keys);
-  _gcry_burn_stack (272 * sizeof (u32_t));
+  _gcry_burn_stack (272 * sizeof (u32));
 }
 
 /* Initialize CTX with the key KEY of KEY_LENGTH bytes.  */
 static gcry_err_code_t
 serpent_setkey (void *ctx,
-               const byte_t *key, unsigned int key_length)
+               const byte *key, unsigned int key_length)
 {
-  serpent_context_t *context = (serpent_context_t *) ctx;
+  serpent_context_t *context = ctx;
   static const char *serpent_test_ret;
   static int serpent_init_done;
   gcry_err_code_t ret = GPG_ERR_NO_ERROR;
@@ -687,8 +688,6 @@ serpent_setkey (void *ctx,
   if (! serpent_init_done)
     {
       /* Execute a self-test the first time, Serpent is used.  */
-      static const char *serpent_test (void);
-      
       serpent_test_ret = serpent_test ();
       if (serpent_test_ret)
        log_error ("Serpent test failure: %s\n", serpent_test_ret);
@@ -779,7 +778,17 @@ serpent_decrypt_internal (serpent_context_t *context,
   serpent_block_t b, b_next;
   int round = ROUNDS;
 
-  BLOCK_COPY (b_next, input);
+#ifdef WORDS_BIGENDIAN
+  b_next[0] = byte_swap_32 (input[0]);
+  b_next[1] = byte_swap_32 (input[1]);
+  b_next[2] = byte_swap_32 (input[2]);
+  b_next[3] = byte_swap_32 (input[3]);
+#else
+  b_next[0] = input[0];
+  b_next[1] = input[1];
+  b_next[2] = input[2];
+  b_next[3] = input[3];
+#endif
 
   ROUND_FIRST_INVERSE (7, context->keys, b_next, b);
 
@@ -815,27 +824,38 @@ serpent_decrypt_internal (serpent_context_t *context,
   ROUND_INVERSE (1, context->keys, b, b_next);
   ROUND_INVERSE (0, context->keys, b, b_next);
 
-  BLOCK_COPY (output, b_next);
+
+#ifdef WORDS_BIGENDIAN
+  output[0] = byte_swap_32 (b_next[0]);
+  output[1] = byte_swap_32 (b_next[1]);
+  output[2] = byte_swap_32 (b_next[2]);
+  output[3] = byte_swap_32 (b_next[3]);
+#else
+  output[0] = b_next[0];
+  output[1] = b_next[1];
+  output[2] = b_next[2];
+  output[3] = b_next[3];
+#endif
 }
 
 static void
-serpent_encrypt (void *ctx, byte_t *buffer_out, const byte_t *buffer_in)
+serpent_encrypt (void *ctx, byte *buffer_out, const byte *buffer_in)
 {
-  serpent_context_t *context = (serpent_context_t *) ctx;
+  serpent_context_t *context = ctx;
 
   serpent_encrypt_internal (context,
-                           (const u32_t *) buffer_in, (u32_t *) buffer_out);
+                           (const u32 *) buffer_in, (u32 *) buffer_out);
   _gcry_burn_stack (2 * sizeof (serpent_block_t));
 }
 
 static void
 serpent_decrypt (void *ctx, byte *buffer_out, const byte *buffer_in)
 {
-  serpent_context_t *context = (serpent_context_t *) ctx;
+  serpent_context_t *context = ctx;
 
   serpent_decrypt_internal (context,
-                           (const u32_t *) buffer_in,
-                           (u32_t *) buffer_out);
+                           (const u32 *) buffer_in,
+                           (u32 *) buffer_out);
   _gcry_burn_stack (2 * sizeof (serpent_block_t));
 }
 
@@ -892,10 +912,12 @@ serpent_test (void)
 
   for (i = 0; test_data[i].key_length; i++)
     {
-      serpent_setkey_internal (&context, test_data[i].key, test_data[i].key_length);
+      serpent_setkey_internal (&context, test_data[i].key,
+                               test_data[i].key_length);
       serpent_encrypt_internal (&context,
-                               (const u32_t *) test_data[i].text_plain,
-                               (u32_t *) scratch);
+                               (const u32 *) test_data[i].text_plain,
+                               (u32 *) scratch);
+
       if (memcmp (scratch, test_data[i].text_cipher, sizeof (serpent_block_t)))
        switch (test_data[i].key_length)
          {
@@ -908,8 +930,8 @@ serpent_test (void)
          }
 
     serpent_decrypt_internal (&context,
-                             (const u32_t *) test_data[i].text_cipher,
-                             (u32_t *) scratch);
+                             (const u32 *) test_data[i].text_cipher,
+                             (u32 *) scratch);
     if (memcmp (scratch, test_data[i].text_plain, sizeof (serpent_block_t)))
       switch (test_data[i].key_length)
        {
@@ -931,26 +953,26 @@ serpent_test (void)
 static const char *cipher_spec_serpent128_aliases[] =
   {
     "SERPENT",
-    NULL,
+    NULL
   };
 
-gcry_cipher_spec_t cipher_spec_serpent128 =
+gcry_cipher_spec_t _gcry_cipher_spec_serpent128 =
   {
     "SERPENT128", cipher_spec_serpent128_aliases, NULL, 16, 128,
     sizeof (serpent_context_t),
-    serpent_setkey, serpent_encrypt, serpent_decrypt,
+    serpent_setkey, serpent_encrypt, serpent_decrypt
   };
 
-gcry_cipher_spec_t cipher_spec_serpent192 =
+gcry_cipher_spec_t _gcry_cipher_spec_serpent192 =
   {
     "SERPENT192", NULL, NULL, 16, 192,
     sizeof (serpent_context_t),
-    serpent_setkey, serpent_encrypt, serpent_decrypt,
+    serpent_setkey, serpent_encrypt, serpent_decrypt
   };
 
-gcry_cipher_spec_t cipher_spec_serpent256 =
+gcry_cipher_spec_t _gcry_cipher_spec_serpent256 =
   {
     "SERPENT256", NULL, NULL, 16, 256,
     sizeof (serpent_context_t),
-    serpent_setkey, serpent_encrypt, serpent_decrypt,
+    serpent_setkey, serpent_encrypt, serpent_decrypt
   };