staging: crypto: skein: fixing style issues

92 lines not on this page · raw message

index ace931a..ea54546 100644
@@ -50,31 +50,31 @@ OTHER DEALINGS IN THE SOFTWARE.
  * struct skein_ctx ctx;             // a Skein hash or MAC context
  *
  * // prepare context, here for a Skein with a state size of 512 bits.
- * skeinCtxPrepare(&ctx, Skein512);
+ * skein_ctx_prepare(&ctx, Skein512);
  *
  * // Initialize the context to set the requested hash length in bits
  * // here request a output hash size of 31 bits (Skein supports variable
  * // output sizes even very strange sizes)
- * skeinInit(&ctx, 31);
+ * skein_init(&ctx, 31);
  *
  * // Now update Skein with any number of message bits. A function that
  * // takes a number of bytes is also available.
- * skeinUpdateBits(&ctx, message, msgLength);
+ * skein_update_bits(&ctx, message, msgLength);
  *
  * // Now get the result of the Skein hash. The output buffer must be
  * // large enough to hold the request number of output bits. The application
  * // may now extract the bits.
- * skeinFinal(&ctx, result);
+ * skein_final(&ctx, result);
  * ...
  * @endcode
  *
- * An application may use @c skeinReset to reset a Skein context and use
+ * An application may use @c skein_reset to reset a Skein context and use
  * it for creation of another hash with the same Skein state size and output
  * bit length. In this case the API implementation restores some internal
  * internal state data and saves a full Skein initialization round.
  *
- * To create a MAC the application just uses @c skeinMacInit instead of
- * @c skeinInit. All other functions calls remain the same.
+ * To create a MAC the application just uses @c skein_mac_init instead of
+ * @c skein_init. All other functions calls remain the same.
  *
  */
 

@@ -123,7 +123,7 @@ struct skein_ctx {
  * @return
  *     SKEIN_SUCESS of SKEIN_FAIL
  */
-int skeinCtxPrepare(struct skein_ctx *ctx, enum skein_size size);
+int skein_ctx_prepare(struct skein_ctx *ctx, enum skein_size size);
 
 /**
  * Initialize a Skein context.

@@ -137,9 +137,9 @@ int skeinCtxPrepare(struct skein_ctx *ctx, enum skein_size size);
  *     Number of MAC hash bits to compute
  * @return
  *     SKEIN_SUCESS of SKEIN_FAIL
- * @see skeinReset
+ * @see skein_reset
  */
-int skeinInit(struct skein_ctx *ctx, size_t hashBitLen);
+int skein_init(struct skein_ctx *ctx, size_t hashBitLen);
 
 /**
  * Resets a Skein context for further use.

@@ -151,7 +151,7 @@ int skeinInit(struct skein_ctx *ctx, size_t hashBitLen);
  * @param ctx
  *     Pointer to a pre-initialized Skein MAC context
  */
-void skeinReset(struct skein_ctx *ctx);
+void skein_reset(struct skein_ctx *ctx);
 
 /**
  * Initializes a Skein context for MAC usage.

@@ -173,8 +173,8 @@ void skeinReset(struct skein_ctx *ctx);
  * @return
  *     SKEIN_SUCESS of SKEIN_FAIL
  */
-int skeinMacInit(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
-		 size_t hashBitLen);
+int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
+		   size_t hashBitLen);
 
 /**
  * Update Skein with the next part of the message.

@@ -188,8 +188,8 @@ int skeinMacInit(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
  * @return
  *     Success or error code.
  */
-int skeinUpdate(struct skein_ctx *ctx, const u8 *msg,
-		size_t msgByteCnt);
+int skein_update(struct skein_ctx *ctx, const u8 *msg,
+		 size_t msgByteCnt);
 
 /**
  * Update the hash with a message bit string.

@@ -204,8 +204,8 @@ int skeinUpdate(struct skein_ctx *ctx, const u8 *msg,
  * @param msgBitCnt
  *     Length of the message in @b bits.
  */
-int skeinUpdateBits(struct skein_ctx *ctx, const u8 *msg,
-		    size_t msgBitCnt);
+int skein_update_bits(struct skein_ctx *ctx, const u8 *msg,
+		      size_t msgBitCnt);
 
 /**
  * Finalize Skein and return the hash.

@@ -220,9 +220,9 @@ int skeinUpdateBits(struct skein_ctx *ctx, const u8 *msg,
  *     enough to store @c hashBitLen bits.
  * @return
  *     Success or error code.
- * @see skeinReset
+ * @see skein_reset
  */
-int skeinFinal(struct skein_ctx *ctx, u8 *hash);
+int skein_final(struct skein_ctx *ctx, u8 *hash);
 
 /**
  * @}

index b15c079..41cae89 100644
@@ -12,11 +12,11 @@
 
 #include <skein.h> /* get the Skein API definitions   */
 
-void Skein_256_Process_Block(struct skein_256_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd);
-void Skein_512_Process_Block(struct skein_512_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd);
-void Skein1024_Process_Block(struct skein1024_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd);
+void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blkPtr,
+			     size_t blkCnt, size_t byteCntAdd);
+void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blkPtr,
+			     size_t blkCnt, size_t byteCntAdd);
+void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blkPtr,
+			      size_t blkCnt, size_t byteCntAdd);
 
 #endif

83 lines not on this page · raw message

390 lines not on this page · raw message

168 lines not on this page · raw message

index 6917638..0acb617 100644
@@ -5,8 +5,8 @@
 
 
 /*****************************  Skein_256 ******************************/
