Skip to content

L
linux
Commit 0264b7b7 authored by Anton Saraev's avatar Anton Saraev Committed by Greg Kroah-Hartman
Browse files
Options

staging: crypto: skein: rename macros 

Mixing upper and lower case in names of macros like It_Is_Macro is
not accepted in the Linux Kernel. To prepare skein driver for mainline
inclusion, we rename all macros to uppercase or lowercase names.
Signed-off-by: default avatarAnton Saraev <antonysaraev@gmail.com>
Reviewed-by: default avatarJake Edge <jake@lwn.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 9435d3ac
Hide whitespace changes
Inline Side-by-side
Showing with 353 additions and 352 deletions
drivers/staging/skein/include/skein.h
View file @ 0264b7b7
...@@ -28,15 +28,15 @@ ...@@ -28,15 +28,15 @@
** **
***************************************************************************/ ***************************************************************************/
#ifndef RotL_64 #ifndef rotl_64
#define RotL_64(x, N) (((x) << (N)) | ((x) >> (64-(N)))) #define rotl_64(x, N) (((x) << (N)) | ((x) >> (64-(N))))
#endif #endif
/* below two prototype assume we are handed aligned data */ /* 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_put64_lsb_first(dst08, src64, b_cnt) memcpy(dst08, src64, b_cnt)
#define Skein_Get64_LSB_First(dst64, src08, w_cnt) \ #define skein_get64_lsb_first(dst64, src08, w_cnt) \
memcpy(dst64, src08, 8*(w_cnt)) memcpy(dst64, src08, 8*(w_cnt))
#define Skein_Swap64(w64) (w64) #define skein_swap64(w64) (w64)
enum { enum {
SKEIN_SUCCESS = 0, /* return codes from Skein calls */ SKEIN_SUCCESS = 0, /* return codes from Skein calls */
...@@ -48,20 +48,20 @@ enum { ...@@ -48,20 +48,20 @@ enum {
#define SKEIN_256_STATE_WORDS (4) #define SKEIN_256_STATE_WORDS (4)
#define SKEIN_512_STATE_WORDS (8) #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_MAX_STATE_WORDS (16)
#define SKEIN_256_STATE_BYTES (8*SKEIN_256_STATE_WORDS) #define SKEIN_256_STATE_BYTES (8*SKEIN_256_STATE_WORDS)
#define SKEIN_512_STATE_BYTES (8*SKEIN_512_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_256_STATE_BITS (64*SKEIN_256_STATE_WORDS)
#define SKEIN_512_STATE_BITS (64*SKEIN_512_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_256_BLOCK_BYTES (8*SKEIN_256_STATE_WORDS)
#define SKEIN_512_BLOCK_BYTES (8*SKEIN_512_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 { struct skein_ctx_hdr {
size_t hash_bit_len; /* size of hash result, in bits */ 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 */ ...@@ -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_1024_ctx { /* 1024-bit Skein hash context structure */
struct skein_ctx_hdr h; /* common header context variables */ struct skein_ctx_hdr h; /* common header context variables */
u64 X[SKEIN1024_STATE_WORDS]; /* chaining variables */ u64 X[SKEIN_1024_STATE_WORDS]; /* chaining variables */
u8 b[SKEIN1024_BLOCK_BYTES]; /* partial block buf (8-byte aligned) */ u8 b[SKEIN_1024_BLOCK_BYTES]; /* partial block buf (8-byte aligned) */
}; };
/* Skein APIs for (incremental) "straight hashing" */ /* Skein APIs for (incremental) "straight hashing" */
...@@ -232,44 +232,44 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val); ...@@ -232,44 +232,44 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
** Skein macros for getting/setting tweak words, etc. ** Skein macros for getting/setting tweak words, etc.
** These are useful for partial input bytes, hash tree init/update, 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_get_tweak(ctx_ptr, TWK_NUM) ((ctx_ptr)->h.T[TWK_NUM])
#define Skein_Set_Tweak(ctx_ptr, TWK_NUM, t_val) { \ #define skein_set_tweak(ctx_ptr, TWK_NUM, t_val) { \
(ctx_ptr)->h.T[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_T0(ctx_ptr) skein_get_tweak(ctx_ptr, 0)
#define Skein_Get_T1(ctx_ptr) Skein_Get_Tweak(ctx_ptr, 1) #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_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_set_T1(ctx_ptr, T1) skein_set_tweak(ctx_ptr, 1, T1)
/* set both tweak words at once */ /* set both tweak words at once */
#define Skein_Set_T0_T1(ctx_ptr, T0, T1) \ #define skein_set_T0_T1(ctx_ptr, T0, T1) \
{ \ { \
Skein_Set_T0(ctx_ptr, (T0)); \ skein_set_T0(ctx_ptr, (T0)); \
Skein_Set_T1(ctx_ptr, (T1)); \ skein_set_T1(ctx_ptr, (T1)); \
} }
#define Skein_Set_Type(ctx_ptr, BLK_TYPE) \ #define skein_set_type(ctx_ptr, BLK_TYPE) \
Skein_Set_T1(ctx_ptr, SKEIN_T1_BLK_TYPE_##BLK_TYPE) skein_set_T1(ctx_ptr, SKEIN_T1_BLK_TYPE_##BLK_TYPE)
/* /*
* setup for starting with a new type: * setup for starting with a new type:
* h.T[0]=0; h.T[1] = NEW_TYPE; h.b_cnt=0; * h.T[0]=0; h.T[1] = NEW_TYPE; h.b_cnt=0;
*/ */
#define Skein_Start_New_Type(ctx_ptr, BLK_TYPE) { \ #define skein_start_new_type(ctx_ptr, BLK_TYPE) { \
Skein_Set_T0_T1(ctx_ptr, 0, SKEIN_T1_FLAG_FIRST | \ skein_set_T0_T1(ctx_ptr, 0, SKEIN_T1_FLAG_FIRST | \
SKEIN_T1_BLK_TYPE_##BLK_TYPE); \ SKEIN_T1_BLK_TYPE_##BLK_TYPE); \
(ctx_ptr)->h.b_cnt = 0; \ (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; \ (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; \ (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); \ (hdr).T[1] |= SKEIN_T1_TREE_LEVEL(height); \
} }
...@@ -279,15 +279,16 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val); ...@@ -279,15 +279,16 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
#ifdef SKEIN_DEBUG /* examine/display intermediate values? */ #ifdef SKEIN_DEBUG /* examine/display intermediate values? */
#include "skein_debug.h" #include "skein_debug.h"
#else /* default is no callouts */ #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_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_round(bits, ctx, r, X)
#define Skein_Show_R_Ptr(bits, ctx, r, X_ptr) #define skein_show_r_ptr(bits, ctx, r, X_ptr)
#define Skein_Show_Final(bits, ctx, cnt, out_ptr) #define skein_show_final(bits, ctx, cnt, out_ptr)
#define Skein_Show_Key(bits, ctx, key, key_bytes) #define skein_show_key(bits, ctx, key, key_bytes)
#endif #endif
#define Skein_Assert(x, ret_code)/* ignore all Asserts, for performance */ /* ignore all asserts, for performance */
#define Skein_assert(x) #define skein_assert_ret(x, ret_code)
#define skein_assert(x)
/***************************************************************** /*****************************************************************
** Skein block function constants (shared across Ref and Opt code) ** Skein block function constants (shared across Ref and Opt code)
...@@ -335,11 +336,11 @@ enum { ...@@ -335,11 +336,11 @@ enum {
#ifndef SKEIN_ROUNDS #ifndef SKEIN_ROUNDS
#define SKEIN_256_ROUNDS_TOTAL (72) /* # rounds for diff block sizes */ #define SKEIN_256_ROUNDS_TOTAL (72) /* # rounds for diff block sizes */
#define SKEIN_512_ROUNDS_TOTAL (72) #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) */ #else /* allow command-line define in range 8*(5..14) */
#define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5)) #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 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
#endif /* ifndef _SKEIN_H_ */ #endif /* ifndef _SKEIN_H_ */
drivers/staging/skein/include/skein_iv.h
View file @ 0264b7b7
...@@ -124,7 +124,7 @@ const u64 SKEIN_512_IV_512[] = { ...@@ -124,7 +124,7 @@ const u64 SKEIN_512_IV_512[] = {
}; };
/* blkSize = 1024 bits. hashSize = 384 bits */ /* blkSize = 1024 bits. hashSize = 384 bits */
const u64 SKEIN1024_IV_384[] = { const u64 SKEIN_1024_IV_384[] = {
MK_64(0x5102B6B8, 0xC1894A35), MK_64(0x5102B6B8, 0xC1894A35),
MK_64(0xFEEBC9E3, 0xFE8AF11A), MK_64(0xFEEBC9E3, 0xFE8AF11A),
MK_64(0x0C807F06, 0xE32BED71), MK_64(0x0C807F06, 0xE32BED71),
...@@ -144,7 +144,7 @@ const u64 SKEIN1024_IV_384[] = { ...@@ -144,7 +144,7 @@ const u64 SKEIN1024_IV_384[] = {
}; };
/* blkSize = 1024 bits. hashSize = 512 bits */ /* blkSize = 1024 bits. hashSize = 512 bits */
const u64 SKEIN1024_IV_512[] = { const u64 SKEIN_1024_IV_512[] = {
MK_64(0xCAEC0E5D, 0x7C1B1B18), MK_64(0xCAEC0E5D, 0x7C1B1B18),
MK_64(0xA01B0E04, 0x5F03E802), MK_64(0xA01B0E04, 0x5F03E802),
MK_64(0x33840451, 0xED912885), MK_64(0x33840451, 0xED912885),
...@@ -164,7 +164,7 @@ const u64 SKEIN1024_IV_512[] = { ...@@ -164,7 +164,7 @@ const u64 SKEIN1024_IV_512[] = {
}; };
/* blkSize = 1024 bits. hashSize = 1024 bits */ /* blkSize = 1024 bits. hashSize = 1024 bits */
const u64 SKEIN1024_IV_1024[] = { const u64 SKEIN_1024_IV_1024[] = {
MK_64(0xD593DA07, 0x41E72355), MK_64(0xD593DA07, 0x41E72355),
MK_64(0x15B5E511, 0xAC73E00C), MK_64(0x15B5E511, 0xAC73E00C),
MK_64(0x5180E5AE, 0xBAF2C4F0), MK_64(0x5180E5AE, 0xBAF2C4F0),
......
drivers/staging/skein/include/threefishApi.h
View file @ 0264b7b7
...@@ -31,7 +31,7 @@ ...@@ -31,7 +31,7 @@
#include <linux/types.h> #include <linux/types.h>
#include <skein.h> #include <skein.h>
#define KeyScheduleConst 0x1BD11BDAA9FC1A22L #define KEY_SCHEDULE_CONST 0x1BD11BDAA9FC1A22L
/** /**
* Which Threefish size to use * Which Threefish size to use
......
drivers/staging/skein/skein.c
View file @ 0264b7b7
...@@ -28,7 +28,7 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len) ...@@ -28,7 +28,7 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len)
u64 w[SKEIN_256_STATE_WORDS]; u64 w[SKEIN_256_STATE_WORDS];
} cfg; /* config block */ } cfg; /* config block */
Skein_Assert(hash_bit_len > 0, SKEIN_BAD_HASHLEN); skein_assert_ret(hash_bit_len > 0, SKEIN_BAD_HASHLEN);
ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */ ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */
switch (hash_bit_len) { /* use pre-computed values, where available */ switch (hash_bit_len) { /* use pre-computed values, where available */
...@@ -51,13 +51,13 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len) ...@@ -51,13 +51,13 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len)
* precomputed) * precomputed)
*/ */
/* set tweaks: T0=0; T1=CFG | FINAL */ /* set tweaks: T0=0; T1=CFG | FINAL */
Skein_Start_New_Type(ctx, CFG_FINAL); skein_start_new_type(ctx, CFG_FINAL);
/* set the schema, version */ /* set the schema, version */
cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[0] = skein_swap64(SKEIN_SCHEMA_VER);
/* hash result length in bits */ /* hash result length in bits */
cfg.w[1] = Skein_Swap64(hash_bit_len); cfg.w[1] = skein_swap64(hash_bit_len);
cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); cfg.w[2] = skein_swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL);
/* zero pad config block */ /* zero pad config block */
memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0])); memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0]));
...@@ -69,7 +69,7 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len) ...@@ -69,7 +69,7 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len)
} }
/* The chaining vars ctx->X are now initialized for hash_bit_len. */ /* The chaining vars ctx->X are now initialized for hash_bit_len. */
/* Set up to process the data message portion of the hash (default) */ /* Set up to process the data message portion of the hash (default) */
Skein_Start_New_Type(ctx, MSG); /* T0=0, T1= MSG type */ skein_start_new_type(ctx, MSG); /* T0=0, T1= MSG type */
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -86,20 +86,20 @@ int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hash_bit_len, ...@@ -86,20 +86,20 @@ int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hash_bit_len,
u64 w[SKEIN_256_STATE_WORDS]; u64 w[SKEIN_256_STATE_WORDS];
} cfg; /* config block */ } cfg; /* config block */
Skein_Assert(hash_bit_len > 0, SKEIN_BAD_HASHLEN); skein_assert_ret(hash_bit_len > 0, SKEIN_BAD_HASHLEN);
Skein_Assert(key_bytes == 0 || key != NULL, SKEIN_FAIL); skein_assert_ret(key_bytes == 0 || key != NULL, SKEIN_FAIL);
/* compute the initial chaining values ctx->X[], based on key */ /* compute the initial chaining values ctx->X[], based on key */
if (key_bytes == 0) { /* is there a key? */ if (key_bytes == 0) { /* is there a key? */
/* no key: use all zeroes as key for config block */ /* no key: use all zeroes as key for config block */
memset(ctx->X, 0, sizeof(ctx->X)); memset(ctx->X, 0, sizeof(ctx->X));
} else { /* here to pre-process a key */ } else { /* here to pre-process a key */
Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); skein_assert(sizeof(cfg.b) >= sizeof(ctx->X));
/* do a mini-Init right here */ /* do a mini-Init right here */
/* set output hash bit count = state size */ /* set output hash bit count = state size */
ctx->h.hash_bit_len = 8*sizeof(ctx->X); ctx->h.hash_bit_len = 8*sizeof(ctx->X);
/* set tweaks: T0 = 0; T1 = KEY type */ /* set tweaks: T0 = 0; T1 = KEY type */
Skein_Start_New_Type(ctx, KEY); skein_start_new_type(ctx, KEY);
/* zero the initial chaining variables */ /* zero the initial chaining variables */
memset(ctx->X, 0, sizeof(ctx->X)); memset(ctx->X, 0, sizeof(ctx->X));
/* hash the key */ /* hash the key */
...@@ -115,24 +115,24 @@ int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hash_bit_len, ...@@ -115,24 +115,24 @@ int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hash_bit_len,
*/ */
/* output hash bit count */ /* output hash bit count */
ctx->h.hash_bit_len = hash_bit_len; ctx->h.hash_bit_len = hash_bit_len;
Skein_Start_New_Type(ctx, CFG_FINAL); skein_start_new_type(ctx, CFG_FINAL);
/* pre-pad cfg.w[] with zeroes */ /* pre-pad cfg.w[] with zeroes */
memset(&cfg.w, 0, sizeof(cfg.w)); memset(&cfg.w, 0, sizeof(cfg.w));
cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[0] = skein_swap64(SKEIN_SCHEMA_VER);
/* hash result length in bits */ /* hash result length in bits */
cfg.w[1] = Skein_Swap64(hash_bit_len); cfg.w[1] = skein_swap64(hash_bit_len);
/* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */
cfg.w[2] = Skein_Swap64(tree_info); cfg.w[2] = skein_swap64(tree_info);
Skein_Show_Key(256, &ctx->h, key, key_bytes); skein_show_key(256, &ctx->h, key, key_bytes);
/* compute the initial chaining values from config block */ /* compute the initial chaining values from config block */
skein_256_process_block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN); skein_256_process_block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN);
/* The chaining vars ctx->X are now initialized */ /* The chaining vars ctx->X are now initialized */
/* Set up to process the data message portion of the hash (default) */ /* Set up to process the data message portion of the hash (default) */
Skein_Start_New_Type(ctx, MSG); skein_start_new_type(ctx, MSG);
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -145,7 +145,7 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg, ...@@ -145,7 +145,7 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg,
size_t n; size_t n;
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL);
/* process full blocks, if any */ /* process full blocks, if any */
if (msg_byte_cnt + ctx->h.b_cnt > SKEIN_256_BLOCK_BYTES) { if (msg_byte_cnt + ctx->h.b_cnt > SKEIN_256_BLOCK_BYTES) {
...@@ -155,13 +155,13 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg, ...@@ -155,13 +155,13 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg,
n = SKEIN_256_BLOCK_BYTES - ctx->h.b_cnt; n = SKEIN_256_BLOCK_BYTES - ctx->h.b_cnt;
if (n) { if (n) {
/* check on our logic here */ /* check on our logic here */
Skein_assert(n < msg_byte_cnt); skein_assert(n < msg_byte_cnt);
memcpy(&ctx->b[ctx->h.b_cnt], msg, n); memcpy(&ctx->b[ctx->h.b_cnt], msg, n);
msg_byte_cnt -= n; msg_byte_cnt -= n;
msg += n; msg += n;
ctx->h.b_cnt += n; ctx->h.b_cnt += n;
} }
Skein_assert(ctx->h.b_cnt == SKEIN_256_BLOCK_BYTES); skein_assert(ctx->h.b_cnt == SKEIN_256_BLOCK_BYTES);
skein_256_process_block(ctx, ctx->b, 1, skein_256_process_block(ctx, ctx->b, 1,
SKEIN_256_BLOCK_BYTES); SKEIN_256_BLOCK_BYTES);
ctx->h.b_cnt = 0; ctx->h.b_cnt = 0;
...@@ -178,12 +178,12 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg, ...@@ -178,12 +178,12 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg,
msg_byte_cnt -= n * SKEIN_256_BLOCK_BYTES; msg_byte_cnt -= n * SKEIN_256_BLOCK_BYTES;
msg += n * SKEIN_256_BLOCK_BYTES; msg += n * SKEIN_256_BLOCK_BYTES;
} }
Skein_assert(ctx->h.b_cnt == 0); skein_assert(ctx->h.b_cnt == 0);
} }
/* copy any remaining source message data bytes into b[] */ /* copy any remaining source message data bytes into b[] */
if (msg_byte_cnt) { if (msg_byte_cnt) {
Skein_assert(msg_byte_cnt + ctx->h.b_cnt <= skein_assert(msg_byte_cnt + ctx->h.b_cnt <=
SKEIN_256_BLOCK_BYTES); SKEIN_256_BLOCK_BYTES);
memcpy(&ctx->b[ctx->h.b_cnt], msg, msg_byte_cnt); memcpy(&ctx->b[ctx->h.b_cnt], msg, msg_byte_cnt);
ctx->h.b_cnt += msg_byte_cnt; ctx->h.b_cnt += msg_byte_cnt;
...@@ -199,7 +199,7 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -199,7 +199,7 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val)
size_t i, n, byte_cnt; size_t i, n, byte_cnt;
u64 X[SKEIN_256_STATE_WORDS]; u64 X[SKEIN_256_STATE_WORDS];
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL);
/* tag as the final block */ /* tag as the final block */
ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
...@@ -222,8 +222,8 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -222,8 +222,8 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val)
memcpy(X, ctx->X, sizeof(X)); memcpy(X, ctx->X, sizeof(X));
for (i = 0; i*SKEIN_256_BLOCK_BYTES < byte_cnt; i++) { for (i = 0; i*SKEIN_256_BLOCK_BYTES < byte_cnt; i++) {
/* build the counter block */ /* build the counter block */
((u64 *)ctx->b)[0] = Skein_Swap64((u64) i); ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
Skein_Start_New_Type(ctx, OUT_FINAL); skein_start_new_type(ctx, OUT_FINAL);
/* run "counter mode" */ /* run "counter mode" */
skein_256_process_block(ctx, ctx->b, 1, sizeof(u64)); skein_256_process_block(ctx, ctx->b, 1, sizeof(u64));
/* number of output bytes left to go */ /* number of output bytes left to go */
...@@ -231,9 +231,9 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -231,9 +231,9 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val)
if (n >= SKEIN_256_BLOCK_BYTES) if (n >= SKEIN_256_BLOCK_BYTES)
n = SKEIN_256_BLOCK_BYTES; n = SKEIN_256_BLOCK_BYTES;
/* "output" the ctr mode bytes */ /* "output" the ctr mode bytes */
Skein_Put64_LSB_First(hash_val+i*SKEIN_256_BLOCK_BYTES, ctx->X, skein_put64_lsb_first(hash_val+i*SKEIN_256_BLOCK_BYTES, ctx->X,
n); n);
Skein_Show_Final(256, &ctx->h, n, skein_show_final(256, &ctx->h, n,
hash_val+i*SKEIN_256_BLOCK_BYTES); hash_val+i*SKEIN_256_BLOCK_BYTES);
/* restore the counter mode key for next time */ /* restore the counter mode key for next time */
memcpy(ctx->X, X, sizeof(X)); memcpy(ctx->X, X, sizeof(X));
...@@ -254,7 +254,7 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len) ...@@ -254,7 +254,7 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len)
u64 w[SKEIN_512_STATE_WORDS]; u64 w[SKEIN_512_STATE_WORDS];
} cfg; /* config block */ } cfg; /* config block */
Skein_Assert(hash_bit_len > 0, SKEIN_BAD_HASHLEN); skein_assert_ret(hash_bit_len > 0, SKEIN_BAD_HASHLEN);
ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */ ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */
switch (hash_bit_len) { /* use pre-computed values, where available */ switch (hash_bit_len) { /* use pre-computed values, where available */
...@@ -277,13 +277,13 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len) ...@@ -277,13 +277,13 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len)
* precomputed) * precomputed)
*/ */
/* set tweaks: T0=0; T1=CFG | FINAL */ /* set tweaks: T0=0; T1=CFG | FINAL */
Skein_Start_New_Type(ctx, CFG_FINAL); skein_start_new_type(ctx, CFG_FINAL);
/* set the schema, version */ /* set the schema, version */
cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[0] = skein_swap64(SKEIN_SCHEMA_VER);
/* hash result length in bits */ /* hash result length in bits */
cfg.w[1] = Skein_Swap64(hash_bit_len); cfg.w[1] = skein_swap64(hash_bit_len);
cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); cfg.w[2] = skein_swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL);
/* zero pad config block */ /* zero pad config block */
memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0])); memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0]));
...@@ -299,7 +299,7 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len) ...@@ -299,7 +299,7 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len)
* hash_bit_len. * hash_bit_len.
*/ */
/* Set up to process the data message portion of the hash (default) */ /* Set up to process the data message portion of the hash (default) */
Skein_Start_New_Type(ctx, MSG); /* T0=0, T1= MSG type */ skein_start_new_type(ctx, MSG); /* T0=0, T1= MSG type */
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -316,20 +316,20 @@ int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hash_bit_len, ...@@ -316,20 +316,20 @@ int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hash_bit_len,
u64 w[SKEIN_512_STATE_WORDS]; u64 w[SKEIN_512_STATE_WORDS];
} cfg; /* config block */ } cfg; /* config block */
Skein_Assert(hash_bit_len > 0, SKEIN_BAD_HASHLEN); skein_assert_ret(hash_bit_len > 0, SKEIN_BAD_HASHLEN);
Skein_Assert(key_bytes == 0 || key != NULL, SKEIN_FAIL); skein_assert_ret(key_bytes == 0 || key != NULL, SKEIN_FAIL);
/* compute the initial chaining values ctx->X[], based on key */ /* compute the initial chaining values ctx->X[], based on key */
if (key_bytes == 0) { /* is there a key? */ if (key_bytes == 0) { /* is there a key? */
/* no key: use all zeroes as key for config block */ /* no key: use all zeroes as key for config block */
memset(ctx->X, 0, sizeof(ctx->X)); memset(ctx->X, 0, sizeof(ctx->X));
} else { /* here to pre-process a key */ } else { /* here to pre-process a key */
Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); skein_assert(sizeof(cfg.b) >= sizeof(ctx->X));
/* do a mini-Init right here */ /* do a mini-Init right here */
/* set output hash bit count = state size */ /* set output hash bit count = state size */
ctx->h.hash_bit_len = 8*sizeof(ctx->X); ctx->h.hash_bit_len = 8*sizeof(ctx->X);
/* set tweaks: T0 = 0; T1 = KEY type */ /* set tweaks: T0 = 0; T1 = KEY type */
Skein_Start_New_Type(ctx, KEY); skein_start_new_type(ctx, KEY);
/* zero the initial chaining variables */ /* zero the initial chaining variables */
memset(ctx->X, 0, sizeof(ctx->X)); memset(ctx->X, 0, sizeof(ctx->X));
/* hash the key */ /* hash the key */
...@@ -344,24 +344,24 @@ int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hash_bit_len, ...@@ -344,24 +344,24 @@ int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hash_bit_len,
* precomputed for each key) * precomputed for each key)
*/ */
ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */ ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */
Skein_Start_New_Type(ctx, CFG_FINAL); skein_start_new_type(ctx, CFG_FINAL);
/* pre-pad cfg.w[] with zeroes */ /* pre-pad cfg.w[] with zeroes */
memset(&cfg.w, 0, sizeof(cfg.w)); memset(&cfg.w, 0, sizeof(cfg.w));
cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[0] = skein_swap64(SKEIN_SCHEMA_VER);
/* hash result length in bits */ /* hash result length in bits */
cfg.w[1] = Skein_Swap64(hash_bit_len); cfg.w[1] = skein_swap64(hash_bit_len);
/* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */
cfg.w[2] = Skein_Swap64(tree_info); cfg.w[2] = skein_swap64(tree_info);
Skein_Show_Key(512, &ctx->h, key, key_bytes); skein_show_key(512, &ctx->h, key, key_bytes);
/* compute the initial chaining values from config block */ /* compute the initial chaining values from config block */
skein_512_process_block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN); skein_512_process_block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN);
/* The chaining vars ctx->X are now initialized */ /* The chaining vars ctx->X are now initialized */
/* Set up to process the data message portion of the hash (default) */ /* Set up to process the data message portion of the hash (default) */
Skein_Start_New_Type(ctx, MSG); skein_start_new_type(ctx, MSG);
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -374,7 +374,7 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg, ...@@ -374,7 +374,7 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg,
size_t n; size_t n;
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL);
/* process full blocks, if any */ /* process full blocks, if any */
if (msg_byte_cnt + ctx->h.b_cnt > SKEIN_512_BLOCK_BYTES) { if (msg_byte_cnt + ctx->h.b_cnt > SKEIN_512_BLOCK_BYTES) {
...@@ -384,13 +384,13 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg, ...@@ -384,13 +384,13 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg,
n = SKEIN_512_BLOCK_BYTES - ctx->h.b_cnt; n = SKEIN_512_BLOCK_BYTES - ctx->h.b_cnt;
if (n) { if (n) {
/* check on our logic here */ /* check on our logic here */
Skein_assert(n < msg_byte_cnt); skein_assert(n < msg_byte_cnt);
memcpy(&ctx->b[ctx->h.b_cnt], msg, n); memcpy(&ctx->b[ctx->h.b_cnt], msg, n);
msg_byte_cnt -= n; msg_byte_cnt -= n;
msg += n; msg += n;
ctx->h.b_cnt += n; ctx->h.b_cnt += n;
} }
Skein_assert(ctx->h.b_cnt == SKEIN_512_BLOCK_BYTES); skein_assert(ctx->h.b_cnt == SKEIN_512_BLOCK_BYTES);
skein_512_process_block(ctx, ctx->b, 1, skein_512_process_block(ctx, ctx->b, 1,
SKEIN_512_BLOCK_BYTES); SKEIN_512_BLOCK_BYTES);
ctx->h.b_cnt = 0; ctx->h.b_cnt = 0;
...@@ -407,12 +407,12 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg, ...@@ -407,12 +407,12 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg,
msg_byte_cnt -= n * SKEIN_512_BLOCK_BYTES; msg_byte_cnt -= n * SKEIN_512_BLOCK_BYTES;
msg += n * SKEIN_512_BLOCK_BYTES; msg += n * SKEIN_512_BLOCK_BYTES;
} }
Skein_assert(ctx->h.b_cnt == 0); skein_assert(ctx->h.b_cnt == 0);
} }
/* copy any remaining source message data bytes into b[] */ /* copy any remaining source message data bytes into b[] */
if (msg_byte_cnt) { if (msg_byte_cnt) {
Skein_assert(msg_byte_cnt + ctx->h.b_cnt <= skein_assert(msg_byte_cnt + ctx->h.b_cnt <=
SKEIN_512_BLOCK_BYTES); SKEIN_512_BLOCK_BYTES);
memcpy(&ctx->b[ctx->h.b_cnt], msg, msg_byte_cnt); memcpy(&ctx->b[ctx->h.b_cnt], msg, msg_byte_cnt);
ctx->h.b_cnt += msg_byte_cnt; ctx->h.b_cnt += msg_byte_cnt;
...@@ -428,7 +428,7 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -428,7 +428,7 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val)
size_t i, n, byte_cnt; size_t i, n, byte_cnt;
u64 X[SKEIN_512_STATE_WORDS]; u64 X[SKEIN_512_STATE_WORDS];
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL);
/* tag as the final block */ /* tag as the final block */
ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
...@@ -451,8 +451,8 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -451,8 +451,8 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val)
memcpy(X, ctx->X, sizeof(X)); memcpy(X, ctx->X, sizeof(X));
for (i = 0; i*SKEIN_512_BLOCK_BYTES < byte_cnt; i++) { for (i = 0; i*SKEIN_512_BLOCK_BYTES < byte_cnt; i++) {
/* build the counter block */ /* build the counter block */
((u64 *)ctx->b)[0] = Skein_Swap64((u64) i); ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
Skein_Start_New_Type(ctx, OUT_FINAL); skein_start_new_type(ctx, OUT_FINAL);
/* run "counter mode" */ /* run "counter mode" */
skein_512_process_block(ctx, ctx->b, 1, sizeof(u64)); skein_512_process_block(ctx, ctx->b, 1, sizeof(u64));
/* number of output bytes left to go */ /* number of output bytes left to go */
...@@ -460,9 +460,9 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -460,9 +460,9 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val)
if (n >= SKEIN_512_BLOCK_BYTES) if (n >= SKEIN_512_BLOCK_BYTES)
n = SKEIN_512_BLOCK_BYTES; n = SKEIN_512_BLOCK_BYTES;
/* "output" the ctr mode bytes */ /* "output" the ctr mode bytes */
Skein_Put64_LSB_First(hash_val+i*SKEIN_512_BLOCK_BYTES, ctx->X, skein_put64_lsb_first(hash_val+i*SKEIN_512_BLOCK_BYTES, ctx->X,
n); n);
Skein_Show_Final(512, &ctx->h, n, skein_show_final(512, &ctx->h, n,
hash_val+i*SKEIN_512_BLOCK_BYTES); hash_val+i*SKEIN_512_BLOCK_BYTES);
/* restore the counter mode key for next time */ /* restore the counter mode key for next time */
memcpy(ctx->X, X, sizeof(X)); memcpy(ctx->X, X, sizeof(X));
...@@ -479,22 +479,22 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -479,22 +479,22 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val)
int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len) int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len)
{ {
union { union {
u8 b[SKEIN1024_STATE_BYTES]; u8 b[SKEIN_1024_STATE_BYTES];
u64 w[SKEIN1024_STATE_WORDS]; u64 w[SKEIN_1024_STATE_WORDS];
} cfg; /* config block */ } cfg; /* config block */
Skein_Assert(hash_bit_len > 0, SKEIN_BAD_HASHLEN); skein_assert_ret(hash_bit_len > 0, SKEIN_BAD_HASHLEN);
ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */ ctx->h.hash_bit_len = hash_bit_len; /* output hash bit count */
switch (hash_bit_len) { /* use pre-computed values, where available */ switch (hash_bit_len) { /* use pre-computed values, where available */
case 512: case 512:
memcpy(ctx->X, SKEIN1024_IV_512, sizeof(ctx->X)); memcpy(ctx->X, SKEIN_1024_IV_512, sizeof(ctx->X));
break; break;
case 384: case 384:
memcpy(ctx->X, SKEIN1024_IV_384, sizeof(ctx->X)); memcpy(ctx->X, SKEIN_1024_IV_384, sizeof(ctx->X));
break; break;
case 1024: case 1024:
memcpy(ctx->X, SKEIN1024_IV_1024, sizeof(ctx->X)); memcpy(ctx->X, SKEIN_1024_IV_1024, sizeof(ctx->X));
break; break;
default: default:
/* here if there is no precomputed IV value available */ /* here if there is no precomputed IV value available */
...@@ -503,13 +503,13 @@ int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len) ...@@ -503,13 +503,13 @@ int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len)
* (could be precomputed) * (could be precomputed)
*/ */
/* set tweaks: T0=0; T1=CFG | FINAL */ /* set tweaks: T0=0; T1=CFG | FINAL */
Skein_Start_New_Type(ctx, CFG_FINAL); skein_start_new_type(ctx, CFG_FINAL);
/* set the schema, version */ /* set the schema, version */
cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[0] = skein_swap64(SKEIN_SCHEMA_VER);
/* hash result length in bits */ /* hash result length in bits */
cfg.w[1] = Skein_Swap64(hash_bit_len); cfg.w[1] = skein_swap64(hash_bit_len);
cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); cfg.w[2] = skein_swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL);
/* zero pad config block */ /* zero pad config block */
memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0])); memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0]));
...@@ -522,7 +522,7 @@ int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len) ...@@ -522,7 +522,7 @@ int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len)
/* The chaining vars ctx->X are now initialized for the hash_bit_len. */ /* The chaining vars ctx->X are now initialized for the hash_bit_len. */
/* Set up to process the data message portion of the hash (default) */ /* Set up to process the data message portion of the hash (default) */
Skein_Start_New_Type(ctx, MSG); /* T0=0, T1= MSG type */ skein_start_new_type(ctx, MSG); /* T0=0, T1= MSG type */
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -535,24 +535,24 @@ int skein_1024_init_ext(struct skein_1024_ctx *ctx, size_t hash_bit_len, ...@@ -535,24 +535,24 @@ 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) u64 tree_info, const u8 *key, size_t key_bytes)
{ {
union { union {
u8 b[SKEIN1024_STATE_BYTES]; u8 b[SKEIN_1024_STATE_BYTES];
u64 w[SKEIN1024_STATE_WORDS]; u64 w[SKEIN_1024_STATE_WORDS];
} cfg; /* config block */ } cfg; /* config block */
Skein_Assert(hash_bit_len > 0, SKEIN_BAD_HASHLEN); skein_assert_ret(hash_bit_len > 0, SKEIN_BAD_HASHLEN);
Skein_Assert(key_bytes == 0 || key != NULL, SKEIN_FAIL); skein_assert_ret(key_bytes == 0 || key != NULL, SKEIN_FAIL);
/* compute the initial chaining values ctx->X[], based on key */ /* compute the initial chaining values ctx->X[], based on key */
if (key_bytes == 0) { /* is there a key? */ if (key_bytes == 0) { /* is there a key? */
/* no key: use all zeroes as key for config block */ /* no key: use all zeroes as key for config block */
memset(ctx->X, 0, sizeof(ctx->X)); memset(ctx->X, 0, sizeof(ctx->X));
} else { /* here to pre-process a key */ } else { /* here to pre-process a key */
Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); skein_assert(sizeof(cfg.b) >= sizeof(ctx->X));
/* do a mini-Init right here */ /* do a mini-Init right here */
/* set output hash bit count = state size */ /* set output hash bit count = state size */
ctx->h.hash_bit_len = 8*sizeof(ctx->X); ctx->h.hash_bit_len = 8*sizeof(ctx->X);
/* set tweaks: T0 = 0; T1 = KEY type */ /* set tweaks: T0 = 0; T1 = KEY type */
Skein_Start_New_Type(ctx, KEY); skein_start_new_type(ctx, KEY);
/* zero the initial chaining variables */ /* zero the initial chaining variables */
memset(ctx->X, 0, sizeof(ctx->X)); memset(ctx->X, 0, sizeof(ctx->X));
/* hash the key */ /* hash the key */
...@@ -568,24 +568,24 @@ int skein_1024_init_ext(struct skein_1024_ctx *ctx, size_t hash_bit_len, ...@@ -568,24 +568,24 @@ int skein_1024_init_ext(struct skein_1024_ctx *ctx, size_t hash_bit_len,
*/ */
/* output hash bit count */ /* output hash bit count */
ctx->h.hash_bit_len = hash_bit_len; ctx->h.hash_bit_len = hash_bit_len;
Skein_Start_New_Type(ctx, CFG_FINAL); skein_start_new_type(ctx, CFG_FINAL);
/* pre-pad cfg.w[] with zeroes */ /* pre-pad cfg.w[] with zeroes */
memset(&cfg.w, 0, sizeof(cfg.w)); memset(&cfg.w, 0, sizeof(cfg.w));
cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[0] = skein_swap64(SKEIN_SCHEMA_VER);
/* hash result length in bits */ /* hash result length in bits */
cfg.w[1] = Skein_Swap64(hash_bit_len); cfg.w[1] = skein_swap64(hash_bit_len);
/* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */
cfg.w[2] = Skein_Swap64(tree_info); cfg.w[2] = skein_swap64(tree_info);
Skein_Show_Key(1024, &ctx->h, key, key_bytes); skein_show_key(1024, &ctx->h, key, key_bytes);
/* compute the initial chaining values from config block */ /* compute the initial chaining values from config block */
skein_1024_process_block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN); skein_1024_process_block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN);
/* The chaining vars ctx->X are now initialized */ /* The chaining vars ctx->X are now initialized */
/* Set up to process the data message portion of the hash (default) */ /* Set up to process the data message portion of the hash (default) */
Skein_Start_New_Type(ctx, MSG); skein_start_new_type(ctx, MSG);
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -598,46 +598,46 @@ int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg, ...@@ -598,46 +598,46 @@ int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg,
size_t n; size_t n;
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN1024_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_1024_BLOCK_BYTES, SKEIN_FAIL);
/* process full blocks, if any */ /* process full blocks, if any */
if (msg_byte_cnt + ctx->h.b_cnt > SKEIN1024_BLOCK_BYTES) { if (msg_byte_cnt + ctx->h.b_cnt > SKEIN_1024_BLOCK_BYTES) {
/* finish up any buffered message data */ /* finish up any buffered message data */
if (ctx->h.b_cnt) { if (ctx->h.b_cnt) {
/* # bytes free in buffer b[] */ /* # bytes free in buffer b[] */
n = SKEIN1024_BLOCK_BYTES - ctx->h.b_cnt; n = SKEIN_1024_BLOCK_BYTES - ctx->h.b_cnt;
if (n) { if (n) {
/* check on our logic here */ /* check on our logic here */
Skein_assert(n < msg_byte_cnt); skein_assert(n < msg_byte_cnt);
memcpy(&ctx->b[ctx->h.b_cnt], msg, n); memcpy(&ctx->b[ctx->h.b_cnt], msg, n);
msg_byte_cnt -= n; msg_byte_cnt -= n;
msg += n; msg += n;
ctx->h.b_cnt += n; ctx->h.b_cnt += n;
} }
Skein_assert(ctx->h.b_cnt == SKEIN1024_BLOCK_BYTES); skein_assert(ctx->h.b_cnt == SKEIN_1024_BLOCK_BYTES);
skein_1024_process_block(ctx, ctx->b, 1, skein_1024_process_block(ctx, ctx->b, 1,
SKEIN1024_BLOCK_BYTES); SKEIN_1024_BLOCK_BYTES);
ctx->h.b_cnt = 0; ctx->h.b_cnt = 0;
} }
/* /*
* now process any remaining full blocks, directly from input * now process any remaining full blocks, directly from input
* message data * message data
*/ */
if (msg_byte_cnt > SKEIN1024_BLOCK_BYTES) { if (msg_byte_cnt > SKEIN_1024_BLOCK_BYTES) {
/* number of full blocks to process */ /* number of full blocks to process */
n = (msg_byte_cnt-1) / SKEIN1024_BLOCK_BYTES; n = (msg_byte_cnt-1) / SKEIN_1024_BLOCK_BYTES;
skein_1024_process_block(ctx, msg, n, skein_1024_process_block(ctx, msg, n,
SKEIN1024_BLOCK_BYTES); SKEIN_1024_BLOCK_BYTES);
msg_byte_cnt -= n * SKEIN1024_BLOCK_BYTES; msg_byte_cnt -= n * SKEIN_1024_BLOCK_BYTES;
msg += n * SKEIN1024_BLOCK_BYTES; msg += n * SKEIN_1024_BLOCK_BYTES;
} }
Skein_assert(ctx->h.b_cnt == 0); skein_assert(ctx->h.b_cnt == 0);
} }
/* copy any remaining source message data bytes into b[] */ /* copy any remaining source message data bytes into b[] */
if (msg_byte_cnt) { if (msg_byte_cnt) {
Skein_assert(msg_byte_cnt + ctx->h.b_cnt <= skein_assert(msg_byte_cnt + ctx->h.b_cnt <=
SKEIN1024_BLOCK_BYTES); SKEIN_1024_BLOCK_BYTES);
memcpy(&ctx->b[ctx->h.b_cnt], msg, msg_byte_cnt); memcpy(&ctx->b[ctx->h.b_cnt], msg, msg_byte_cnt);
ctx->h.b_cnt += msg_byte_cnt; ctx->h.b_cnt += msg_byte_cnt;
} }
...@@ -650,16 +650,16 @@ int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg, ...@@ -650,16 +650,16 @@ int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg,
int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val) int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val)
{ {
size_t i, n, byte_cnt; size_t i, n, byte_cnt;
u64 X[SKEIN1024_STATE_WORDS]; u64 X[SKEIN_1024_STATE_WORDS];
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN1024_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_1024_BLOCK_BYTES, SKEIN_FAIL);
/* tag as the final block */ /* tag as the final block */
ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
/* zero pad b[] if necessary */ /* zero pad b[] if necessary */
if (ctx->h.b_cnt < SKEIN1024_BLOCK_BYTES) if (ctx->h.b_cnt < SKEIN_1024_BLOCK_BYTES)
memset(&ctx->b[ctx->h.b_cnt], 0, memset(&ctx->b[ctx->h.b_cnt], 0,
SKEIN1024_BLOCK_BYTES - ctx->h.b_cnt); SKEIN_1024_BLOCK_BYTES - ctx->h.b_cnt);
/* process the final block */ /* process the final block */
skein_1024_process_block(ctx, ctx->b, 1, ctx->h.b_cnt); skein_1024_process_block(ctx, ctx->b, 1, ctx->h.b_cnt);
...@@ -673,21 +673,21 @@ int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val) ...@@ -673,21 +673,21 @@ int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val)
memset(ctx->b, 0, sizeof(ctx->b)); memset(ctx->b, 0, sizeof(ctx->b));
/* keep a local copy of counter mode "key" */ /* keep a local copy of counter mode "key" */
memcpy(X, ctx->X, sizeof(X)); memcpy(X, ctx->X, sizeof(X));
for (i = 0; i*SKEIN1024_BLOCK_BYTES < byte_cnt; i++) { for (i = 0; i*SKEIN_1024_BLOCK_BYTES < byte_cnt; i++) {
/* build the counter block */ /* build the counter block */
((u64 *)ctx->b)[0] = Skein_Swap64((u64) i); ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
Skein_Start_New_Type(ctx, OUT_FINAL); skein_start_new_type(ctx, OUT_FINAL);
/* run "counter mode" */ /* run "counter mode" */
skein_1024_process_block(ctx, ctx->b, 1, sizeof(u64)); skein_1024_process_block(ctx, ctx->b, 1, sizeof(u64));
/* number of output bytes left to go */ /* number of output bytes left to go */
n = byte_cnt - i*SKEIN1024_BLOCK_BYTES; n = byte_cnt - i*SKEIN_1024_BLOCK_BYTES;
if (n >= SKEIN1024_BLOCK_BYTES) if (n >= SKEIN_1024_BLOCK_BYTES)
n = SKEIN1024_BLOCK_BYTES; n = SKEIN_1024_BLOCK_BYTES;
/* "output" the ctr mode bytes */ /* "output" the ctr mode bytes */
Skein_Put64_LSB_First(hash_val+i*SKEIN1024_BLOCK_BYTES, ctx->X, skein_put64_lsb_first(hash_val+i*SKEIN_1024_BLOCK_BYTES, ctx->X,
n); n);
Skein_Show_Final(1024, &ctx->h, n, skein_show_final(1024, &ctx->h, n,
hash_val+i*SKEIN1024_BLOCK_BYTES); hash_val+i*SKEIN_1024_BLOCK_BYTES);
/* restore the counter mode key for next time */ /* restore the counter mode key for next time */
memcpy(ctx->X, X, sizeof(X)); memcpy(ctx->X, X, sizeof(X));
} }
...@@ -702,7 +702,7 @@ int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val) ...@@ -702,7 +702,7 @@ int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val)
int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hash_val) int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hash_val)
{ {
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL);
/* tag as the final block */ /* tag as the final block */
ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
...@@ -714,7 +714,7 @@ int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -714,7 +714,7 @@ int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hash_val)
skein_256_process_block(ctx, ctx->b, 1, ctx->h.b_cnt); skein_256_process_block(ctx, ctx->b, 1, ctx->h.b_cnt);
/* "output" the state bytes */ /* "output" the state bytes */
Skein_Put64_LSB_First(hash_val, ctx->X, SKEIN_256_BLOCK_BYTES); skein_put64_lsb_first(hash_val, ctx->X, SKEIN_256_BLOCK_BYTES);
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -724,7 +724,7 @@ int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -724,7 +724,7 @@ 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_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val)
{ {
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL);
/* tag as the final block */ /* tag as the final block */
ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
...@@ -736,7 +736,7 @@ int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -736,7 +736,7 @@ int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val)
skein_512_process_block(ctx, ctx->b, 1, ctx->h.b_cnt); skein_512_process_block(ctx, ctx->b, 1, ctx->h.b_cnt);
/* "output" the state bytes */ /* "output" the state bytes */
Skein_Put64_LSB_First(hash_val, ctx->X, SKEIN_512_BLOCK_BYTES); skein_put64_lsb_first(hash_val, ctx->X, SKEIN_512_BLOCK_BYTES);
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -746,19 +746,19 @@ int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -746,19 +746,19 @@ int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hash_val)
int skein_1024_final_pad(struct skein_1024_ctx *ctx, u8 *hash_val) int skein_1024_final_pad(struct skein_1024_ctx *ctx, u8 *hash_val)
{ {
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN1024_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_1024_BLOCK_BYTES, SKEIN_FAIL);
/* tag as the final block */ /* tag as the final block */
ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
/* zero pad b[] if necessary */ /* zero pad b[] if necessary */
if (ctx->h.b_cnt < SKEIN1024_BLOCK_BYTES) if (ctx->h.b_cnt < SKEIN_1024_BLOCK_BYTES)
memset(&ctx->b[ctx->h.b_cnt], 0, memset(&ctx->b[ctx->h.b_cnt], 0,
SKEIN1024_BLOCK_BYTES - ctx->h.b_cnt); SKEIN_1024_BLOCK_BYTES - ctx->h.b_cnt);
/* process the final block */ /* process the final block */
skein_1024_process_block(ctx, ctx->b, 1, ctx->h.b_cnt); skein_1024_process_block(ctx, ctx->b, 1, ctx->h.b_cnt);
/* "output" the state bytes */ /* "output" the state bytes */
Skein_Put64_LSB_First(hash_val, ctx->X, SKEIN1024_BLOCK_BYTES); skein_put64_lsb_first(hash_val, ctx->X, SKEIN_1024_BLOCK_BYTES);
return SKEIN_SUCCESS; return SKEIN_SUCCESS;
} }
...@@ -771,7 +771,7 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -771,7 +771,7 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val)
size_t i, n, byte_cnt; size_t i, n, byte_cnt;
u64 X[SKEIN_256_STATE_WORDS]; u64 X[SKEIN_256_STATE_WORDS];
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_256_BLOCK_BYTES, SKEIN_FAIL);
/* now output the result */ /* now output the result */
/* total number of output bytes */ /* total number of output bytes */
...@@ -784,8 +784,8 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -784,8 +784,8 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val)
memcpy(X, ctx->X, sizeof(X)); memcpy(X, ctx->X, sizeof(X));
for (i = 0; i*SKEIN_256_BLOCK_BYTES < byte_cnt; i++) { for (i = 0; i*SKEIN_256_BLOCK_BYTES < byte_cnt; i++) {
/* build the counter block */ /* build the counter block */
((u64 *)ctx->b)[0] = Skein_Swap64((u64) i); ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
Skein_Start_New_Type(ctx, OUT_FINAL); skein_start_new_type(ctx, OUT_FINAL);
/* run "counter mode" */ /* run "counter mode" */
skein_256_process_block(ctx, ctx->b, 1, sizeof(u64)); skein_256_process_block(ctx, ctx->b, 1, sizeof(u64));
/* number of output bytes left to go */ /* number of output bytes left to go */
...@@ -793,9 +793,9 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val) ...@@ -793,9 +793,9 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val)
if (n >= SKEIN_256_BLOCK_BYTES) if (n >= SKEIN_256_BLOCK_BYTES)
n = SKEIN_256_BLOCK_BYTES; n = SKEIN_256_BLOCK_BYTES;
/* "output" the ctr mode bytes */ /* "output" the ctr mode bytes */
Skein_Put64_LSB_First(hash_val+i*SKEIN_256_BLOCK_BYTES, ctx->X, skein_put64_lsb_first(hash_val+i*SKEIN_256_BLOCK_BYTES, ctx->X,
n); n);
Skein_Show_Final(256, &ctx->h, n, skein_show_final(256, &ctx->h, n,
hash_val+i*SKEIN_256_BLOCK_BYTES); hash_val+i*SKEIN_256_BLOCK_BYTES);
/* restore the counter mode key for next time */ /* restore the counter mode key for next time */
memcpy(ctx->X, X, sizeof(X)); memcpy(ctx->X, X, sizeof(X));
...@@ -810,7 +810,7 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -810,7 +810,7 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val)
size_t i, n, byte_cnt; size_t i, n, byte_cnt;
u64 X[SKEIN_512_STATE_WORDS]; u64 X[SKEIN_512_STATE_WORDS];
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL);
/* now output the result */ /* now output the result */
/* total number of output bytes */ /* total number of output bytes */
...@@ -823,8 +823,8 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -823,8 +823,8 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val)
memcpy(X, ctx->X, sizeof(X)); memcpy(X, ctx->X, sizeof(X));
for (i = 0; i*SKEIN_512_BLOCK_BYTES < byte_cnt; i++) { for (i = 0; i*SKEIN_512_BLOCK_BYTES < byte_cnt; i++) {
/* build the counter block */ /* build the counter block */
((u64 *)ctx->b)[0] = Skein_Swap64((u64) i); ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
Skein_Start_New_Type(ctx, OUT_FINAL); skein_start_new_type(ctx, OUT_FINAL);
/* run "counter mode" */ /* run "counter mode" */
skein_512_process_block(ctx, ctx->b, 1, sizeof(u64)); skein_512_process_block(ctx, ctx->b, 1, sizeof(u64));
/* number of output bytes left to go */ /* number of output bytes left to go */
...@@ -832,9 +832,9 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -832,9 +832,9 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val)
if (n >= SKEIN_512_BLOCK_BYTES) if (n >= SKEIN_512_BLOCK_BYTES)
n = SKEIN_512_BLOCK_BYTES; n = SKEIN_512_BLOCK_BYTES;
/* "output" the ctr mode bytes */ /* "output" the ctr mode bytes */
Skein_Put64_LSB_First(hash_val+i*SKEIN_512_BLOCK_BYTES, ctx->X, skein_put64_lsb_first(hash_val+i*SKEIN_512_BLOCK_BYTES, ctx->X,
n); n);
Skein_Show_Final(256, &ctx->h, n, skein_show_final(256, &ctx->h, n,
hash_val+i*SKEIN_512_BLOCK_BYTES); hash_val+i*SKEIN_512_BLOCK_BYTES);
/* restore the counter mode key for next time */ /* restore the counter mode key for next time */
memcpy(ctx->X, X, sizeof(X)); memcpy(ctx->X, X, sizeof(X));
...@@ -847,9 +847,9 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val) ...@@ -847,9 +847,9 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val)
int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val) int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val)
{ {
size_t i, n, byte_cnt; size_t i, n, byte_cnt;
u64 X[SKEIN1024_STATE_WORDS]; u64 X[SKEIN_1024_STATE_WORDS];
/* catch uninitialized context */ /* catch uninitialized context */
Skein_Assert(ctx->h.b_cnt <= SKEIN1024_BLOCK_BYTES, SKEIN_FAIL); skein_assert_ret(ctx->h.b_cnt <= SKEIN_1024_BLOCK_BYTES, SKEIN_FAIL);
/* now output the result */ /* now output the result */
/* total number of output bytes */ /* total number of output bytes */
...@@ -860,21 +860,21 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val) ...@@ -860,21 +860,21 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val)
memset(ctx->b, 0, sizeof(ctx->b)); memset(ctx->b, 0, sizeof(ctx->b));
/* keep a local copy of counter mode "key" */ /* keep a local copy of counter mode "key" */
memcpy(X, ctx->X, sizeof(X)); memcpy(X, ctx->X, sizeof(X));
for (i = 0; i*SKEIN1024_BLOCK_BYTES < byte_cnt; i++) { for (i = 0; i*SKEIN_1024_BLOCK_BYTES < byte_cnt; i++) {
/* build the counter block */ /* build the counter block */
((u64 *)ctx->b)[0] = Skein_Swap64((u64) i); ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
Skein_Start_New_Type(ctx, OUT_FINAL); skein_start_new_type(ctx, OUT_FINAL);
/* run "counter mode" */ /* run "counter mode" */
skein_1024_process_block(ctx, ctx->b, 1, sizeof(u64)); skein_1024_process_block(ctx, ctx->b, 1, sizeof(u64));
/* number of output bytes left to go */ /* number of output bytes left to go */
n = byte_cnt - i*SKEIN1024_BLOCK_BYTES; n = byte_cnt - i*SKEIN_1024_BLOCK_BYTES;
if (n >= SKEIN1024_BLOCK_BYTES) if (n >= SKEIN_1024_BLOCK_BYTES)
n = SKEIN1024_BLOCK_BYTES; n = SKEIN_1024_BLOCK_BYTES;
/* "output" the ctr mode bytes */ /* "output" the ctr mode bytes */
Skein_Put64_LSB_First(hash_val+i*SKEIN1024_BLOCK_BYTES, ctx->X, skein_put64_lsb_first(hash_val+i*SKEIN_1024_BLOCK_BYTES, ctx->X,
n); n);
Skein_Show_Final(256, &ctx->h, n, skein_show_final(256, &ctx->h, n,
hash_val+i*SKEIN1024_BLOCK_BYTES); hash_val+i*SKEIN_1024_BLOCK_BYTES);
/* restore the counter mode key for next time */ /* restore the counter mode key for next time */
memcpy(ctx->X, X, sizeof(X)); memcpy(ctx->X, X, sizeof(X));
} }
......
drivers/staging/skein/skeinApi.c
View file @ 0264b7b7
...@@ -29,7 +29,7 @@ OTHER DEALINGS IN THE SOFTWARE. ...@@ -29,7 +29,7 @@ OTHER DEALINGS IN THE SOFTWARE.
int skein_ctx_prepare(struct skein_ctx *ctx, enum skein_size size) 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)); memset(ctx , 0, sizeof(struct skein_ctx));
ctx->skein_size = size; ctx->skein_size = size;
...@@ -44,7 +44,7 @@ int skein_init(struct skein_ctx *ctx, size_t hash_bit_len) ...@@ -44,7 +44,7 @@ int skein_init(struct skein_ctx *ctx, size_t hash_bit_len)
u64 *X = NULL; u64 *X = NULL;
u64 tree_info = SKEIN_CFG_TREE_INFO_SEQUENTIAL; 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 * The following two lines rely of the fact that the real Skein
* contexts are a union in out context and thus have tha maximum * 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, ...@@ -89,12 +89,12 @@ int skein_mac_init(struct skein_ctx *ctx, const u8 *key, size_t key_len,
size_t X_len = 0; size_t X_len = 0;
u64 tree_info = SKEIN_CFG_TREE_INFO_SEQUENTIAL; 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 = ctx->m.s256.X;
X_len = ctx->skein_size/8; 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) { switch (ctx->skein_size) {
case SKEIN_256: case SKEIN_256:
...@@ -141,7 +141,7 @@ void skein_reset(struct skein_ctx *ctx) ...@@ -141,7 +141,7 @@ void skein_reset(struct skein_ctx *ctx)
memcpy(X, ctx->X_save, X_len); memcpy(X, ctx->X_save, X_len);
/* Setup context to process the message */ /* 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, int skein_update(struct skein_ctx *ctx, const u8 *msg,
...@@ -149,7 +149,7 @@ 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; int ret = SKEIN_FAIL;
Skein_Assert(ctx, SKEIN_FAIL); skein_assert_ret(ctx, SKEIN_FAIL);
switch (ctx->skein_size) { switch (ctx->skein_size) {
case SKEIN_256: case SKEIN_256:
...@@ -185,8 +185,8 @@ int skein_update_bits(struct skein_ctx *ctx, const u8 *msg, ...@@ -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 * only the final Update() call is allowed do partial bytes, else
* assert an error * assert an error
*/ */
Skein_Assert((ctx->m.h.T[1] & SKEIN_T1_FLAG_BIT_PAD) == 0 || skein_assert_ret((ctx->m.h.T[1] & SKEIN_T1_FLAG_BIT_PAD) == 0 ||
msg_bit_cnt == 0, SKEIN_FAIL); msg_bit_cnt == 0, SKEIN_FAIL);
/* if number of bits is a multiple of bytes - that's easy */ /* if number of bits is a multiple of bytes - that's easy */
if ((msg_bit_cnt & 0x7) == 0) if ((msg_bit_cnt & 0x7) == 0)
...@@ -203,13 +203,13 @@ int skein_update_bits(struct skein_ctx *ctx, const u8 *msg, ...@@ -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; up = (u8 *)ctx->m.s256.X + ctx->skein_size / 8;
/* set tweak flag for the skein_final call */ /* 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 */ /* now "pad" the final partial byte the way NIST likes */
/* get the b_cnt value (same location for all block sizes) */ /* get the b_cnt value (same location for all block sizes) */
length = ctx->m.h.b_cnt; length = ctx->m.h.b_cnt;
/* internal sanity check: there IS a partial byte in the buffer! */ /* internal sanity check: there IS a partial byte in the buffer! */
Skein_assert(length != 0); skein_assert(length != 0);
/* partial byte bit mask */ /* partial byte bit mask */
mask = (u8) (1u << (7 - (msg_bit_cnt & 7))); mask = (u8) (1u << (7 - (msg_bit_cnt & 7)));
/* apply bit padding on final byte (in the buffer) */ /* apply bit padding on final byte (in the buffer) */
...@@ -222,7 +222,7 @@ int skein_final(struct skein_ctx *ctx, u8 *hash) ...@@ -222,7 +222,7 @@ int skein_final(struct skein_ctx *ctx, u8 *hash)
{ {
int ret = SKEIN_FAIL; int ret = SKEIN_FAIL;
Skein_Assert(ctx, SKEIN_FAIL); skein_assert_ret(ctx, SKEIN_FAIL);
switch (ctx->skein_size) { switch (ctx->skein_size) {
case SKEIN_256: case SKEIN_256:
......
drivers/staging/skein/skeinBlockNo3F.c
View file @ 0264b7b7
...@@ -11,10 +11,10 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr, ...@@ -11,10 +11,10 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
struct threefish_key key; struct threefish_key key;
u64 tweak[2]; u64 tweak[2];
int i; 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]; 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[0] = ctx->h.T[0];
tweak[1] = ctx->h.T[1]; tweak[1] = ctx->h.T[1];
...@@ -37,7 +37,7 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr, ...@@ -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); threefish_set_key(&key, THREEFISH_256, ctx->X, tweak);
/* get input block in little-endian format */ /* 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); 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, ...@@ -63,9 +63,9 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
u64 tweak[2]; u64 tweak[2];
int i; int i;
u64 words[3]; 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[0] = ctx->h.T[0];
tweak[1] = ctx->h.T[1]; tweak[1] = ctx->h.T[1];
...@@ -88,7 +88,7 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr, ...@@ -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); threefish_set_key(&key, THREEFISH_512, ctx->X, tweak);
/* get input block in little-endian format */ /* 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); 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, ...@@ -118,9 +118,9 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
u64 tweak[2]; u64 tweak[2];
int i; int i;
u64 words[3]; 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[0] = ctx->h.T[0];
tweak[1] = ctx->h.T[1]; tweak[1] = ctx->h.T[1];
...@@ -143,11 +143,11 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr, ...@@ -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); threefish_set_key(&key, THREEFISH_1024, ctx->X, tweak);
/* get input block in little-endian format */ /* 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); 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 */ /* do the final "feedforward" xor, update ctx chaining vars */
ctx->X[0] = ctx->X[0] ^ w[0]; ctx->X[0] = ctx->X[0] ^ w[0];
......
drivers/staging/skein/skein_block.c
View file @ 0264b7b7
...@@ -32,9 +32,9 @@ ...@@ -32,9 +32,9 @@
#define ts (kw + KW_TWK_BASE) #define ts (kw + KW_TWK_BASE)
#ifdef SKEIN_DEBUG #ifdef SKEIN_DEBUG
#define DebugSaveTweak(ctx) { ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #define debug_save_tweak(ctx) { ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; }
#else #else
#define DebugSaveTweak(ctx) #define debug_save_tweak(ctx)
#endif #endif
/***************************** SKEIN_256 ******************************/ /***************************** SKEIN_256 ******************************/
...@@ -70,7 +70,7 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr, ...@@ -70,7 +70,7 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
X_ptr[0] = &X0; X_ptr[1] = &X1; X_ptr[2] = &X2; X_ptr[3] = &X3; X_ptr[0] = &X0; X_ptr[1] = &X1; X_ptr[2] = &X2; X_ptr[3] = &X3;
#endif #endif
Skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */ skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
ts[0] = ctx->h.T[0]; ts[0] = ctx->h.T[0];
ts[1] = ctx->h.T[1]; ts[1] = ctx->h.T[1];
do { do {
...@@ -90,9 +90,9 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr, ...@@ -90,9 +90,9 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
ts[2] = ts[0] ^ ts[1]; ts[2] = ts[0] ^ ts[1];
/* get input block in little-endian format */ /* get input block in little-endian format */
Skein_Get64_LSB_First(w, blk_ptr, WCNT); skein_get64_lsb_first(w, blk_ptr, WCNT);
DebugSaveTweak(ctx); debug_save_tweak(ctx);
Skein_Show_Block(BLK_BITS, &ctx->h, ctx->X, blk_ptr, w, ks, ts); skein_show_block(BLK_BITS, &ctx->h, ctx->X, blk_ptr, w, ks, ts);
X0 = w[0] + ks[0]; /* do the first full key injection */ X0 = w[0] + ks[0]; /* do the first full key injection */
X1 = w[1] + ks[1] + ts[0]; X1 = w[1] + ks[1] + ts[0];
...@@ -100,24 +100,24 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr, ...@@ -100,24 +100,24 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
X3 = w[3] + ks[3]; X3 = w[3] + ks[3];
/* show starting state values */ /* show starting state values */
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INITIAL, skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INITIAL,
X_ptr); X_ptr);
blk_ptr += SKEIN_256_BLOCK_BYTES; blk_ptr += SKEIN_256_BLOCK_BYTES;
/* run the rounds */ /* run the rounds */
#define Round256(p0, p1, p2, p3, ROT, r_num) \ #define ROUND256(p0, p1, p2, p3, ROT, r_num) \
do { \ do { \
X##p0 += X##p1; X##p1 = RotL_64(X##p1, ROT##_0); X##p1 ^= X##p0; \ X##p0 += X##p1; X##p1 = rotl_64(X##p1, ROT##_0); X##p1 ^= X##p0; \
X##p2 += X##p3; X##p3 = RotL_64(X##p3, ROT##_1); X##p3 ^= X##p2; \ X##p2 += X##p3; X##p3 = rotl_64(X##p3, ROT##_1); X##p3 ^= X##p2; \
} while (0) } while (0)
#if SKEIN_UNROLL_256 == 0 #if SKEIN_UNROLL_256 == 0
#define R256(p0, p1, p2, p3, ROT, r_num) /* fully unrolled */ \ #define R256(p0, p1, p2, p3, ROT, r_num) /* fully unrolled */ \
do { \ do { \
Round256(p0, p1, p2, p3, ROT, r_num); \ ROUND256(p0, p1, p2, p3, ROT, r_num); \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, r_num, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, r_num, X_ptr); \
} while (0) } while (0)
#define I256(R) \ #define I256(R) \
...@@ -127,13 +127,13 @@ do { \ ...@@ -127,13 +127,13 @@ do { \
X1 += ks[((R)+2) % 5] + ts[((R)+1) % 3]; \ X1 += ks[((R)+2) % 5] + ts[((R)+1) % 3]; \
X2 += ks[((R)+3) % 5] + ts[((R)+2) % 3]; \ X2 += ks[((R)+3) % 5] + ts[((R)+2) % 3]; \
X3 += ks[((R)+4) % 5] + (R)+1; \ X3 += ks[((R)+4) % 5] + (R)+1; \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \
} while (0) } while (0)
#else /* looping version */ #else /* looping version */
#define R256(p0, p1, p2, p3, ROT, r_num) \ #define R256(p0, p1, p2, p3, ROT, r_num) \
do { \ do { \
Round256(p0, p1, p2, p3, ROT, r_num); \ ROUND256(p0, p1, p2, p3, ROT, r_num); \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, 4 * (r - 1) + r_num, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, 4 * (r - 1) + r_num, X_ptr); \
} while (0) } while (0)
#define I256(R) \ #define I256(R) \
...@@ -146,13 +146,13 @@ do { \ ...@@ -146,13 +146,13 @@ do { \
/* rotate key schedule */ \ /* rotate key schedule */ \
ks[r + (R) + 4] = ks[r + (R) - 1]; \ ks[r + (R) + 4] = ks[r + (R) - 1]; \
ts[r + (R) + 2] = ts[r + (R) - 1]; \ ts[r + (R) + 2] = ts[r + (R) - 1]; \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \
} while (0) } while (0)
for (r = 1; r < 2 * RCNT; r += 2 * SKEIN_UNROLL_256) for (r = 1; r < 2 * RCNT; r += 2 * SKEIN_UNROLL_256)
#endif #endif
{ {
#define R256_8_rounds(R) \ #define R256_8_ROUNDS(R) \
do { \ do { \
R256(0, 1, 2, 3, R_256_0, 8 * (R) + 1); \ R256(0, 1, 2, 3, R_256_0, 8 * (R) + 1); \
R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2); \ R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2); \
...@@ -166,54 +166,54 @@ do { \ ...@@ -166,54 +166,54 @@ do { \
I256(2 * (R) + 1); \ I256(2 * (R) + 1); \
} while (0) } while (0)
R256_8_rounds(0); R256_8_ROUNDS(0);
#define R256_Unroll_R(NN) \ #define R256_UNROLL_R(NN) \
((SKEIN_UNROLL_256 == 0 && \ ((SKEIN_UNROLL_256 == 0 && \
SKEIN_256_ROUNDS_TOTAL/8 > (NN)) || \ SKEIN_256_ROUNDS_TOTAL/8 > (NN)) || \
(SKEIN_UNROLL_256 > (NN))) (SKEIN_UNROLL_256 > (NN)))
#if R256_Unroll_R(1) #if R256_UNROLL_R(1)
R256_8_rounds(1); R256_8_ROUNDS(1);
#endif #endif
#if R256_Unroll_R(2) #if R256_UNROLL_R(2)
R256_8_rounds(2); R256_8_ROUNDS(2);
#endif #endif
#if R256_Unroll_R(3) #if R256_UNROLL_R(3)
R256_8_rounds(3); R256_8_ROUNDS(3);
#endif #endif
#if R256_Unroll_R(4) #if R256_UNROLL_R(4)
R256_8_rounds(4); R256_8_ROUNDS(4);
#endif #endif
#if R256_Unroll_R(5) #if R256_UNROLL_R(5)
R256_8_rounds(5); R256_8_ROUNDS(5);
#endif #endif
#if R256_Unroll_R(6) #if R256_UNROLL_R(6)
R256_8_rounds(6); R256_8_ROUNDS(6);
#endif #endif
#if R256_Unroll_R(7) #if R256_UNROLL_R(7)
R256_8_rounds(7); R256_8_ROUNDS(7);
#endif #endif
#if R256_Unroll_R(8) #if R256_UNROLL_R(8)
R256_8_rounds(8); R256_8_ROUNDS(8);
#endif #endif
#if R256_Unroll_R(9) #if R256_UNROLL_R(9)
R256_8_rounds(9); R256_8_ROUNDS(9);
#endif #endif
#if R256_Unroll_R(10) #if R256_UNROLL_R(10)
R256_8_rounds(10); R256_8_ROUNDS(10);
#endif #endif
#if R256_Unroll_R(11) #if R256_UNROLL_R(11)
R256_8_rounds(11); R256_8_ROUNDS(11);
#endif #endif
#if R256_Unroll_R(12) #if R256_UNROLL_R(12)
R256_8_rounds(12); R256_8_ROUNDS(12);
#endif #endif
#if R256_Unroll_R(13) #if R256_UNROLL_R(13)
R256_8_rounds(13); R256_8_ROUNDS(13);
#endif #endif
#if R256_Unroll_R(14) #if R256_UNROLL_R(14)
R256_8_rounds(14); R256_8_ROUNDS(14);
#endif #endif
#if (SKEIN_UNROLL_256 > 14) #if (SKEIN_UNROLL_256 > 14)
#error "need more unrolling in skein_256_process_block" #error "need more unrolling in skein_256_process_block"
...@@ -225,7 +225,7 @@ do { \ ...@@ -225,7 +225,7 @@ do { \
ctx->X[2] = X2 ^ w[2]; ctx->X[2] = X2 ^ w[2];
ctx->X[3] = X3 ^ w[3]; ctx->X[3] = X3 ^ w[3];
Skein_Show_Round(BLK_BITS, &ctx->h, SKEIN_RND_FEED_FWD, ctx->X); skein_show_round(BLK_BITS, &ctx->h, SKEIN_RND_FEED_FWD, ctx->X);
ts[1] &= ~SKEIN_T1_FLAG_FIRST; ts[1] &= ~SKEIN_T1_FLAG_FIRST;
} while (--blk_cnt); } while (--blk_cnt);
...@@ -281,7 +281,7 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr, ...@@ -281,7 +281,7 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
X_ptr[4] = &X4; X_ptr[5] = &X5; X_ptr[6] = &X6; X_ptr[7] = &X7; X_ptr[4] = &X4; X_ptr[5] = &X5; X_ptr[6] = &X6; X_ptr[7] = &X7;
#endif #endif
Skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */ skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
ts[0] = ctx->h.T[0]; ts[0] = ctx->h.T[0];
ts[1] = ctx->h.T[1]; ts[1] = ctx->h.T[1];
do { do {
...@@ -306,9 +306,9 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr, ...@@ -306,9 +306,9 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
ts[2] = ts[0] ^ ts[1]; ts[2] = ts[0] ^ ts[1];
/* get input block in little-endian format */ /* get input block in little-endian format */
Skein_Get64_LSB_First(w, blk_ptr, WCNT); skein_get64_lsb_first(w, blk_ptr, WCNT);
DebugSaveTweak(ctx); debug_save_tweak(ctx);
Skein_Show_Block(BLK_BITS, &ctx->h, ctx->X, blk_ptr, w, ks, ts); skein_show_block(BLK_BITS, &ctx->h, ctx->X, blk_ptr, w, ks, ts);
X0 = w[0] + ks[0]; /* do the first full key injection */ X0 = w[0] + ks[0]; /* do the first full key injection */
X1 = w[1] + ks[1]; X1 = w[1] + ks[1];
...@@ -321,22 +321,22 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr, ...@@ -321,22 +321,22 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
blk_ptr += SKEIN_512_BLOCK_BYTES; blk_ptr += SKEIN_512_BLOCK_BYTES;
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INITIAL, skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INITIAL,
X_ptr); X_ptr);
/* run the rounds */ /* run the rounds */
#define Round512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \ #define ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
do { \ do { \
X##p0 += X##p1; X##p1 = RotL_64(X##p1, ROT##_0); X##p1 ^= X##p0; \ X##p0 += X##p1; X##p1 = rotl_64(X##p1, ROT##_0); X##p1 ^= X##p0; \
X##p2 += X##p3; X##p3 = RotL_64(X##p3, ROT##_1); X##p3 ^= X##p2; \ X##p2 += X##p3; X##p3 = rotl_64(X##p3, ROT##_1); X##p3 ^= X##p2; \
X##p4 += X##p5; X##p5 = RotL_64(X##p5, ROT##_2); X##p5 ^= X##p4; \ X##p4 += X##p5; X##p5 = rotl_64(X##p5, ROT##_2); X##p5 ^= X##p4; \
X##p6 += X##p7; X##p7 = RotL_64(X##p7, ROT##_3); X##p7 ^= X##p6; \ X##p6 += X##p7; X##p7 = rotl_64(X##p7, ROT##_3); X##p7 ^= X##p6; \
} while (0) } while (0)
#if SKEIN_UNROLL_512 == 0 #if SKEIN_UNROLL_512 == 0
#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) /* unrolled */ \ #define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) /* unrolled */ \
do { \ do { \
Round512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \ ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, r_num, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, r_num, X_ptr); \
} while (0) } while (0)
#define I512(R) \ #define I512(R) \
...@@ -350,13 +350,13 @@ do { \ ...@@ -350,13 +350,13 @@ do { \
X5 += ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \ X5 += ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \
X6 += ks[((R) + 7) % 9] + ts[((R) + 2) % 3]; \ X6 += ks[((R) + 7) % 9] + ts[((R) + 2) % 3]; \
X7 += ks[((R) + 8) % 9] + (R) + 1; \ X7 += ks[((R) + 8) % 9] + (R) + 1; \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \
} while (0) } while (0)
#else /* looping version */ #else /* looping version */
#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \ #define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
do { \ do { \
Round512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num); \ ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num); \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, 4 * (r - 1) + r_num, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, 4 * (r - 1) + r_num, X_ptr); \
} while (0) } while (0)
#define I512(R) \ #define I512(R) \
...@@ -373,13 +373,13 @@ do { \ ...@@ -373,13 +373,13 @@ do { \
/* rotate key schedule */ \ /* rotate key schedule */ \
ks[r + (R) + 8] = ks[r + (R) - 1]; \ ks[r + (R) + 8] = ks[r + (R) - 1]; \
ts[r + (R) + 2] = ts[r + (R) - 1]; \ ts[r + (R) + 2] = ts[r + (R) - 1]; \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \
} while (0) } while (0)
for (r = 1; r < 2 * RCNT; r += 2 * SKEIN_UNROLL_512) for (r = 1; r < 2 * RCNT; r += 2 * SKEIN_UNROLL_512)
#endif /* end of looped code definitions */ #endif /* end of looped code definitions */
{ {
#define R512_8_rounds(R) /* do 8 full rounds */ \ #define R512_8_ROUNDS(R) /* do 8 full rounds */ \
do { \ do { \
R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8 * (R) + 1); \ R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8 * (R) + 1); \
R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2); \ R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2); \
...@@ -393,54 +393,54 @@ do { \ ...@@ -393,54 +393,54 @@ do { \
I512(2 * (R) + 1); /* and key injection */ \ I512(2 * (R) + 1); /* and key injection */ \
} while (0) } while (0)
R512_8_rounds(0); R512_8_ROUNDS(0);
#define R512_Unroll_R(NN) \ #define R512_UNROLL_R(NN) \
((SKEIN_UNROLL_512 == 0 && \ ((SKEIN_UNROLL_512 == 0 && \
SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \ SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \
(SKEIN_UNROLL_512 > (NN))) (SKEIN_UNROLL_512 > (NN)))
#if R512_Unroll_R(1) #if R512_UNROLL_R(1)
R512_8_rounds(1); R512_8_ROUNDS(1);
#endif #endif
#if R512_Unroll_R(2) #if R512_UNROLL_R(2)
R512_8_rounds(2); R512_8_ROUNDS(2);
#endif #endif
#if R512_Unroll_R(3) #if R512_UNROLL_R(3)
R512_8_rounds(3); R512_8_ROUNDS(3);
#endif #endif
#if R512_Unroll_R(4) #if R512_UNROLL_R(4)
R512_8_rounds(4); R512_8_ROUNDS(4);
#endif #endif
#if R512_Unroll_R(5) #if R512_UNROLL_R(5)
R512_8_rounds(5); R512_8_ROUNDS(5);
#endif #endif
#if R512_Unroll_R(6) #if R512_UNROLL_R(6)
R512_8_rounds(6); R512_8_ROUNDS(6);
#endif #endif
#if R512_Unroll_R(7) #if R512_UNROLL_R(7)
R512_8_rounds(7); R512_8_ROUNDS(7);
#endif #endif
#if R512_Unroll_R(8) #if R512_UNROLL_R(8)
R512_8_rounds(8); R512_8_ROUNDS(8);
#endif #endif
#if R512_Unroll_R(9) #if R512_UNROLL_R(9)
R512_8_rounds(9); R512_8_ROUNDS(9);
#endif #endif
#if R512_Unroll_R(10) #if R512_UNROLL_R(10)
R512_8_rounds(10); R512_8_ROUNDS(10);
#endif #endif
#if R512_Unroll_R(11) #if R512_UNROLL_R(11)
R512_8_rounds(11); R512_8_ROUNDS(11);
#endif #endif
#if R512_Unroll_R(12) #if R512_UNROLL_R(12)
R512_8_rounds(12); R512_8_ROUNDS(12);
#endif #endif
#if R512_Unroll_R(13) #if R512_UNROLL_R(13)
R512_8_rounds(13); R512_8_ROUNDS(13);
#endif #endif
#if R512_Unroll_R(14) #if R512_UNROLL_R(14)
R512_8_rounds(14); R512_8_ROUNDS(14);
#endif #endif
#if (SKEIN_UNROLL_512 > 14) #if (SKEIN_UNROLL_512 > 14)
#error "need more unrolling in skein_512_process_block" #error "need more unrolling in skein_512_process_block"
...@@ -456,7 +456,7 @@ do { \ ...@@ -456,7 +456,7 @@ do { \
ctx->X[5] = X5 ^ w[5]; ctx->X[5] = X5 ^ w[5];
ctx->X[6] = X6 ^ w[6]; ctx->X[6] = X6 ^ w[6];
ctx->X[7] = X7 ^ w[7]; ctx->X[7] = X7 ^ w[7];
Skein_Show_Round(BLK_BITS, &ctx->h, SKEIN_RND_FEED_FWD, ctx->X); skein_show_round(BLK_BITS, &ctx->h, SKEIN_RND_FEED_FWD, ctx->X);
ts[1] &= ~SKEIN_T1_FLAG_FIRST; ts[1] &= ~SKEIN_T1_FLAG_FIRST;
} while (--blk_cnt); } while (--blk_cnt);
...@@ -483,10 +483,10 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr, ...@@ -483,10 +483,10 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
size_t blk_cnt, size_t byte_cnt_add) size_t blk_cnt, size_t byte_cnt_add)
{ /* do it in C, always looping (unrolled is bigger AND slower!) */ { /* do it in C, always looping (unrolled is bigger AND slower!) */
enum { enum {
WCNT = SKEIN1024_STATE_WORDS WCNT = SKEIN_1024_STATE_WORDS
}; };
#undef RCNT #undef RCNT
#define RCNT (SKEIN1024_ROUNDS_TOTAL/8) #define RCNT (SKEIN_1024_ROUNDS_TOTAL/8)
#ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #ifdef SKEIN_LOOP /* configure how much to unroll the loop */
#define SKEIN_UNROLL_1024 ((SKEIN_LOOP)%10) #define SKEIN_UNROLL_1024 ((SKEIN_LOOP)%10)
...@@ -519,7 +519,7 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr, ...@@ -519,7 +519,7 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
X_ptr[15] = &X15; X_ptr[15] = &X15;
#endif #endif
Skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */ skein_assert(blk_cnt != 0); /* never call with blk_cnt == 0! */
ts[0] = ctx->h.T[0]; ts[0] = ctx->h.T[0];
ts[1] = ctx->h.T[1]; ts[1] = ctx->h.T[1];
do { do {
...@@ -554,9 +554,9 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr, ...@@ -554,9 +554,9 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
ts[2] = ts[0] ^ ts[1]; ts[2] = ts[0] ^ ts[1];
/* get input block in little-endian format */ /* get input block in little-endian format */
Skein_Get64_LSB_First(w, blk_ptr, WCNT); skein_get64_lsb_first(w, blk_ptr, WCNT);
DebugSaveTweak(ctx); debug_save_tweak(ctx);
Skein_Show_Block(BLK_BITS, &ctx->h, ctx->X, blk_ptr, w, ks, ts); skein_show_block(BLK_BITS, &ctx->h, ctx->X, blk_ptr, w, ks, ts);
X00 = w[0] + ks[0]; /* do the first full key injection */ X00 = w[0] + ks[0]; /* do the first full key injection */
X01 = w[1] + ks[1]; X01 = w[1] + ks[1];
...@@ -575,29 +575,29 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr, ...@@ -575,29 +575,29 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
X14 = w[14] + ks[14] + ts[1]; X14 = w[14] + ks[14] + ts[1];
X15 = w[15] + ks[15]; X15 = w[15] + ks[15];
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INITIAL, skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INITIAL,
X_ptr); X_ptr);
#define Round1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \ #define ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
pF, ROT, r_num) \ pF, ROT, r_num) \
do { \ do { \
X##p0 += X##p1; X##p1 = RotL_64(X##p1, ROT##_0); X##p1 ^= X##p0; \ X##p0 += X##p1; X##p1 = rotl_64(X##p1, ROT##_0); X##p1 ^= X##p0; \
X##p2 += X##p3; X##p3 = RotL_64(X##p3, ROT##_1); X##p3 ^= X##p2; \ X##p2 += X##p3; X##p3 = rotl_64(X##p3, ROT##_1); X##p3 ^= X##p2; \
X##p4 += X##p5; X##p5 = RotL_64(X##p5, ROT##_2); X##p5 ^= X##p4; \ X##p4 += X##p5; X##p5 = rotl_64(X##p5, ROT##_2); X##p5 ^= X##p4; \
X##p6 += X##p7; X##p7 = RotL_64(X##p7, ROT##_3); X##p7 ^= X##p6; \ X##p6 += X##p7; X##p7 = rotl_64(X##p7, ROT##_3); X##p7 ^= X##p6; \
X##p8 += X##p9; X##p9 = RotL_64(X##p9, ROT##_4); X##p9 ^= X##p8; \ X##p8 += X##p9; X##p9 = rotl_64(X##p9, ROT##_4); X##p9 ^= X##p8; \
X##pA += X##pB; X##pB = RotL_64(X##pB, ROT##_5); X##pB ^= X##pA; \ X##pA += X##pB; X##pB = rotl_64(X##pB, ROT##_5); X##pB ^= X##pA; \
X##pC += X##pD; X##pD = RotL_64(X##pD, ROT##_6); X##pD ^= X##pC; \ X##pC += X##pD; X##pD = rotl_64(X##pD, ROT##_6); X##pD ^= X##pC; \
X##pE += X##pF; X##pF = RotL_64(X##pF, ROT##_7); X##pF ^= X##pE; \ X##pE += X##pF; X##pF = rotl_64(X##pF, ROT##_7); X##pF ^= X##pE; \
} while (0) } while (0)
#if SKEIN_UNROLL_1024 == 0 #if SKEIN_UNROLL_1024 == 0
#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \ #define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \
ROT, rn) \ ROT, rn) \
do { \ do { \
Round1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \ ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
pF, ROT, rn) \ pF, ROT, rn); \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, rn, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, rn, X_ptr); \
} while (0) } while (0)
#define I1024(R) \ #define I1024(R) \
...@@ -619,15 +619,15 @@ do { \ ...@@ -619,15 +619,15 @@ do { \
X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \ X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \
X14 += ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \ X14 += ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \
X15 += ks[((R) + 16) % 17] + (R) + 1; \ X15 += ks[((R) + 16) % 17] + (R) + 1; \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \
} while (0) } while (0)
#else /* looping version */ #else /* looping version */
#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \ #define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \
ROT, rn) \ ROT, rn) \
do { \ do { \
Round1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \ ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
pF, ROT, rn) \ pF, ROT, rn); \
Skein_Show_R_Ptr(BLK_BITS, &ctx->h, 4 * (r - 1) + rn, X_ptr); \ skein_show_r_ptr(BLK_BITS, &ctx->h, 4 * (r - 1) + rn, X_ptr); \
} while (0) } while (0)
#define I1024(R) \ #define I1024(R) \
...@@ -652,13 +652,13 @@ do { \ ...@@ -652,13 +652,13 @@ do { \
/* rotate key schedule */ \ /* rotate key schedule */ \
ks[r + (R) + 16] = ks[r + (R) - 1]; \ ks[r + (R) + 16] = ks[r + (R) - 1]; \
ts[r + (R) + 2] = ts[r + (R) - 1]; \ ts[r + (R) + 2] = ts[r + (R) - 1]; \
Skein_Show_R_Ptr(BLK_BITSi, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \ skein_show_r_ptr(BLK_BITSi, &ctx->h, SKEIN_RND_KEY_INJECT, X_ptr); \
} while (0) } while (0)
for (r = 1; r <= 2 * RCNT; r += 2 * SKEIN_UNROLL_1024) for (r = 1; r <= 2 * RCNT; r += 2 * SKEIN_UNROLL_1024)
#endif #endif
{ {
#define R1024_8_rounds(R) \ #define R1024_8_ROUNDS(R) \
do { \ do { \
R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, \ R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, \
R1024_0, 8*(R) + 1); \ R1024_0, 8*(R) + 1); \
...@@ -680,54 +680,54 @@ do { \ ...@@ -680,54 +680,54 @@ do { \
I1024(2*(R)+1); \ I1024(2*(R)+1); \
} while (0) } while (0)
R1024_8_rounds(0); R1024_8_ROUNDS(0);
#define R1024_Unroll_R(NN) \ #define R1024_UNROLL_R(NN) \
((SKEIN_UNROLL_1024 == 0 && \ ((SKEIN_UNROLL_1024 == 0 && \
SKEIN1024_ROUNDS_TOTAL/8 > (NN)) || \ SKEIN_1024_ROUNDS_TOTAL/8 > (NN)) || \
(SKEIN_UNROLL_1024 > (NN))) (SKEIN_UNROLL_1024 > (NN)))
#if R1024_Unroll_R(1) #if R1024_UNROLL_R(1)
R1024_8_rounds(1); R1024_8_ROUNDS(1);
#endif #endif
#if R1024_Unroll_R(2) #if R1024_UNROLL_R(2)
R1024_8_rounds(2); R1024_8_ROUNDS(2);
#endif #endif
#if R1024_Unroll_R(3) #if R1024_UNROLL_R(3)
R1024_8_rounds(3); R1024_8_ROUNDS(3);
#endif #endif
#if R1024_Unroll_R(4) #if R1024_UNROLL_R(4)
R1024_8_rounds(4); R1024_8_ROUNDS(4);
#endif #endif
#if R1024_Unroll_R(5) #if R1024_UNROLL_R(5)
R1024_8_rounds(5); R1024_8_ROUNDS(5);
#endif #endif
#if R1024_Unroll_R(6) #if R1024_UNROLL_R(6)
R1024_8_rounds(6); R1024_8_ROUNDS(6);
#endif #endif
#if R1024_Unroll_R(7) #if R1024_UNROLL_R(7)
R1024_8_rounds(7); R1024_8_ROUNDS(7);
#endif #endif
#if R1024_Unroll_R(8) #if R1024_UNROLL_R(8)
R1024_8_rounds(8); R1024_8_ROUNDS(8);
#endif #endif
#if R1024_Unroll_R(9) #if R1024_UNROLL_R(9)
R1024_8_rounds(9); R1024_8_ROUNDS(9);
#endif #endif
#if R1024_Unroll_R(10) #if R1024_UNROLL_R(10)
R1024_8_rounds(10); R1024_8_ROUNDS(10);
#endif #endif
#if R1024_Unroll_R(11) #if R1024_UNROLL_R(11)
R1024_8_rounds(11); R1024_8_ROUNDS(11);
#endif #endif
#if R1024_Unroll_R(12) #if R1024_UNROLL_R(12)
R1024_8_rounds(12); R1024_8_ROUNDS(12);
#endif #endif
#if R1024_Unroll_R(13) #if R1024_UNROLL_R(13)
R1024_8_rounds(13); R1024_8_ROUNDS(13);
#endif #endif
#if R1024_Unroll_R(14) #if R1024_UNROLL_R(14)
R1024_8_rounds(14); R1024_8_ROUNDS(14);
#endif #endif
#if (SKEIN_UNROLL_1024 > 14) #if (SKEIN_UNROLL_1024 > 14)
#error "need more unrolling in Skein_1024_Process_Block" #error "need more unrolling in Skein_1024_Process_Block"
...@@ -752,10 +752,10 @@ do { \ ...@@ -752,10 +752,10 @@ do { \
ctx->X[14] = X14 ^ w[14]; ctx->X[14] = X14 ^ w[14];
ctx->X[15] = X15 ^ w[15]; ctx->X[15] = X15 ^ w[15];
Skein_Show_Round(BLK_BITS, &ctx->h, SKEIN_RND_FEED_FWD, ctx->X); skein_show_round(BLK_BITS, &ctx->h, SKEIN_RND_FEED_FWD, ctx->X);
ts[1] &= ~SKEIN_T1_FLAG_FIRST; ts[1] &= ~SKEIN_T1_FLAG_FIRST;
blk_ptr += SKEIN1024_BLOCK_BYTES; blk_ptr += SKEIN_1024_BLOCK_BYTES;
} while (--blk_cnt); } while (--blk_cnt);
ctx->h.T[0] = ts[0]; ctx->h.T[0] = ts[0];
ctx->h.T[1] = ts[1]; ctx->h.T[1] = ts[1];
......
drivers/staging/skein/threefishApi.c
View file @ 0264b7b7
...@@ -9,7 +9,7 @@ void threefish_set_key(struct threefish_key *key_ctx, ...@@ -9,7 +9,7 @@ void threefish_set_key(struct threefish_key *key_ctx,
{ {
int key_words = state_size / 64; int key_words = state_size / 64;
int i; int i;
u64 parity = KeyScheduleConst; u64 parity = KEY_SCHEDULE_CONST;
key_ctx->tweak[0] = tweak[0]; key_ctx->tweak[0] = tweak[0];
key_ctx->tweak[1] = tweak[1]; key_ctx->tweak[1] = tweak[1];
...@@ -29,9 +29,9 @@ void threefish_encrypt_block_bytes(struct threefish_key *key_ctx, u8 *in, ...@@ -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 plain[SKEIN_MAX_STATE_WORDS]; /* max number of words*/
u64 cipher[SKEIN_MAX_STATE_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); 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, 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, ...@@ -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 plain[SKEIN_MAX_STATE_WORDS]; /* max number of words*/
u64 cipher[SKEIN_MAX_STATE_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); 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, void threefish_decrypt_block_words(struct threefish_key *key_ctx, u64 *in,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7