reducing code size by removing unused functions and tables

src/clyde_32bit.c

@@ -28,22 +28,6 @@
 #define CLYDE_128_NS 6                // Number of steps
 #define CLYDE_128_NR 2 * CLYDE_128_NS // Number of rounds
 
-// Round constants for Clyde-128
-static const uint32_t clyde128_rc[CLYDE_128_NR][LS_ROWS] = {
-  { 1, 0, 0, 0 }, // 0
-  { 0, 1, 0, 0 }, // 1
-  { 0, 0, 1, 0 }, // 2
-  { 0, 0, 0, 1 }, // 3
-  { 1, 1, 0, 0 }, // 4
-  { 0, 1, 1, 0 }, // 5
-  { 0, 0, 1, 1 }, // 6
-  { 1, 1, 0, 1 }, // 7
-  { 1, 0, 1, 0 }, // 8
-  { 0, 1, 0, 1 }, // 9
-  { 1, 1, 1, 0 }, // 10
-  { 0, 1, 1, 1 }  // 11
-};
-
 
 // Apply a S-box layer to a Clyde-128 state.
 static void sbox_layer(uint32_t* state) {
@@ -105,21 +89,21 @@ void clyde128_encrypt(clyde128_state state, const clyde128_state t, const unsign
 	// Datapath
 	XORLS(state, tk[0]);
 	uint32_t off = 0x924;		// 2-bits describing the round key
-	uint32_t lfsr = 0x8;		// LFSR for round constant	
+	uint32_t lfsr = 0x8;		// LFSR for round constant
 	for (uint32_t s = 0; s < CLYDE_128_NS; s++) {
 		sbox_layer(state);
 		lbox(&state[0], &state[1]);
 		lbox(&state[2], &state[3]);
 		XORCST(state,lfsr);
-		uint32_t b = lfsr & 0x1;        
+		uint32_t b = lfsr & 0x1;
 		lfsr = (lfsr^(b<<3) | b<<4)>>1;	// update LFSR
 
 		sbox_layer(state);
 		lbox(&state[0], &state[1]);
 		lbox(&state[2], &state[3]);
 		XORCST(state,lfsr);
-		b = lfsr & 0x1;               
-		lfsr = (lfsr^(b<<3) | b<<4)>>1; // update LFSR     
+		b = lfsr & 0x1;
+		lfsr = (lfsr^(b<<3) | b<<4)>>1; // update LFSR
 		off >>=2;
 		XORLS(state, tk[off&0x03]);
 	}

src/clyde_32bit_inv.c

-/* MIT License
- *
- * Copyright (c) 2019 Gaëtan Cassiers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#include <string.h>
-#include <stdint.h>
-
-#ifdef BENCH_IACA
-#include "iacaMarks.h"
-#else
-#define IACA_START
-#define IACA_END
-#endif
-
-#include "primitives.h"
-
-#define CLYDE_128_NS 6                // Number of steps
-#define CLYDE_128_NR 2 * CLYDE_128_NS // Number of rounds
-
-// Round constants for Clyde-128
-static const uint32_t clyde128_rc[CLYDE_128_NR][LS_ROWS] = {
-  { 1, 0, 0, 0 }, // 0
-  { 0, 1, 0, 0 }, // 1
-  { 0, 0, 1, 0 }, // 2
-  { 0, 0, 0, 1 }, // 3
-  { 1, 1, 0, 0 }, // 4
-  { 0, 1, 1, 0 }, // 5
-  { 0, 0, 1, 1 }, // 6
-  { 1, 1, 0, 1 }, // 7
-  { 1, 0, 1, 0 }, // 8
-  { 0, 1, 0, 1 }, // 9
-  { 1, 1, 1, 0 }, // 10
-  { 0, 1, 1, 1 }  // 11
-};
-
-// Apply a inverse S-box layer to a Clyde-128 state.
-static void sbox_layer_inv(uint32_t* state) {
-  uint32_t y3 = (state[0] & state[1]) ^ state[2];
-  uint32_t y0 = (state[1] & y3) ^ state[3];
-  uint32_t y1 = (y3 & y0) ^ state[0];
-  uint32_t y2 = (y0 & y1) ^ state[1];
-  state[0] = y0;
-  state[1] = y1;
-  state[2] = y2;
-  state[3] = y3;
-}
-
-// Apply a inverse L-box to a pair of Clyde-128 rows.
-#define ROT32(x,n) ((uint32_t)(((x)>>(n))|((x)<<(32-(n)))))
-static void lbox_inv(uint32_t* x, uint32_t* y) {
-  uint32_t a, b, c, d;
-  a = *x ^ ROT32(*x, 25);
-  b = *y ^ ROT32(*y, 25);
-  c = *x ^ ROT32(a, 31);
-  d = *y ^ ROT32(b, 31);
-  c = c ^ ROT32(a, 20);
-  d = d ^ ROT32(b, 20);
-  a = c ^ ROT32(c, 31);
-  b = d ^ ROT32(d, 31);
-  c = c ^ ROT32(b, 26);
-  d = d ^ ROT32(a, 25);
-  a = a ^ ROT32(c, 17);
-  b = b ^ ROT32(d, 17);
-  a = ROT32(a, 16);
-  b = ROT32(b, 16);
-  *x = a;
-  *y = b;
-}
-
-#define XORLS(DEST, OP) do { \
-    (DEST)[0] ^= (OP)[0]; \
-    (DEST)[1] ^= (OP)[1]; \
-    (DEST)[2] ^= (OP)[2]; \
-    (DEST)[3] ^= (OP)[3]; } while (0)
-
-void clyde128_decrypt(clyde128_state state, const clyde128_state t, const unsigned char* k) {
-  // Key schedule
-  clyde128_state k_st;
-  memcpy(k_st, k, CLYDE128_NBYTES);
-  clyde128_state tk[3] = {
-      { t[0], t[1], t[2], t[3] },
-      { t[0] ^ t[2], t[1] ^ t[3], t[0], t[1] },
-      { t[2], t[3], t[0] ^ t[2], t[1] ^ t[3] }
-  };
-  XORLS(tk[0], k);
-  XORLS(tk[1], k);
-  XORLS(tk[2], k);
-
-  // Datapath
-  for (unsigned int s = 0; s < CLYDE_128_NS; s++) {
-      IACA_START
-      unsigned int r = 2 * s;
-      unsigned int off = (s+1) % 3;
-      XORLS(state, tk[off]);
-
-      XORLS(state, clyde128_rc[r+1]);
-      lbox_inv(&state[0], &state[1]);
-      lbox_inv(&state[2], &state[3]);
-      sbox_layer_inv(state);
-      XORLS(state, clyde128_rc[r]);
-      lbox_inv(&state[0], &state[1]);
-      lbox_inv(&state[2], &state[3]);
-      sbox_layer_inv(state);
-  }
-  IACA_END
-  XORLS(state, tk[0]);
-}

src/primitives.c

+
+#include "primitives.h"
+//#include INCLUDE_C(PRIMITIVES_TYPE)
+//
+#define QUOTEME_INNER(M)       #M
+#define QUOTEME(M)       QUOTEME_INNER(M)
+#define CONCAT3(X, Y, Z) X ## Y ## Z
+#define INCLUDE_C(M)  QUOTEME(CONCAT3(M, _, primitives.c))
+

src/s1p.c

@@ -23,10 +23,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
-
+#include "primitives.h"
 #include "s1p.h"
 #include "parameters.h"
-#include "primitives.h"
 
 #define CAPACITY_BYTES 32
 #define RATE_BYTES (SHADOW_NBYTES - CAPACITY_BYTES)

src/shadow_32bit.c

@@ -32,23 +32,6 @@
 #define SHADOW_NR 2 * SHADOW_NS       // Number of rounds
 
 
-// Round constants for Clyde-128
-static const uint32_t clyde128_rc[CLYDE_128_NR][LS_ROWS] = {
-  { 1, 0, 0, 0 }, // 0
-  { 0, 1, 0, 0 }, // 1
-  { 0, 0, 1, 0 }, // 2
-  { 0, 0, 0, 1 }, // 3
-  { 1, 1, 0, 0 }, // 4
-  { 0, 1, 1, 0 }, // 5
-  { 0, 0, 1, 1 }, // 6
-  { 1, 1, 0, 1 }, // 7
-  { 1, 0, 1, 0 }, // 8
-  { 0, 1, 0, 1 }, // 9
-  { 1, 1, 1, 0 }, // 10
-  { 0, 1, 1, 1 }  // 11
-};
-
-
 // Apply a S-box layer to a Clyde-128 state.
 static void sbox_layer(uint32_t* state) {
   uint32_t y1 = (state[0] & state[1]) ^ state[2];
@@ -120,7 +103,7 @@ static void dbox_mls_layer(shadow_state state) {
 
 // Shadow permutation. Updates state.
 void shadow(shadow_state state) {
-    uint32_t lfsr = 0x8;	 
+    uint32_t lfsr = 0x8;
     for (unsigned int s = 0; s < SHADOW_NS; s++) {
         for (unsigned int b = 0; b < MLS_BUNDLES; b++) {
             sbox_layer(state[b]);
@@ -130,14 +113,14 @@ void shadow(shadow_state state) {
             sbox_layer(state[b]);
         }
 
-        uint32_t b = lfsr & 0x1;        
+        uint32_t b = lfsr & 0x1;
         lfsr = (lfsr^(b<<3) | b<<4)>>1;	// update LFSR
 
         dbox_mls_layer(state);
         for (unsigned int b = 0; b < MLS_BUNDLES; b++) {
             XORCST(state[b], lfsr, b);
-        }	  
-        b = lfsr & 0x1;                 
+        }
+        b = lfsr & 0x1;
         lfsr = (lfsr^(b<<3) | b<<4)>>1; // update LFSR
     }
 }

test/test.sh

@@ -35,6 +35,6 @@ test_build_spook 1 0 410c79bf206274bf6145103d1e87c20e17d258cd77c550fd0d33ef30a97
 test_build_spook 1 1 53d431a078490a709767c0089614fcda87218f11e97ab565d2e84f25bbfcd9cc
 }
 
-export CLYDE_TYPE=clyde_$ctype;
-export SHADOW_TYPE=shadow_$stype;
+export CLYDE_TYPE=clyde_32bit;
+export SHADOW_TYPE=shadow_32bit;
 test_all_spook_versions;