-void Skein_256_Process_Block(struct skein_256_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd)
+void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blkPtr,
+			     size_t blkCnt, size_t byteCntAdd)
 {
 	struct threefish_key key;
 	u64 tweak[2];

@@ -34,12 +34,12 @@ void Skein_256_Process_Block(struct skein_256_ctx *ctx, const u8 *blkPtr,
 		tweak[0] |= (words[1] & 0xffffffffL) << 32;
 		tweak[1] |= words[2] & 0xffffffffL;
 
-		threefishSetKey(&key, Threefish256, ctx->X, tweak);
+		threefish_set_key(&key, Threefish256, ctx->X, tweak);
 
 		/* get input block in little-endian format */
 		Skein_Get64_LSB_First(w, blkPtr, SKEIN_256_STATE_WORDS);
 
-		threefishEncryptBlockWords(&key, w, ctx->X);
+		threefish_encrypt_block_words(&key, w, ctx->X);
 
 		blkPtr += SKEIN_256_BLOCK_BYTES;
 

@@ -56,8 +56,8 @@ void Skein_256_Process_Block(struct skein_256_ctx *ctx, const u8 *blkPtr,
 	ctx->h.T[1] = tweak[1];
 }
 
-void Skein_512_Process_Block(struct skein_512_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd)
+void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blkPtr,
+			     size_t blkCnt, size_t byteCntAdd)
 {
 	struct threefish_key key;
 	u64 tweak[2];

@@ -85,12 +85,12 @@ void Skein_512_Process_Block(struct skein_512_ctx *ctx, const u8 *blkPtr,
 		tweak[0] |= (words[1] & 0xffffffffL) << 32;
 		tweak[1] |= words[2] & 0xffffffffL;
 
-		threefishSetKey(&key, Threefish512, ctx->X, tweak);
+		threefish_set_key(&key, Threefish512, ctx->X, tweak);
 
 		/* get input block in little-endian format */
 		Skein_Get64_LSB_First(w, blkPtr, SKEIN_512_STATE_WORDS);
 
-		threefishEncryptBlockWords(&key, w, ctx->X);
+		threefish_encrypt_block_words(&key, w, ctx->X);
 
 		blkPtr += SKEIN_512_BLOCK_BYTES;
 

@@ -111,8 +111,8 @@ void Skein_512_Process_Block(struct skein_512_ctx *ctx, const u8 *blkPtr,
 	ctx->h.T[1] = tweak[1];
 }
 
-void Skein1024_Process_Block(struct skein1024_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd)
+void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blkPtr,
+			      size_t blkCnt, size_t byteCntAdd)
 {
 	struct threefish_key key;
 	u64 tweak[2];

@@ -140,12 +140,12 @@ void Skein1024_Process_Block(struct skein1024_ctx *ctx, const u8 *blkPtr,
 		tweak[0] |= (words[1] & 0xffffffffL) << 32;
 		tweak[1] |= words[2] & 0xffffffffL;
 
-		threefishSetKey(&key, Threefish1024, ctx->X, tweak);
+		threefish_set_key(&key, Threefish1024, ctx->X, tweak);
 
 		/* get input block in little-endian format */
 		Skein_Get64_LSB_First(w, blkPtr, SKEIN1024_STATE_WORDS);
 
-		threefishEncryptBlockWords(&key, w, ctx->X);
+		threefish_encrypt_block_words(&key, w, ctx->X);
 
 		blkPtr += SKEIN1024_BLOCK_BYTES;
 

index fd96ca0..1195aec 100644
@@ -39,8 +39,8 @@
 
 /*****************************  Skein_256 ******************************/
 #if !(SKEIN_USE_ASM & 256)
-void Skein_256_Process_Block(struct skein_256_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd)
+void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blkPtr,
+			     size_t blkCnt, size_t byteCntAdd)
 	{ /* do it in C */
 	enum {
 		WCNT = SKEIN_256_STATE_WORDS

@@ -215,7 +215,7 @@ do { \
 		R256_8_rounds(14);
 	#endif
 	#if  (SKEIN_UNROLL_256 > 14)
-#error  "need more unrolling in Skein_256_Process_Block"
+#error  "need more unrolling in skein_256_process_block"
 	#endif
 		}
 		/* do the final "feedforward" xor, update context chaining */

@@ -233,12 +233,12 @@ do { \
 }
 
 #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF)
-size_t Skein_256_Process_Block_CodeSize(void)
+size_t skein_256_process_block_code_size(void)
 {
-	return ((u8 *) Skein_256_Process_Block_CodeSize) -
-		((u8 *) Skein_256_Process_Block);
+	return ((u8 *) skein_256_process_block_code_size) -
+		((u8 *) skein_256_process_block);
 }
-unsigned int Skein_256_Unroll_Cnt(void)
+unsigned int skein_256_unroll_cnt(void)
 {
 	return SKEIN_UNROLL_256;
 }

@@ -247,8 +247,8 @@ unsigned int Skein_256_Unroll_Cnt(void)
 
 /*****************************  Skein_512 ******************************/
 #if !(SKEIN_USE_ASM & 512)
-void Skein_512_Process_Block(struct skein_512_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd)
+void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blkPtr,
+			     size_t blkCnt, size_t byteCntAdd)
 { /* do it in C */
 	enum {
 		WCNT = SKEIN_512_STATE_WORDS

@@ -441,7 +441,7 @@ do { \
 			R512_8_rounds(14);
 	#endif
 	#if  (SKEIN_UNROLL_512 > 14)
-#error  "need more unrolling in Skein_512_Process_Block"
+#error  "need more unrolling in skein_512_process_block"
 	#endif
 		}
 

@@ -463,12 +463,12 @@ do { \
 }
 
 #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF)
-size_t Skein_512_Process_Block_CodeSize(void)
+size_t skein_512_process_block_code_size(void)
 {
-	return ((u8 *) Skein_512_Process_Block_CodeSize) -
-		((u8 *) Skein_512_Process_Block);
+	return ((u8 *) skein_512_process_block_code_size) -
+		((u8 *) skein_512_process_block);
 }
-unsigned int Skein_512_Unroll_Cnt(void)
+unsigned int skein_512_unroll_cnt(void)
 {
 	return SKEIN_UNROLL_512;
 }

@@ -477,8 +477,8 @@ unsigned int Skein_512_Unroll_Cnt(void)
 
 /*****************************  Skein1024 ******************************/
 #if !(SKEIN_USE_ASM & 1024)
-void Skein1024_Process_Block(struct skein1024_ctx *ctx, const u8 *blkPtr,
-				size_t blkCnt, size_t byteCntAdd)
+void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blkPtr,
+			      size_t blkCnt, size_t byteCntAdd)
 { /* do it in C, always looping (unrolled is bigger AND slower!) */
 	enum {
 		WCNT = SKEIN1024_STATE_WORDS

@@ -757,12 +757,12 @@ do { \
 }
 
 #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF)
-size_t Skein1024_Process_Block_CodeSize(void)
+size_t skein_1024_process_block_code_size(void)
 {
-	return ((u8 *) Skein1024_Process_Block_CodeSize) -
-		((u8 *) Skein1024_Process_Block);
+	return ((u8 *) skein_1024_process_block_code_size) -
+		((u8 *) skein_1024_process_block);
 }
-unsigned int Skein1024_Unroll_Cnt(void)
+unsigned int skein_1024_unroll_cnt(void)
 {
 	return SKEIN_UNROLL_1024;
 }

index fe7517b..113019f 100644
@@ -2,7 +2,8 @@
 #include <threefishApi.h>
 
 
-void threefishEncrypt1024(struct threefish_key *keyCtx, u64 *input, u64 *output)
+void threefish_encrypt_1024(struct threefish_key *keyCtx, u64 *input,
+			    u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
 	  b2 = input[2], b3 = input[3],

@@ -2122,7 +2123,8 @@ void threefishEncrypt1024(struct threefish_key *keyCtx, u64 *input, u64 *output)
 	output[15] = b15 + k1 + 20;
 }
 
-void threefishDecrypt1024(struct threefish_key *keyCtx, u64 *input, u64 *output)
+void threefish_decrypt_1024(struct threefish_key *keyCtx, u64 *input,
+			    u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
 	  b2 = input[2], b3 = input[3],

index 2ae746a..ee21aef 100644
@@ -2,7 +2,8 @@
 #include <threefishApi.h>
 
 
-void threefishEncrypt256(struct threefish_key *keyCtx, u64 *input, u64 *output)
+void threefish_encrypt_256(struct threefish_key *keyCtx, u64 *input,
+			   u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
 	  b2 = input[2], b3 = input[3];

@@ -494,7 +495,8 @@ void threefishEncrypt256(struct threefish_key *keyCtx, u64 *input, u64 *output)
 	output[3] = b3 + k1 + 18;
 }
 
-void threefishDecrypt256(struct threefish_key *keyCtx, u64 *input, u64 *output)
+void threefish_decrypt_256(struct threefish_key *keyCtx, u64 *input,
+			   u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
 	  b2 = input[2], b3 = input[3];

index f428fd6..c4ad1b4 100644
@@ -2,7 +2,8 @@
 #include <threefishApi.h>
 
 
-void threefishEncrypt512(struct threefish_key *keyCtx, u64 *input, u64 *output)
+void threefish_encrypt_512(struct threefish_key *keyCtx, u64 *input,
+			   u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
 	  b2 = input[2], b3 = input[3],

@@ -962,7 +963,8 @@ void threefishEncrypt512(struct threefish_key *keyCtx, u64 *input, u64 *output)
 	output[7] = b7 + k7 + 18;
 }
 
-void threefishDecrypt512(struct threefish_key *keyCtx, u64 *input, u64 *output)
+void threefish_decrypt_512(struct threefish_key *keyCtx, u64 *input,
+			   u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
 	  b2 = input[2], b3 = input[3],

index 1e70f66..fce613b 100644
@@ -3,9 +3,9 @@
 #include <linux/string.h>
 #include <threefishApi.h>
 
-void threefishSetKey(struct threefish_key *keyCtx,
-			enum threefish_size stateSize,
-			u64 *keyData, u64 *tweak)
+void threefish_set_key(struct threefish_key *keyCtx,
+		       enum threefish_size stateSize,
+		       u64 *keyData, u64 *tweak)
 {
 	int keyWords = stateSize / 64;
 	int i;

@@ -23,56 +23,56 @@ void threefishSetKey(struct threefish_key *keyCtx,
 	keyCtx->stateSize = stateSize;
 }
 
-void threefishEncryptBlockBytes(struct threefish_key *keyCtx, u8 *in,
-				u8 *out)
+void threefish_encrypt_block_bytes(struct threefish_key *keyCtx, u8 *in,
+				   u8 *out)
 {
 	u64 plain[SKEIN_MAX_STATE_WORDS];        /* max number of words*/
 	u64 cipher[SKEIN_MAX_STATE_WORDS];
 
 	Skein_Get64_LSB_First(plain, in, keyCtx->stateSize / 64);
-	threefishEncryptBlockWords(keyCtx, plain, cipher);
+	threefish_encrypt_block_words(keyCtx, plain, cipher);
 	Skein_Put64_LSB_First(out, cipher, keyCtx->stateSize / 8);
 }
 
-void threefishEncryptBlockWords(struct threefish_key *keyCtx, u64 *in,
-				u64 *out)
+void threefish_encrypt_block_words(struct threefish_key *keyCtx, u64 *in,
+				   u64 *out)
 {
 	switch (keyCtx->stateSize) {
 	case Threefish256:
-		threefishEncrypt256(keyCtx, in, out);
+		threefish_encrypt_256(keyCtx, in, out);
 		break;
 	case Threefish512:
-		threefishEncrypt512(keyCtx, in, out);
+		threefish_encrypt_512(keyCtx, in, out);
 		break;
 	case Threefish1024:
-		threefishEncrypt1024(keyCtx, in, out);
+		threefish_encrypt_1024(keyCtx, in, out);
 		break;
 	}
 }
 
-void threefishDecryptBlockBytes(struct threefish_key *keyCtx, u8 *in,
-				u8 *out)
+void threefish_decrypt_block_bytes(struct threefish_key *keyCtx, u8 *in,
+				   u8 *out)
 {
 	u64 plain[SKEIN_MAX_STATE_WORDS];        /* max number of words*/
 	u64 cipher[SKEIN_MAX_STATE_WORDS];
 
 	Skein_Get64_LSB_First(cipher, in, keyCtx->stateSize / 64);
-	threefishDecryptBlockWords(keyCtx, cipher, plain);
+	threefish_decrypt_block_words(keyCtx, cipher, plain);
 	Skein_Put64_LSB_First(out, plain, keyCtx->stateSize / 8);
 }
 
-void threefishDecryptBlockWords(struct threefish_key *keyCtx, u64 *in,
-				u64 *out)
+void threefish_decrypt_block_words(struct threefish_key *keyCtx, u64 *in,
+				   u64 *out)
 {
 	switch (keyCtx->stateSize) {
 	case Threefish256:
-		threefishDecrypt256(keyCtx, in, out);
+		threefish_decrypt_256(keyCtx, in, out);
 		break;
 	case Threefish512:
-		threefishDecrypt512(keyCtx, in, out);
+		threefish_decrypt_512(keyCtx, in, out);
 		break;
 	case Threefish1024:
-		threefishDecrypt1024(keyCtx, in, out);
+		threefish_decrypt_1024(keyCtx, in, out);
 		break;
 	}
 }

index 09e96d6..8ecd720 100644
@@ -293,7 +293,7 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
 ** Skein block function constants (shared across Ref and Opt code)
 ******************************************************************/
 enum {
-	    /* Skein_256 round rotation constants */
+	    /* SKEIN_256 round rotation constants */
 	R_256_0_0 = 14, R_256_0_1 = 16,
 	R_256_1_0 = 52, R_256_1_1 = 57,
 	R_256_2_0 = 23, R_256_2_1 = 40,

@@ -303,7 +303,7 @@ enum {
 	R_256_6_0 = 58, R_256_6_1 = 22,
 	R_256_7_0 = 32, R_256_7_1 = 32,
 
-	    /* Skein_512 round rotation constants */
+	    /* SKEIN_512 round rotation constants */
 	R_512_0_0 = 46, R_512_0_1 = 36, R_512_0_2 = 19, R_512_0_3 = 37,
 	R_512_1_0 = 33, R_512_1_1 = 27, R_512_1_2 = 14, R_512_1_3 = 42,
 	R_512_2_0 = 17, R_512_2_1 = 49, R_512_2_2 = 36, R_512_2_3 = 39,

@@ -313,7 +313,7 @@ enum {
 	R_512_6_0 = 25, R_512_6_1 = 29, R_512_6_2 = 39, R_512_6_3 = 43,
 	R_512_7_0 =  8, R_512_7_1 = 35, R_512_7_2 = 56, R_512_7_3 = 22,
 
-	    /* Skein1024 round rotation constants */
+	    /* SKEIN_1024 round rotation constants */
 	R1024_0_0 = 24, R1024_0_1 = 13, R1024_0_2 =  8, R1024_0_3 = 47,
 	R1024_0_4 =  8, R1024_0_5 = 17, R1024_0_6 = 22, R1024_0_7 = 37,
 	R1024_1_0 = 38, R1024_1_1 = 19, R1024_1_2 = 10, R1024_1_3 = 55,

index 850d5c9..b4e879d 100644
@@ -50,7 +50,7 @@ OTHER DEALINGS IN THE SOFTWARE.
  * struct skein_ctx ctx;             // a Skein hash or MAC context
  *
  * // prepare context, here for a Skein with a state size of 512 bits.
- * skein_ctx_prepare(&ctx, Skein512);
+ * skein_ctx_prepare(&ctx, SKEIN_512);
  *
  * // Initialize the context to set the requested hash length in bits
  * // here request a output hash size of 31 bits (Skein supports variable

@@ -85,9 +85,9 @@ OTHER DEALINGS IN THE SOFTWARE.
  * Which Skein size to use
  */
 enum skein_size {
-	Skein256 = 256,     /*!< Skein with 256 bit state */
-	Skein512 = 512,     /*!< Skein with 512 bit state */
-	Skein1024 = 1024    /*!< Skein with 1024 bit state */
+	SKEIN_256 = 256,     /*!< Skein with 256 bit state */
+	SKEIN_512 = 512,     /*!< Skein with 512 bit state */
+	SKEIN_1024 = 1024    /*!< Skein with 1024 bit state */
 };
 
 /**

index 37f6e63..63030e5 100644
@@ -17,14 +17,14 @@
  * functions.
  *
 @code
-    // Threefish cipher context data
-    struct threefish_key key_ctx;
+	// Threefish cipher context data
+	struct threefish_key key_ctx;
 
-    // Initialize the context
-    threefish_set_key(&key_ctx, Threefish512, key, tweak);
+	// Initialize the context
+	threefish_set_key(&key_ctx, THREEFISH_512, key, tweak);
 
-    // Encrypt
-    threefish_encrypt_block_bytes(&key_ctx, input, cipher);
+	// Encrypt
+	threefish_encrypt_block_bytes(&key_ctx, input, cipher);
 @endcode
  */
 

@@ -37,9 +37,9 @@
  * Which Threefish size to use
  */
 enum threefish_size {
-	Threefish256 = 256,     /*!< Skein with 256 bit state */
-	Threefish512 = 512,     /*!< Skein with 512 bit state */
-	Threefish1024 = 1024    /*!< Skein with 1024 bit state */
+	THREEFISH_256 = 256,     /*!< Skein with 256 bit state */
+	THREEFISH_512 = 512,     /*!< Skein with 512 bit state */
+	THREEFISH_1024 = 1024    /*!< Skein with 1024 bit state */
 };
 
 /**

index 3426392..87b3ff2 100644
@@ -57,15 +57,15 @@ int skein_init(struct skein_ctx *ctx, size_t hash_bit_len)
 	 * the save chaining variables.
 	 */
 	switch (ctx->skein_size) {
-	case Skein256:
+	case SKEIN_256:
 		ret = skein_256_init_ext(&ctx->m.s256, hash_bit_len,
 					 tree_info, NULL, 0);
 		break;
-	case Skein512:
+	case SKEIN_512:
 		ret = skein_512_init_ext(&ctx->m.s512, hash_bit_len,
 					 tree_info, NULL, 0);
 		break;
-	case Skein1024:
+	case SKEIN_1024:
 		ret = skein_1024_init_ext(&ctx->m.s1024, hash_bit_len,
 					  tree_info, NULL, 0);
 		break;

@@ -97,18 +97,18 @@ int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t key_len,
 	Skein_Assert(hash_bit_len, SKEIN_BAD_HASHLEN);
 
 	switch (ctx->skein_size) {
-	case Skein256:
+	case SKEIN_256:
 		ret = skein_256_init_ext(&ctx->m.s256, hash_bit_len,
 					 tree_info,
 					 (const u8 *)key, key_len);
 
 		break;
-	case Skein512:
+	case SKEIN_512:
 		ret = skein_512_init_ext(&ctx->m.s512, hash_bit_len,
 					 tree_info,
 					 (const u8 *)key, key_len);
 		break;
-	case Skein1024:
+	case SKEIN_1024:
 		ret = skein_1024_init_ext(&ctx->m.s1024, hash_bit_len,
 					  tree_info,
 					  (const u8 *)key, key_len);

@@ -152,15 +152,15 @@ int skein_update(struct skein_ctx *ctx, const u8 *msg,
 	Skein_Assert(ctx, SKEIN_FAIL);
 
 	switch (ctx->skein_size) {
-	case Skein256:
+	case SKEIN_256:
 		ret = skein_256_update(&ctx->m.s256, (const u8 *)msg,
 				       msg_byte_cnt);
 		break;
-	case Skein512:
+	case SKEIN_512:
 		ret = skein_512_update(&ctx->m.s512, (const u8 *)msg,
 				       msg_byte_cnt);
 		break;
-	case Skein1024:
+	case SKEIN_1024:
 		ret = skein_1024_update(&ctx->m.s1024, (const u8 *)msg,
 					msg_byte_cnt);
 		break;

@@ -225,13 +225,13 @@ int skein_final(struct skein_ctx *ctx, u8 *hash)
 	Skein_Assert(ctx, SKEIN_FAIL);
 
 	switch (ctx->skein_size) {
-	case Skein256:
+	case SKEIN_256:
 		ret = skein_256_final(&ctx->m.s256, (u8 *)hash);
 		break;
-	case Skein512:
+	case SKEIN_512:
 		ret = skein_512_final(&ctx->m.s512, (u8 *)hash);
 		break;
-	case Skein1024:
+	case SKEIN_1024:
 		ret = skein_1024_final(&ctx->m.s1024, (u8 *)hash);
 		break;
 	}

index 55c6831..716b78e 100644
@@ -34,7 +34,7 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
 		tweak[0] |= (words[1] & 0xffffffffL) << 32;
 		tweak[1] |= words[2] & 0xffffffffL;
 
-		threefish_set_key(&key, Threefish256, ctx->X, tweak);
+		threefish_set_key(&key, THREEFISH_256, ctx->X, tweak);
 
 		/* get input block in little-endian format */
 		Skein_Get64_LSB_First(w, blk_ptr, SKEIN_256_STATE_WORDS);

@@ -85,7 +85,7 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
 		tweak[0] |= (words[1] & 0xffffffffL) << 32;
 		tweak[1] |= words[2] & 0xffffffffL;
 
-		threefish_set_key(&key, Threefish512, ctx->X, tweak);
+		threefish_set_key(&key, THREEFISH_512, ctx->X, tweak);
 
 		/* get input block in little-endian format */
 		Skein_Get64_LSB_First(w, blk_ptr, SKEIN_512_STATE_WORDS);

@@ -140,7 +140,7 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 		tweak[0] |= (words[1] & 0xffffffffL) << 32;
 		tweak[1] |= words[2] & 0xffffffffL;
 
-		threefish_set_key(&key, Threefish1024, ctx->X, tweak);
+		threefish_set_key(&key, THREEFISH_1024, ctx->X, tweak);
 
 		/* get input block in little-endian format */
 		Skein_Get64_LSB_First(w, blk_ptr, SKEIN1024_STATE_WORDS);

index c9db6d6..ebd4af1 100644
@@ -37,7 +37,7 @@
 #define DebugSaveTweak(ctx)
 #endif
 
-/*****************************  Skein_256 ******************************/
+/*****************************  SKEIN_256 ******************************/
 #if !(SKEIN_USE_ASM & 256)
 void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
 			     size_t blk_cnt, size_t byte_cnt_add)

@@ -246,7 +246,7 @@ unsigned int skein_256_unroll_cnt(void)
 #endif
 #endif
 
-/*****************************  Skein_512 ******************************/
+/*****************************  SKEIN_512 ******************************/
 #if !(SKEIN_USE_ASM & 512)
 void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
 			     size_t blk_cnt, size_t byte_cnt_add)

@@ -477,7 +477,7 @@ unsigned int skein_512_unroll_cnt(void)
 #endif
 #endif
 
-/*****************************  Skein1024 ******************************/
+/*****************************  SKEIN_1024 ******************************/
 #if !(SKEIN_USE_ASM & 1024)
 void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 			      size_t blk_cnt, size_t byte_cnt_add)

index 67ba9a6..17a314b 100644
@@ -38,13 +38,13 @@ void threefish_encrypt_block_words(struct threefish_key *key_ctx, u64 *in,
 				   u64 *out)
 {
 	switch (key_ctx->state_size) {
-	case Threefish256:
+	case THREEFISH_256:
 		threefish_encrypt_256(key_ctx, in, out);
 		break;
-	case Threefish512:
+	case THREEFISH_512:
 		threefish_encrypt_512(key_ctx, in, out);
 		break;
-	case Threefish1024:
+	case THREEFISH_1024:
 		threefish_encrypt_1024(key_ctx, in, out);
 		break;
 	}

@@ -65,13 +65,13 @@ void threefish_decrypt_block_words(struct threefish_key *key_ctx, u64 *in,
 				   u64 *out)
 {
 	switch (key_ctx->state_size) {
-	case Threefish256:
+	case THREEFISH_256:
 		threefish_decrypt_256(key_ctx, in, out);
 		break;
-	case Threefish512:
+	case THREEFISH_512:
 		threefish_decrypt_512(key_ctx, in, out);
 		break;
-	case Threefish1024:
+	case THREEFISH_1024:
 		threefish_decrypt_1024(key_ctx, in, out);
 		break;
 	}

similarity index 99%
rename from drivers/staging/skein/include/skeinApi.h
rename to drivers/staging/skein/include/skein_api.h
index b4e879d..87f769a 100644
@@ -28,7 +28,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #define SKEINAPI_H
 
 /**
- * @file skeinApi.h
+ * @file skein_api.h
  * @brief A Skein API and its functions.
  * @{
  *

@@ -44,7 +44,7 @@ OTHER DEALINGS IN THE SOFTWARE.
  *
  * @code
  *
- * #include <skeinApi.h>
+ * #include <skein_api.h>
  *
  * ...
  * struct skein_ctx ctx;             // a Skein hash or MAC context

similarity index 99%
rename from drivers/staging/skein/include/threefishApi.h
rename to drivers/staging/skein/include/threefish_api.h
index 96cc0e8..fe28981 100644
@@ -3,7 +3,7 @@
 #define THREEFISHAPI_H
 
 /**
- * @file threefishApi.h
+ * @file threefish_api.h
  * @brief A Threefish cipher API and its functions.
  * @{
  *

similarity index 99%
rename from drivers/staging/skein/skeinApi.c
rename to drivers/staging/skein/skein_api.c
index 16d596b..7fb0160 100644
@@ -25,7 +25,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include <linux/string.h>
-#include <skeinApi.h>
+#include <skein_api.h>
 
 int skein_ctx_prepare(struct skein_ctx *ctx, enum skein_size size)
 {

similarity index 99%
rename from drivers/staging/skein/skeinBlockNo3F.c
rename to drivers/staging/skein/skein_block_no_3f.c
index 4ee7f9f..23a3ac5 100644
@@ -1,7 +1,7 @@
 
 #include <linux/string.h>
 #include <skein.h>
-#include <threefishApi.h>
+#include <threefish_api.h>
 
 
 /*****************************  Skein_256 ******************************/

similarity index 99%
rename from drivers/staging/skein/threefish1024Block.c
rename to drivers/staging/skein/threefish_1024_block.c
index 827ce1a..7ecde26 100644
@@ -1,5 +1,5 @@
 #include <linux/string.h>
-#include <threefishApi.h>
+#include <threefish_api.h>
 
 
 void threefish_encrypt_1024(struct threefish_key *key_ctx, u64 *input,

similarity index 99%
rename from drivers/staging/skein/threefish256Block.c
rename to drivers/staging/skein/threefish_256_block.c
index 1329c71..6bb747c 100644
@@ -1,5 +1,5 @@
 #include <linux/string.h>
-#include <threefishApi.h>
+#include <threefish_api.h>
 
 
 void threefish_encrypt_256(struct threefish_key *key_ctx, u64 *input,

similarity index 99%
rename from drivers/staging/skein/threefish512Block.c
rename to drivers/staging/skein/threefish_512_block.c
index db50d83..68bf5c4 100644
@@ -1,5 +1,5 @@
 #include <linux/string.h>
-#include <threefishApi.h>
+#include <threefish_api.h>
 
 
 void threefish_encrypt_512(struct threefish_key *key_ctx, u64 *input,

similarity index 98%
rename from drivers/staging/skein/threefishApi.c
rename to drivers/staging/skein/threefish_api.c
index 0ba42fa..45769c5 100644
@@ -1,7 +1,7 @@
 
 
 #include <linux/string.h>
-#include <threefishApi.h>
+#include <threefish_api.h>
 
 void threefish_set_key(struct threefish_key *key_ctx,
 		       enum threefish_size state_size,

@@ -76,4 +76,3 @@ void threefish_decrypt_block_words(struct threefish_key *key_ctx, u64 *in,
 		break;
 	}
 }
-

index 8ecd720..2c87ff7 100644
@@ -28,15 +28,15 @@
 **
 ***************************************************************************/
 
-#ifndef RotL_64
-#define RotL_64(x, N)    (((x) << (N)) | ((x) >> (64-(N))))
+#ifndef rotl_64
+#define rotl_64(x, N)    (((x) << (N)) | ((x) >> (64-(N))))
 #endif
 
 /* below two prototype assume we are handed aligned data */
-#define Skein_Put64_LSB_First(dst08, src64, b_cnt) memcpy(dst08, src64, b_cnt)
-#define Skein_Get64_LSB_First(dst64, src08, w_cnt) \
+#define skein_put64_lsb_first(dst08, src64, b_cnt) memcpy(dst08, src64, b_cnt)
+#define skein_get64_lsb_first(dst64, src08, w_cnt) \
 		memcpy(dst64, src08, 8*(w_cnt))
-#define Skein_Swap64(w64)  (w64)
+#define skein_swap64(w64)  (w64)
 
 enum {
 	SKEIN_SUCCESS         =      0, /* return codes from Skein calls */

@@ -48,20 +48,20 @@ enum {
 
 #define  SKEIN_256_STATE_WORDS  (4)
 #define  SKEIN_512_STATE_WORDS  (8)
-#define  SKEIN1024_STATE_WORDS (16)
+#define  SKEIN_1024_STATE_WORDS (16)
 #define  SKEIN_MAX_STATE_WORDS (16)
 
 #define  SKEIN_256_STATE_BYTES  (8*SKEIN_256_STATE_WORDS)
 #define  SKEIN_512_STATE_BYTES  (8*SKEIN_512_STATE_WORDS)
-#define  SKEIN1024_STATE_BYTES  (8*SKEIN1024_STATE_WORDS)
+#define  SKEIN_1024_STATE_BYTES  (8*SKEIN_1024_STATE_WORDS)
 
 #define  SKEIN_256_STATE_BITS  (64*SKEIN_256_STATE_WORDS)
 #define  SKEIN_512_STATE_BITS  (64*SKEIN_512_STATE_WORDS)
-#define  SKEIN1024_STATE_BITS  (64*SKEIN1024_STATE_WORDS)
+#define  SKEIN_1024_STATE_BITS  (64*SKEIN_1024_STATE_WORDS)
 
 #define  SKEIN_256_BLOCK_BYTES  (8*SKEIN_256_STATE_WORDS)
 #define  SKEIN_512_BLOCK_BYTES  (8*SKEIN_512_STATE_WORDS)
-#define  SKEIN1024_BLOCK_BYTES  (8*SKEIN1024_STATE_WORDS)
+#define  SKEIN_1024_BLOCK_BYTES  (8*SKEIN_1024_STATE_WORDS)
 
 struct skein_ctx_hdr {
 	size_t hash_bit_len;		/* size of hash result, in bits */

@@ -83,8 +83,8 @@ struct skein_512_ctx { /* 512-bit Skein hash context structure */
 
 struct skein_1024_ctx { /* 1024-bit Skein hash context structure */
 	struct skein_ctx_hdr h;		/* common header context variables */
-	u64 X[SKEIN1024_STATE_WORDS];	/* chaining variables */
-	u8 b[SKEIN1024_BLOCK_BYTES];	/* partial block buf (8-byte aligned) */
+	u64 X[SKEIN_1024_STATE_WORDS];	/* chaining variables */
+	u8 b[SKEIN_1024_BLOCK_BYTES];	/* partial block buf (8-byte aligned) */
 };
 
 /* Skein APIs for (incremental) "straight hashing" */

@@ -232,44 +232,44 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
 **   Skein macros for getting/setting tweak words, etc.
 **   These are useful for partial input bytes, hash tree init/update, etc.
 **/
-#define Skein_Get_Tweak(ctx_ptr, TWK_NUM)          ((ctx_ptr)->h.T[TWK_NUM])
-#define Skein_Set_Tweak(ctx_ptr, TWK_NUM, t_val) { \
+#define skein_get_tweak(ctx_ptr, TWK_NUM)          ((ctx_ptr)->h.T[TWK_NUM])
+#define skein_set_tweak(ctx_ptr, TWK_NUM, t_val) { \
 		(ctx_ptr)->h.T[TWK_NUM] = (t_val); \
 	}
 
-#define Skein_Get_T0(ctx_ptr)     Skein_Get_Tweak(ctx_ptr, 0)
-#define Skein_Get_T1(ctx_ptr)     Skein_Get_Tweak(ctx_ptr, 1)
-#define Skein_Set_T0(ctx_ptr, T0) Skein_Set_Tweak(ctx_ptr, 0, T0)
-#define Skein_Set_T1(ctx_ptr, T1) Skein_Set_Tweak(ctx_ptr, 1, T1)
+#define skein_get_T0(ctx_ptr)     skein_get_tweak(ctx_ptr, 0)
+#define skein_get_T1(ctx_ptr)     skein_get_tweak(ctx_ptr, 1)
+#define skein_set_T0(ctx_ptr, T0) skein_set_tweak(ctx_ptr, 0, T0)
+#define skein_set_T1(ctx_ptr, T1) skein_set_tweak(ctx_ptr, 1, T1)
 
 /* set both tweak words at once */
-#define Skein_Set_T0_T1(ctx_ptr, T0, T1)           \
-	{                                           \
-	Skein_Set_T0(ctx_ptr, (T0));                  \
-	Skein_Set_T1(ctx_ptr, (T1));                  \
+#define skein_set_T0_T1(ctx_ptr, T0, T1)           \
+	{                                          \
+	skein_set_T0(ctx_ptr, (T0));               \
+	skein_set_T1(ctx_ptr, (T1));               \
 	}
 
-#define Skein_Set_Type(ctx_ptr, BLK_TYPE)         \
-	Skein_Set_T1(ctx_ptr, SKEIN_T1_BLK_TYPE_##BLK_TYPE)
+#define skein_set_type(ctx_ptr, BLK_TYPE)         \
+	skein_set_T1(ctx_ptr, SKEIN_T1_BLK_TYPE_##BLK_TYPE)
 
 /*
  * setup for starting with a new type:
  * h.T[0]=0; h.T[1] = NEW_TYPE; h.b_cnt=0;
  */
-#define Skein_Start_New_Type(ctx_ptr, BLK_TYPE) { \
-		Skein_Set_T0_T1(ctx_ptr, 0, SKEIN_T1_FLAG_FIRST | \
+#define skein_start_new_type(ctx_ptr, BLK_TYPE) { \
+		skein_set_T0_T1(ctx_ptr, 0, SKEIN_T1_FLAG_FIRST | \
 				SKEIN_T1_BLK_TYPE_##BLK_TYPE); \
 		(ctx_ptr)->h.b_cnt = 0; \
 	}
 
-#define Skein_Clear_First_Flag(hdr) { \
+#define skein_clear_first_flag(hdr) { \
 		(hdr).T[1] &= ~SKEIN_T1_FLAG_FIRST; \
 	}
-#define Skein_Set_Bit_Pad_Flag(hdr) { \
+#define skein_set_bit_pad_flag(hdr) { \
 		(hdr).T[1] |=  SKEIN_T1_FLAG_BIT_PAD; \
 	}
 
-#define Skein_Set_Tree_Level(hdr, height) { \
+#define skein_set_tree_level(hdr, height) { \
 		(hdr).T[1] |= SKEIN_T1_TREE_LEVEL(height); \
 	}
 

@@ -279,15 +279,16 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
 #ifdef SKEIN_DEBUG             /* examine/display intermediate values? */
 #include "skein_debug.h"
 #else                           /* default is no callouts */
-#define Skein_Show_Block(bits, ctx, X, blk_ptr, w_ptr, ks_event_ptr, ks_odd_ptr)
-#define Skein_Show_Round(bits, ctx, r, X)
-#define Skein_Show_R_Ptr(bits, ctx, r, X_ptr)
-#define Skein_Show_Final(bits, ctx, cnt, out_ptr)
-#define Skein_Show_Key(bits, ctx, key, key_bytes)
+#define skein_show_block(bits, ctx, X, blk_ptr, w_ptr, ks_event_ptr, ks_odd_ptr)
+#define skein_show_round(bits, ctx, r, X)
+#define skein_show_r_ptr(bits, ctx, r, X_ptr)
+#define skein_show_final(bits, ctx, cnt, out_ptr)
+#define skein_show_key(bits, ctx, key, key_bytes)
 #endif
 
-#define Skein_Assert(x, ret_code)/* ignore all Asserts, for performance */
-#define Skein_assert(x)
+/* ignore all asserts, for performance */
+#define skein_assert_ret(x, ret_code)
+#define skein_assert(x)
 
 /*****************************************************************
 ** Skein block function constants (shared across Ref and Opt code)

@@ -335,11 +336,11 @@ enum {
 #ifndef SKEIN_ROUNDS
 #define SKEIN_256_ROUNDS_TOTAL (72)	/* # rounds for diff block sizes */
 #define SKEIN_512_ROUNDS_TOTAL (72)
-#define SKEIN1024_ROUNDS_TOTAL (80)
+#define SKEIN_1024_ROUNDS_TOTAL (80)
 #else			/* allow command-line define in range 8*(5..14)   */
 #define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5))
 #define SKEIN_512_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/10)  + 5) % 10) + 5))
-#define SKEIN1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS)     + 5) % 10) + 5))
+#define SKEIN_1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS)     + 5) % 10) + 5))
 #endif
 
 #endif  /* ifndef _SKEIN_H_ */

index 8dd5e4d..7ff93df 100644
@@ -124,7 +124,7 @@ const u64 SKEIN_512_IV_512[] = {
 };
 
 /* blkSize = 1024 bits. hashSize =  384 bits */
-const u64 SKEIN1024_IV_384[] = {
+const u64 SKEIN_1024_IV_384[] = {
 	MK_64(0x5102B6B8, 0xC1894A35),
 	MK_64(0xFEEBC9E3, 0xFE8AF11A),
 	MK_64(0x0C807F06, 0xE32BED71),

@@ -144,7 +144,7 @@ const u64 SKEIN1024_IV_384[] = {
 };
 
 /* blkSize = 1024 bits. hashSize =  512 bits */
-const u64 SKEIN1024_IV_512[] = {
+const u64 SKEIN_1024_IV_512[] = {
 	MK_64(0xCAEC0E5D, 0x7C1B1B18),
 	MK_64(0xA01B0E04, 0x5F03E802),
 	MK_64(0x33840451, 0xED912885),

@@ -164,7 +164,7 @@ const u64 SKEIN1024_IV_512[] = {
 };
 
 /* blkSize = 1024 bits. hashSize = 1024 bits */
-const u64 SKEIN1024_IV_1024[] = {
+const u64 SKEIN_1024_IV_1024[] = {
 	MK_64(0xD593DA07, 0x41E72355),
 	MK_64(0x15B5E511, 0xAC73E00C),
 	MK_64(0x5180E5AE, 0xBAF2C4F0),

index 63030e5..96cc0e8 100644
@@ -31,7 +31,7 @@
 #include <linux/types.h>
 #include <skein.h>
 
-#define KeyScheduleConst 0x1BD11BDAA9FC1A22L
+#define KEY_SCHEDULE_CONST 0x1BD11BDAA9FC1A22L
 
 /**
  * Which Threefish size to use

683 lines not on this page · raw message

index 87b3ff2..16d596b 100644
@@ -29,7 +29,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 int skein_ctx_prepare(struct skein_ctx *ctx, enum skein_size size)
 {
-	Skein_Assert(ctx && size, SKEIN_FAIL);
+	skein_assert_ret(ctx && size, SKEIN_FAIL);
 
 	memset(ctx , 0, sizeof(struct skein_ctx));
 	ctx->skein_size = size;

@@ -44,7 +44,7 @@ int skein_init(struct skein_ctx *ctx, size_t hash_bit_len)
 	u64 *X = NULL;
 	u64 tree_info = SKEIN_CFG_TREE_INFO_SEQUENTIAL;
 
-	Skein_Assert(ctx, SKEIN_FAIL);
+	skein_assert_ret(ctx, SKEIN_FAIL);
 	/*
 	 * The following two lines rely of the fact that the real Skein
 	 * contexts are a union in out context and thus have tha maximum

@@ -89,12 +89,12 @@ int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t key_len,
 	size_t X_len = 0;
 	u64 tree_info = SKEIN_CFG_TREE_INFO_SEQUENTIAL;
 
-	Skein_Assert(ctx, SKEIN_FAIL);
+	skein_assert_ret(ctx, SKEIN_FAIL);
 
 	X = ctx->m.s256.X;
 	X_len = ctx->skein_size/8;
 
-	Skein_Assert(hash_bit_len, SKEIN_BAD_HASHLEN);
+	skein_assert_ret(hash_bit_len, SKEIN_BAD_HASHLEN);
 
 	switch (ctx->skein_size) {
 	case SKEIN_256:

@@ -141,7 +141,7 @@ void skein_reset(struct skein_ctx *ctx)
 	memcpy(X, ctx->X_save, X_len);
 
 	/* Setup context to process the message */
-	Skein_Start_New_Type(&ctx->m, MSG);
+	skein_start_new_type(&ctx->m, MSG);
 }
 
 int skein_update(struct skein_ctx *ctx, const u8 *msg,

@@ -149,7 +149,7 @@ int skein_update(struct skein_ctx *ctx, const u8 *msg,
 {
 	int ret = SKEIN_FAIL;
 
-	Skein_Assert(ctx, SKEIN_FAIL);
+	skein_assert_ret(ctx, SKEIN_FAIL);
 
 	switch (ctx->skein_size) {
 	case SKEIN_256:

@@ -185,8 +185,8 @@ int skein_update_bits(struct skein_ctx *ctx, const u8 *msg,
 	 * only the final Update() call is allowed do partial bytes, else
 	 * assert an error
 	 */
-	Skein_Assert((ctx->m.h.T[1] & SKEIN_T1_FLAG_BIT_PAD) == 0 ||
-			msg_bit_cnt == 0, SKEIN_FAIL);
+	skein_assert_ret((ctx->m.h.T[1] & SKEIN_T1_FLAG_BIT_PAD) == 0 ||
+			 msg_bit_cnt == 0, SKEIN_FAIL);
 
 	/* if number of bits is a multiple of bytes - that's easy */
 	if ((msg_bit_cnt & 0x7) == 0)

@@ -203,13 +203,13 @@ int skein_update_bits(struct skein_ctx *ctx, const u8 *msg,
 	up = (u8 *)ctx->m.s256.X + ctx->skein_size / 8;
 
 	/* set tweak flag for the skein_final call */
-	Skein_Set_Bit_Pad_Flag(ctx->m.h);
+	skein_set_bit_pad_flag(ctx->m.h);
 
 	/* now "pad" the final partial byte the way NIST likes */
 	/* get the b_cnt value (same location for all block sizes) */
 	length = ctx->m.h.b_cnt;
 	/* internal sanity check: there IS a partial byte in the buffer! */
-	Skein_assert(length != 0);
+	skein_assert(length != 0);
 	/* partial byte bit mask */
 	mask = (u8) (1u << (7 - (msg_bit_cnt & 7)));
 	/* apply bit padding on final byte (in the buffer) */

@@ -222,7 +222,7 @@ int skein_final(struct skein_ctx *ctx, u8 *hash)
 {
 	int ret = SKEIN_FAIL;
 
-	Skein_Assert(ctx, SKEIN_FAIL);
+	skein_assert_ret(ctx, SKEIN_FAIL);
 
 	switch (ctx->skein_size) {
 	case SKEIN_256:

index 716b78e..4ee7f9f 100644
@@ -11,10 +11,10 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
 	struct threefish_key key;
 	u64 tweak[2];
 	int i;
-	u64  w[SKEIN_256_STATE_WORDS]; /* local copy of input block */
+	u64 w[SKEIN_256_STATE_WORDS]; /* local copy of input block */
 	u64 words[3];
 
-	Skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
+	skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
 	tweak[0] = ctx->h.T[0];
 	tweak[1] = ctx->h.T[1];
 

@@ -37,7 +37,7 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
 		threefish_set_key(&key, THREEFISH_256, ctx->X, tweak);
 
 		/* get input block in little-endian format */
-		Skein_Get64_LSB_First(w, blk_ptr, SKEIN_256_STATE_WORDS);
+		skein_get64_lsb_first(w, blk_ptr, SKEIN_256_STATE_WORDS);
 
 		threefish_encrypt_block_words(&key, w, ctx->X);
 

@@ -63,9 +63,9 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
 	u64 tweak[2];
 	int i;
 	u64 words[3];
-	u64  w[SKEIN_512_STATE_WORDS]; /* local copy of input block */
+	u64 w[SKEIN_512_STATE_WORDS]; /* local copy of input block */
 
-	Skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
+	skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
 	tweak[0] = ctx->h.T[0];
 	tweak[1] = ctx->h.T[1];
 

@@ -88,7 +88,7 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
 		threefish_set_key(&key, THREEFISH_512, ctx->X, tweak);
 
 		/* get input block in little-endian format */
-		Skein_Get64_LSB_First(w, blk_ptr, SKEIN_512_STATE_WORDS);
+		skein_get64_lsb_first(w, blk_ptr, SKEIN_512_STATE_WORDS);
 
 		threefish_encrypt_block_words(&key, w, ctx->X);
 

@@ -118,9 +118,9 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 	u64 tweak[2];
 	int i;
 	u64 words[3];
-	u64  w[SKEIN1024_STATE_WORDS]; /* local copy of input block */
+	u64 w[SKEIN_1024_STATE_WORDS]; /* local copy of input block */
 
-	Skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
+	skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
 	tweak[0] = ctx->h.T[0];
 	tweak[1] = ctx->h.T[1];
 

@@ -143,11 +143,11 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 		threefish_set_key(&key, THREEFISH_1024, ctx->X, tweak);
 
 		/* get input block in little-endian format */
-		Skein_Get64_LSB_First(w, blk_ptr, SKEIN1024_STATE_WORDS);
+		skein_get64_lsb_first(w, blk_ptr, SKEIN_1024_STATE_WORDS);
 
 		threefish_encrypt_block_words(&key, w, ctx->X);
 
-		blk_ptr += SKEIN1024_BLOCK_BYTES;
+		blk_ptr += SKEIN_1024_BLOCK_BYTES;
 
 		/* do the final "feedforward" xor, update ctx chaining vars */
 		ctx->X[0]  = ctx->X[0]  ^ w[0];

562 lines not on this page · raw message

index 17a314b..0ba42fa 100644
@@ -9,7 +9,7 @@ void threefish_set_key(struct threefish_key *key_ctx,
 {
 	int key_words = state_size / 64;
 	int i;
-	u64 parity = KeyScheduleConst;
+	u64 parity = KEY_SCHEDULE_CONST;
 
 	key_ctx->tweak[0] = tweak[0];
 	key_ctx->tweak[1] = tweak[1];

@@ -29,9 +29,9 @@ void threefish_encrypt_block_bytes(struct threefish_key *key_ctx, u8 *in,
 	u64 plain[SKEIN_MAX_STATE_WORDS];        /* max number of words*/
 	u64 cipher[SKEIN_MAX_STATE_WORDS];
 
-	Skein_Get64_LSB_First(plain, in, key_ctx->state_size / 64);
+	skein_get64_lsb_first(plain, in, key_ctx->state_size / 64);
 	threefish_encrypt_block_words(key_ctx, plain, cipher);
-	Skein_Put64_LSB_First(out, cipher, key_ctx->state_size / 8);
+	skein_put64_lsb_first(out, cipher, key_ctx->state_size / 8);
 }
 
 void threefish_encrypt_block_words(struct threefish_key *key_ctx, u64 *in,

@@ -56,9 +56,9 @@ void threefish_decrypt_block_bytes(struct threefish_key *key_ctx, u8 *in,
 	u64 plain[SKEIN_MAX_STATE_WORDS];        /* max number of words*/
 	u64 cipher[SKEIN_MAX_STATE_WORDS];
 
-	Skein_Get64_LSB_First(cipher, in, key_ctx->state_size / 64);
+	skein_get64_lsb_first(cipher, in, key_ctx->state_size / 64);
 	threefish_decrypt_block_words(key_ctx, cipher, plain);
-	Skein_Put64_LSB_First(out, plain, key_ctx->state_size / 8);
+	skein_put64_lsb_first(out, plain, key_ctx->state_size / 8);
 }
 
 void threefish_decrypt_block_words(struct threefish_key *key_ctx, u64 *in,

index deaa9c8..09e96d6 100644
@@ -81,7 +81,7 @@ struct skein_512_ctx { /* 512-bit Skein hash context structure */
 	u8 b[SKEIN_512_BLOCK_BYTES];	/* partial block buf (8-byte aligned) */
 };
 
-struct skein1024_ctx { /* 1024-bit Skein hash context structure */
+struct skein_1024_ctx { /* 1024-bit Skein hash context structure */
 	struct skein_ctx_hdr h;		/* common header context variables */
 	u64 X[SKEIN1024_STATE_WORDS];	/* chaining variables */
 	u8 b[SKEIN1024_BLOCK_BYTES];	/* partial block buf (8-byte aligned) */

@@ -90,18 +90,18 @@ struct skein1024_ctx { /* 1024-bit Skein hash context structure */
 /* Skein APIs for (incremental) "straight hashing" */
 int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len);
 int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len);
-int skein_1024_init(struct skein1024_ctx *ctx, size_t hash_bit_len);
+int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len);
 
 int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg,
 		     size_t msg_byte_cnt);
 int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg,
 		     size_t msg_byte_cnt);
-int skein_1024_update(struct skein1024_ctx *ctx, const u8 *msg,
+int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg,
 		      size_t msg_byte_cnt);
 
 int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val);
 int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val);
-int skein_1024_final(struct skein1024_ctx *ctx, u8 *hash_val);
+int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val);
 
 /*
 **   Skein APIs for "extended" initialization: MAC keys, tree hashing.

@@ -121,7 +121,7 @@ int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hash_bit_len,
 		       u64 tree_info, const u8 *key, size_t key_bytes);
 int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hash_bit_len,
 		       u64 tree_info, const u8 *key, size_t key_bytes);
-int skein_1024_init_ext(struct skein1024_ctx *ctx, size_t hash_bit_len,
+int skein_1024_init_ext(struct skein_1024_ctx *ctx, size_t hash_bit_len,
 			u64 tree_info, const u8 *key, size_t key_bytes);
 
 /*

@@ -131,7 +131,7 @@ int skein_1024_init_ext(struct skein1024_ctx *ctx, size_t hash_bit_len,
 */
 int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hash_val);
 int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val);
-int skein_1024_final_pad(struct skein1024_ctx *ctx, u8 *hash_val);
+int skein_1024_final_pad(struct skein_1024_ctx *ctx, u8 *hash_val);
 
 #ifndef SKEIN_TREE_HASH
 #define SKEIN_TREE_HASH (1)

@@ -139,7 +139,7 @@ int skein_1024_final_pad(struct skein1024_ctx *ctx, u8 *hash_val);
 #if  SKEIN_TREE_HASH
 int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val);
 int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val);
-int skein_1024_output(struct skein1024_ctx *ctx, u8 *hash_val);
+int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
 #endif
 
 /*****************************************************************

index 11ecab8..850d5c9 100644
@@ -105,7 +105,7 @@ struct skein_ctx {
 		struct skein_ctx_hdr h;
 		struct skein_256_ctx s256;
 		struct skein_512_ctx s512;
-		struct skein1024_ctx s1024;
+		struct skein_1024_ctx s1024;
 	} m;
 };
 

index ec787a3..a8dd083 100644
@@ -16,7 +16,7 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
 			     size_t blk_cnt, size_t byte_cnt_add);
 void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
 			     size_t blk_cnt, size_t byte_cnt_add);
-void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blk_ptr,
+void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 			      size_t blk_cnt, size_t byte_cnt_add);
 
 #endif

index d4f3534..43e7757 100644
@@ -476,7 +476,7 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val)
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 /* init the context for a straight hashing operation  */
-int skein_1024_init(struct skein1024_ctx *ctx, size_t hash_bit_len)
+int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len)
 {
 	union {
 		u8 b[SKEIN1024_STATE_BYTES];

@@ -531,7 +531,7 @@ int skein_1024_init(struct skein1024_ctx *ctx, size_t hash_bit_len)
 /* init the context for a MAC and/or tree hash operation */
 /* [identical to skein_1024_init() when key_bytes == 0 && \
  *	tree_info == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */
-int skein_1024_init_ext(struct skein1024_ctx *ctx, size_t hash_bit_len,
+int skein_1024_init_ext(struct skein_1024_ctx *ctx, size_t hash_bit_len,
 			u64 tree_info, const u8 *key, size_t key_bytes)
 {
 	union {

@@ -592,7 +592,7 @@ int skein_1024_init_ext(struct skein1024_ctx *ctx, size_t hash_bit_len,
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 /* process the input bytes */
-int skein_1024_update(struct skein1024_ctx *ctx, const u8 *msg,
+int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg,
 		      size_t msg_byte_cnt)
 {
 	size_t n;

@@ -647,7 +647,7 @@ int skein_1024_update(struct skein1024_ctx *ctx, const u8 *msg,
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 /* finalize the hash computation and output the result */
-int skein_1024_final(struct skein1024_ctx *ctx, u8 *hash_val)
+int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val)
 {
 	size_t i, n, byte_cnt;
 	u64 X[SKEIN1024_STATE_WORDS];

@@ -743,7 +743,7 @@ int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val)
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 /* finalize the hash computation and output the block, no OUTPUT stage */
-int skein_1024_final_pad(struct skein1024_ctx *ctx, u8 *hash_val)
+int skein_1024_final_pad(struct skein_1024_ctx *ctx, u8 *hash_val)
 {
 	/* catch uninitialized context */
 	Skein_Assert(ctx->h.b_cnt <= SKEIN1024_BLOCK_BYTES, SKEIN_FAIL);

@@ -844,7 +844,7 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val)
 
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 /* just do the OUTPUT stage                                       */
-int skein_1024_output(struct skein1024_ctx *ctx, u8 *hash_val)
+int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val)
 {
 	size_t i, n, byte_cnt;
 	u64 X[SKEIN1024_STATE_WORDS];

index 041e5ae..55c6831 100644
@@ -111,7 +111,7 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
 	ctx->h.T[1] = tweak[1];
 }
 
-void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blk_ptr,
+void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 			      size_t blk_cnt, size_t byte_cnt_add)
 {
 	struct threefish_key key;

index a51aa57..c9db6d6 100644
@@ -479,7 +479,7 @@ unsigned int skein_512_unroll_cnt(void)
 
 /*****************************  Skein1024 ******************************/
 #if !(SKEIN_USE_ASM & 1024)
-void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blk_ptr,
+void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
 			      size_t blk_cnt, size_t byte_cnt_add)
 { /* do it in C, always looping (unrolled is bigger AND slower!) */
 	enum {

217 lines not on this page · raw message

index ea54546..11ecab8 100644
@@ -59,7 +59,7 @@ OTHER DEALINGS IN THE SOFTWARE.
  *
  * // Now update Skein with any number of message bits. A function that
  * // takes a number of bytes is also available.
- * skein_update_bits(&ctx, message, msgLength);
+ * skein_update_bits(&ctx, message, msg_length);
  *
  * // Now get the result of the Skein hash. The output buffer must be
  * // large enough to hold the request number of output bits. The application

@@ -99,8 +99,8 @@ enum skein_size {
  * structures as well.
  */
 struct skein_ctx {
-	u64 skeinSize;
-	u64  XSave[SKEIN_MAX_STATE_WORDS];   /* save area for state variables */
+	u64 skein_size;
+	u64 X_save[SKEIN_MAX_STATE_WORDS];   /* save area for state variables */
 	union {
 		struct skein_ctx_hdr h;
 		struct skein_256_ctx s256;

@@ -133,13 +133,13 @@ int skein_ctx_prepare(struct skein_ctx *ctx, enum skein_size size);
  *
  * @param ctx
  *     Pointer to a Skein context.
- * @param hashBitLen
+ * @param hash_bit_len
  *     Number of MAC hash bits to compute
  * @return
  *     SKEIN_SUCESS of SKEIN_FAIL
  * @see skein_reset
  */
-int skein_init(struct skein_ctx *ctx, size_t hashBitLen);
+int skein_init(struct skein_ctx *ctx, size_t hash_bit_len);
 
 /**
  * Resets a Skein context for further use.

@@ -166,15 +166,15 @@ void skein_reset(struct skein_ctx *ctx);
  *     Pointer to an empty or preinitialized Skein MAC context
  * @param key
  *     Pointer to key bytes or NULL
- * @param keyLen
+ * @param key_len
  *     Length of the key in bytes or zero
- * @param hashBitLen
+ * @param hash_bit_len
  *     Number of MAC hash bits to compute
  * @return
  *     SKEIN_SUCESS of SKEIN_FAIL
  */
-int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
-		   size_t hashBitLen);
+int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t key_len,
+		   size_t hash_bit_len);
 
 /**
  * Update Skein with the next part of the message.

@@ -183,13 +183,13 @@ int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
  *     Pointer to initialized Skein context
  * @param msg
  *     Pointer to the message.
- * @param msgByteCnt
+ * @param msg_byte_cnt
  *     Length of the message in @b bytes
  * @return
  *     Success or error code.
  */
 int skein_update(struct skein_ctx *ctx, const u8 *msg,
-		 size_t msgByteCnt);
+		 size_t msg_byte_cnt);
 
 /**
  * Update the hash with a message bit string.

@@ -201,11 +201,11 @@ int skein_update(struct skein_ctx *ctx, const u8 *msg,
  *     Pointer to initialized Skein context
  * @param msg
  *     Pointer to the message.
- * @param msgBitCnt
+ * @param msg_bit_cnt
  *     Length of the message in @b bits.
  */
 int skein_update_bits(struct skein_ctx *ctx, const u8 *msg,
-		      size_t msgBitCnt);
+		      size_t msg_bit_cnt);
 
 /**
  * Finalize Skein and return the hash.

@@ -217,7 +217,7 @@ int skein_update_bits(struct skein_ctx *ctx, const u8 *msg,
  *     Pointer to initialized Skein context
  * @param hash
  *     Pointer to buffer that receives the hash. The buffer must be large
- *     enough to store @c hashBitLen bits.
+ *     enough to store @c hash_bit_len bits.
  * @return
  *     Success or error code.
  * @see skein_reset

index 41cae89..ec787a3 100644
@@ -12,11 +12,11 @@
 
 #include <skein.h> /* get the Skein API definitions   */
 
-void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blkPtr,
-			     size_t blkCnt, size_t byteCntAdd);
-void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blkPtr,
-			     size_t blkCnt, size_t byteCntAdd);
-void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blkPtr,
-			      size_t blkCnt, size_t byteCntAdd);
+void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
+			     size_t blk_cnt, size_t byte_cnt_add);
+void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
+			     size_t blk_cnt, size_t byte_cnt_add);
+void skein_1024_process_block(struct skein1024_ctx *ctx, const u8 *blk_ptr,
+			      size_t blk_cnt, size_t byte_cnt_add);
 
 #endif

153 lines not on this page · raw message

932 lines not on this page · raw message

231 lines not on this page · raw message

133 lines not on this page · raw message

318 lines not on this page · raw message

94 lines not on this page · raw message

index ee21aef..1329c71 100644
@@ -2,16 +2,16 @@
 #include <threefishApi.h>
 
 
-void threefish_encrypt_256(struct threefish_key *keyCtx, u64 *input,
+void threefish_encrypt_256(struct threefish_key *key_ctx, u64 *input,
 			   u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
-	  b2 = input[2], b3 = input[3];
-	u64 k0 = keyCtx->key[0], k1 = keyCtx->key[1],
-	  k2 = keyCtx->key[2], k3 = keyCtx->key[3],
-	  k4 = keyCtx->key[4];
-	u64 t0 = keyCtx->tweak[0], t1 = keyCtx->tweak[1],
-	  t2 = keyCtx->tweak[2];
+	    b2 = input[2], b3 = input[3];
+	u64 k0 = key_ctx->key[0], k1 = key_ctx->key[1],
+	    k2 = key_ctx->key[2], k3 = key_ctx->key[3],
+	    k4 = key_ctx->key[4];
+	u64 t0 = key_ctx->tweak[0], t1 = key_ctx->tweak[1],
+	    t2 = key_ctx->tweak[2];
 
 	b1 += k1 + t0;
 	b0 += b1 + k0;

@@ -495,16 +495,16 @@ void threefish_encrypt_256(struct threefish_key *keyCtx, u64 *input,
 	output[3] = b3 + k1 + 18;
 }
 
-void threefish_decrypt_256(struct threefish_key *keyCtx, u64 *input,
+void threefish_decrypt_256(struct threefish_key *key_ctx, u64 *input,
 			   u64 *output)
 {
 	u64 b0 = input[0], b1 = input[1],
-	  b2 = input[2], b3 = input[3];
-	u64 k0 = keyCtx->key[0], k1 = keyCtx->key[1],
-	  k2 = keyCtx->key[2], k3 = keyCtx->key[3],
-	  k4 = keyCtx->key[4];
-	u64 t0 = keyCtx->tweak[0], t1 = keyCtx->tweak[1],
-	  t2 = keyCtx->tweak[2];
+	    b2 = input[2], b3 = input[3];
+	u64 k0 = key_ctx->key[0], k1 = key_ctx->key[1],
+	    k2 = key_ctx->key[2], k3 = key_ctx->key[3],
+	    k4 = key_ctx->key[4];
+	u64 t0 = key_ctx->tweak[0], t1 = key_ctx->tweak[1],
+	    t2 = key_ctx->tweak[2];
 
 	u64 tmp;
 

62 lines not on this page · raw message

106 lines not on this page · raw message