[ViewVC] Diff of: cvs/Crypt-Twofish2/twofish.c

Comparing Crypt-Twofish2/twofish.c (file contents):
Revision 1.1 by root, Sat Sep 6 22:10:54 2003 UTC vs.
Revision 1.4 by root, Sun Aug 1 18:09:47 2021 UTC

         Bruce Schneier, Counterpane Systems
         Doug Whiting,   Hi/fn
         John Kelsey,    Counterpane Systems
         Chris Hall,     Counterpane Systems
         David Wagner,   UC Berkeley
     Code Author:        Doug Whiting,   Hi/fn
     Version  1.00       April 1998
     Copyright 1998, Hi/fn and Counterpane Systems.  All rights reserved.
     Notes:
         *   Optimized version
         *   Tab size is set to 4 characters in this file
 ***************************************************************************/
 *           Constants/Macros/Tables
 -****************************************************************************/
 #define     CONST                   /* help syntax from C++, NOP here */
-CONST       fullSbox MDStab;        /* not actually const.  Initialized ONE time */
+static CONST       fullSbox MDStab;        /* not actually const.  Initialized ONE time */
-int         needToBuildMDS=1;       /* is MDStab initialized yet? */
+static int         needToBuildMDS=1;       /* is MDStab initialized yet? */
 #define     BIG_TAB     0
 #if BIG_TAB
-BYTE        bigTab[4][256][256];    /* pre-computed S-box */
+static BYTE        bigTab[4][256][256];    /* pre-computed S-box */
 #endif
 /* number of rounds for various key sizes:  128, 192, 256 */
 /* (ignored for now in optimized code!) */
-CONST int   numRounds[4]= {0,ROUNDS_128,ROUNDS_192,ROUNDS_256};
+static CONST int   numRounds[4]= {0,ROUNDS_128,ROUNDS_192,ROUNDS_256};
 #if REENTRANT
 #define     _sBox_   key->sBox8x32
 #else
 static      fullSbox _sBox_;        /* permuted MDStab based on keys */
                    MDStab[2][p8(21)[_sBox8_(2)[_b(x,R+2)]] ^ b2(SKEY0)] ^ \
                    MDStab[3][p8(31)[_sBox8_(3)[_b(x,R+3)]] ^ b3(SKEY0)])
 #define sbSet(N,i,J,v) { _sBox8_(N)[i+J] = v; }
 #define GetSboxKey  DWORD SKEY0 = key->sboxKeys[0]      /* local copy */
 /*----------------------------------------------------------------*/
 #elif defined(PART_KEY)
 #define MOD_STRING  "(Partial keying)"
 #define Fe32_(x,R)(MDStab[0][_sBox8_(0)[_b(x,R  )]] ^ \
                    MDStab[1][_sBox8_(1)[_b(x,R+1)]] ^ \
                    MDStab[2][_sBox8_(2)[_b(x,R+2)]] ^ \
                    MDStab[3][_sBox8_(3)[_b(x,R+3)]])
 #define sbSet(N,i,J,v) { _sBox8_(N)[i+J] = v; }
 #define GetSboxKey
 /*----------------------------------------------------------------*/
 #else   /* default is FULL_KEY */
 #ifndef FULL_KEY
 #define FULL_KEY    1
 #endif
    in optimized assembly language.
 */
 #define Fe32_(x,R) (_sBox_[0][2*_b(x,R  )] ^ _sBox_[0][2*_b(x,R+1)+1] ^ \
                     _sBox_[2][2*_b(x,R+2)] ^ _sBox_[2][2*_b(x,R+3)+1])
         /* set a single S-box value, given the input byte */
-#define sbSet(N,i,J,v) { _sBox_[N&2][2*i+(N&1)+2*J]=MDStab[N][v]; }
+//#define sbSet(N,i,J,v) { _sBox_[N&2][2*i+(N&1)+2*J]=MDStab[N][v]; }
+#define sbSet(N,i,J,v) { *((DWORD *)_sBox_ + (N&2)*256 + 2*i + (N&1) + 2*J) = MDStab[N][v]; }
 #define GetSboxKey
 #endif
 /* macro(s) for debugging help */
 #define     CHECK_TABLE     0       /* nonzero --> compare against "slow" table */
 #define     VALIDATE_PARMS  0       /* disable for full speed */
 /* end of debug macros */
 #ifdef GetCodeSize
-extern DWORD Here(DWORD x);         /* return caller's address! */
+static extern DWORD Here(DWORD x);         /* return caller's address! */
-DWORD TwofishCodeStart(void) { return Here(0); }
+static DWORD TwofishCodeStart(void) { return Here(0); }
 #endif
 /*
 +*****************************************************************************
 *
 *
 * Function:         Handle table use checking
 *
 * Arguments:        op  =   what to do  (see TAB_* defns in AES.H)
 *
 * Return:           TRUE --> done (for TAB_QUERY)
 *
 * Notes: This routine is for use in generating the tables KAT file.
 *        For this optimized version, we don't actually track table usage,
 *        since it would make the macros incredibly ugly.  Instead we just
 *        run for a fixed number of queries and then say we're done.
 *
 -****************************************************************************/
-int TableOp(int op)
+static int TableOp(int op)
     {
     static int queryCnt=0;
     switch (op)
         {
 *
 * Return:           The output of the keyed permutation applied to x.
 *
 * Notes:
 *   This function is a keyed 32-bit permutation.  It is the major building
 *   block for the Twofish round function, including the four keyed 8x8
 *   permutations and the 4x4 MDS matrix multiply.  This function is used
 *   both for generating round subkeys and within the round function on the
 *   block being encrypted.
 *
 *   This version is fairly slow and pedagogical, although a smartcard would
 *   probably perform the operation exactly this way in firmware.   For
 *   ultimate performance, the entire operation can be completed with four
 *   lookups into four 256x32-bit tables, with three dword xors.
 *
 *   The MDS matrix is defined in TABLE.H.  To multiply by Mij, just use the
 *   macro Mij(x).
 *
 -****************************************************************************/
-DWORD f32(DWORD x,CONST DWORD *k32,int keyLen)
+static DWORD f32(DWORD x,CONST DWORD *k32,int keyLen)
     {
     BYTE  b[4];
     /* Run each byte thru 8x8 S-boxes, xoring with key byte at each stage. */
     /* Note that each byte goes through a different combination of S-boxes.*/
     *((DWORD *)b) = Bswap(x);   /* make b[0] = LSB, b[3] = MSB */
     switch (((keyLen + 63)/64) & 3)
 *   the performance impact of this routine is imperceptible. The RS code
 *   chosen has "simple" coefficients to allow smartcard/hardware implementation
 *   without lookup tables.
 *
 -****************************************************************************/
-DWORD RS_MDS_Encode(DWORD k0,DWORD k1)
+static DWORD RS_MDS_Encode(DWORD k0,DWORD k1)
     {
     int i,j;
     DWORD r;
     for (i=r=0;i<2;i++)
         {
         r ^= (i) ? k0 : k1;         /* merge in 32 more key bits */
         for (j=0;j<4;j++)           /* shift one byte at a time */
             RS_rem(r);
         }
     return r;
     }
 * Notes:
 *   Here we precompute all the fixed MDS table.  This only needs to be done
 *   one time at initialization, after which the table is "CONST".
 *
 -****************************************************************************/
-void BuildMDS(void)
+static void BuildMDS(void)
     {
     int i;
     DWORD d;
     BYTE m1[2],mX[2],mY[4];
 #undef  Mul_1                   /* change what the pre-processor does with Mij */
 #undef  Mul_X
 #undef  Mul_Y
 #define Mul_1   m1              /* It will now access m01[], m5B[], and mEF[] */
 #define Mul_X   mX
 #define Mul_Y   mY
 #define SetMDS(N)                   \
         b0(d) = M0##N[P_##N##0];    \
         b1(d) = M1##N[P_##N##0];    \
 #undef  Mul_X
 #undef  Mul_Y
 #define Mul_1   Mx_1            /* re-enable true multiply */
 #define Mul_X   Mx_X
 #define Mul_Y   Mx_Y
 #if BIG_TAB
     {
     int j,k;
     BYTE *q0,*q1;
 *   This optimization allows both blockEncrypt and blockDecrypt to use the same
 *   "fallthru" switch statement based on the number of rounds.
 *   Note that key->numRounds must be even and >= 2 here.
 *
 -****************************************************************************/
-void ReverseRoundSubkeys(keyInstance *key,BYTE newDir)
+static void ReverseRoundSubkeys(keyInstance *key,BYTE newDir)
     {
     DWORD t0,t1;
     register DWORD *r0=key->subKeys+ROUND_SUBKEYS;
     register DWORD *r1=r0 + 2*key->numRounds - 2;
 *   The penalty is nearly 50%!  So we take the code size hit for inlining for
 *   Borland, while Microsoft happily works with a call.
 *
 -****************************************************************************/
 #if defined(__BORLANDC__)   /* do it inline */
 #define Xor32(dst,src,i) { ((DWORD *)dst)[i] = ((DWORD *)src)[i] ^ tmpX; }
 #define Xor256(dst,src,b)               \
     {                                   \
     register DWORD tmpX=0x01010101u * b;\
     for (i=0;i<64;i+=4)                 \
         { Xor32(dst,src,i  ); Xor32(dst,src,i+1); Xor32(dst,src,i+2); Xor32(dst,src,i+3); } \
     }
 #else                       /* do it as a function call */
-void Xor256(void *dst,void *src,BYTE b)
+static void Xor256(void *dst,void *src,BYTE b)
     {
     register DWORD  x=b*0x01010101u;    /* replicate byte to all four bytes */
     register DWORD *d=(DWORD *)dst;
     register DWORD *s=(DWORD *)src;
 #define X_8(N)  { d[N]=s[N] ^ x; d[N+1]=s[N+1] ^ x; }
 *
 * Return:           TRUE on success
 *
 * Notes:
 *   Here we precompute all the round subkeys, although that is not actually
 *   required.  For example, on a smartcard, the round subkeys can
 *   be generated on-the-fly using f32()
 *
 -****************************************************************************/
-int reKey(keyInstance *key)
+static int reKey(keyInstance *key)
     {
     int     i,j,k64Cnt,keyLen;
     int     subkeyCnt;
     DWORD   A=0,B=0,q;
     DWORD   sKey[MAX_KEY_BITS/64],k32e[MAX_KEY_BITS/64],k32o[MAX_KEY_BITS/64];
     reKey_86(key);
     }
 else
 #endif
     {
     for (i=q=0;i<subkeyCnt/2;i++,q+=SK_STEP)
         {                           /* compute round subkeys for PHT */
         F32(A,q        ,k32e);      /* A uses even key dwords */
         F32(B,q+SK_BUMP,k32o);      /* B uses odd  key dwords */
         B = ROL(B,8);
         key->subKeys[2*i  ] = A+B;  /* combine with a PHT */
         assert(f32(q,key->sboxKeys,keyLen) == Fe32_(q,0));
   #endif
     }
 #endif /* CHECK_TABLE */
     if (key->direction == DIR_ENCRYPT)
         ReverseRoundSubkeys(key,DIR_ENCRYPT);   /* reverse the round subkey order */
     return TRUE;
     }
 /*
 *                   else error code (e.g., BAD_KEY_DIR)
 *
 * Notes:    This parses the key bits from keyMaterial.  Zeroes out unused key bits
 *
 -****************************************************************************/
-int makeKey(keyInstance *key, BYTE direction, int keyLen,CONST char *keyMaterial)
+static int makeKey(keyInstance *key, BYTE direction, int keyLen,CONST char *keyMaterial)
     {
     int i;
 #if VALIDATE_PARMS              /* first, sanity check on parameters */
     if (key == NULL)
         return BAD_KEY_INSTANCE;/* must have a keyInstance to initialize */
     if ((direction != DIR_ENCRYPT) && (direction != DIR_DECRYPT))
         return BAD_KEY_DIR;     /* must have valid direction */
     if ((keyLen > MAX_KEY_BITS) || (keyLen < 8) || (keyLen & 0x3F))
         return BAD_KEY_MAT;     /* length must be valid */
     key->numRounds  = numRounds[(keyLen-1)/64];
     memset(key->key32,0,sizeof(key->key32));    /* zero unused bits */
     if (keyMaterial == NULL)
         return TRUE;            /* allow a "dummy" call */
     for (i=0;i<keyLen/32;i++)   /* make byte-oriented copy for CFB1 */
         key->key32[i] = (((unsigned char *)keyMaterial)[i*4+0] <<  0)
                       | (((unsigned char *)keyMaterial)[i*4+1] <<  8)
                       | (((unsigned char *)keyMaterial)[i*4+2] << 16)
                       | (((unsigned char *)keyMaterial)[i*4+3] << 24);
 *
 * Return:           TRUE on success
 *                   else error code (e.g., BAD_CIPHER_MODE)
 *
 -****************************************************************************/
-int cipherInit(cipherInstance *cipher, BYTE mode,CONST char *IV)
+static int cipherInit(cipherInstance *cipher, BYTE mode,CONST char *IV)
     {
     int i;
 #if VALIDATE_PARMS              /* first, sanity check on parameters */
     if (cipher == NULL)
         return BAD_PARAMS;      /* must have a cipherInstance to initialize */
     if ((mode != MODE_ECB) && (mode != MODE_CBC) && (mode != MODE_CFB1))
         return BAD_CIPHER_MODE; /* must have valid cipher mode */
     cipher->cipherSig   =   VALID_SIG;
   #if ALIGN32
 * Return:           # bits ciphered (>= 0)
 *                   else error code (e.g., BAD_CIPHER_STATE, BAD_KEY_MATERIAL)
 *
 * Notes: The only supported block size for ECB/CBC modes is BLOCK_SIZE bits.
 *        If inputLen is not a multiple of BLOCK_SIZE bits in those modes,
 *        an error BAD_INPUT_LEN is returned.  In CFB1 mode, all block
 *        sizes can be supported.
 *
 -****************************************************************************/
-int blockEncrypt(cipherInstance *cipher, keyInstance *key,CONST BYTE *input,
+static int blockEncrypt(cipherInstance *cipher, keyInstance *key,CONST BYTE *input,
                 int inputLen, BYTE *outBuffer)
     {
     int   i,n;                      /* loop counters */
     DWORD x[BLOCK_SIZE/32];         /* block being encrypted */
     DWORD t0,t1;                    /* temp variables */
 #ifdef USE_ASM
     if ((useAsm & 1) && (inputLen))
   #ifdef COMPILE_KEY
         if (key->keySig == VALID_SIG)
             return ((CipherProc *)(key->encryptFuncPtr))(cipher,key,input,inputLen,outBuffer);
   #else
         return (*blockEncrypt_86)(cipher,key,input,inputLen,outBuffer);
   #endif
 #endif
     /* make local copy of subkeys for speed */
     memcpy(sk,key->subKeys,sizeof(DWORD)*(ROUND_SUBKEYS+2*rounds));
 * Return:           # bits ciphered (>= 0)
 *                   else error code (e.g., BAD_CIPHER_STATE, BAD_KEY_MATERIAL)
 *
 * Notes: The only supported block size for ECB/CBC modes is BLOCK_SIZE bits.
 *        If inputLen is not a multiple of BLOCK_SIZE bits in those modes,
 *        an error BAD_INPUT_LEN is returned.  In CFB1 mode, all block
 *        sizes can be supported.
 *
 -****************************************************************************/
-int blockDecrypt(cipherInstance *cipher, keyInstance *key,CONST BYTE *input,
+static int blockDecrypt(cipherInstance *cipher, keyInstance *key,CONST BYTE *input,
                 int inputLen, BYTE *outBuffer)
     {
     int   i,n;                      /* loop counters */
     DWORD x[BLOCK_SIZE/32];         /* block being encrypted */
     DWORD t0,t1;                    /* temp variables */
 #ifdef USE_ASM
     if ((useAsm & 2) && (inputLen))
   #ifdef COMPILE_KEY
         if (key->keySig == VALID_SIG)
             return ((CipherProc *)(key->decryptFuncPtr))(cipher,key,input,inputLen,outBuffer);
   #else
         return (*blockDecrypt_86)(cipher,key,input,inputLen,outBuffer);
   #endif
 #endif
     /* make local copy of subkeys for speed */
     memcpy(sk,key->subKeys,sizeof(DWORD)*(ROUND_SUBKEYS+2*rounds));
     return inputLen;
     }
 #ifdef GetCodeSize
-DWORD TwofishCodeSize(void)
+static DWORD TwofishCodeSize(void)
     {
     DWORD x= Here(0);
 #ifdef USE_ASM
     if (useAsm & 3)
         return TwofishAsmCodeSize();

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing Crypt-Twofish2/twofish.c (file contents): Revision 1.1 by root, Sat Sep 6 22:10:54 2003 UTC vs. Revision 1.4 by root, Sun Aug 1 18:09:47 2021 UTC

Diff Legend

Comparing Crypt-Twofish2/twofish.c (file contents):
Revision 1.1 by root, Sat Sep 6 22:10:54 2003 UTC vs.
Revision 1.4 by root, Sun Aug 1 18:09:47 2021 UTC