Commit 68ace624 authored by Anton Saraev's avatar Anton Saraev Committed by Greg Kroah-Hartman

staging: crypto: skein: rename camelcase functions

camelCase is not accepted in the Linux Kernel. To prepare skein
driver for mainline inclusion, we rename all functions to
non-camelCase equivalents.
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 6559e221
skein/threefish TODO
- rename camelcase vars
- rename camelcase functions
- rename files
- move macros into appropriate header files
- add / pass test vectors
......
......@@ -86,59 +86,59 @@ struct skein1024_ctx { /* 1024-bit Skein hash context structure */
u8 b[SKEIN1024_BLOCK_BYTES]; /* partial block buf (8-byte aligned) */
};
/* Skein APIs for (incremental) "straight hashing" */
int Skein_256_Init(struct skein_256_ctx *ctx, size_t hashBitLen);
int Skein_512_Init(struct skein_512_ctx *ctx, size_t hashBitLen);
int Skein1024_Init(struct skein1024_ctx *ctx, size_t hashBitLen);
int Skein_256_Update(struct skein_256_ctx *ctx, const u8 *msg,
size_t msgByteCnt);
int Skein_512_Update(struct skein_512_ctx *ctx, const u8 *msg,
size_t msgByteCnt);
int Skein1024_Update(struct skein1024_ctx *ctx, const u8 *msg,
size_t msgByteCnt);
int Skein_256_Final(struct skein_256_ctx *ctx, u8 *hashVal);
int Skein_512_Final(struct skein_512_ctx *ctx, u8 *hashVal);
int Skein1024_Final(struct skein1024_ctx *ctx, u8 *hashVal);
/* Skein APIs for (incremental) "straight hashing" */
int skein_256_init(struct skein_256_ctx *ctx, size_t hashBitLen);
int skein_512_init(struct skein_512_ctx *ctx, size_t hashBitLen);
int skein_1024_init(struct skein1024_ctx *ctx, size_t hashBitLen);
int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg,
size_t msgByteCnt);
int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg,
size_t msgByteCnt);
int skein_1024_update(struct skein1024_ctx *ctx, const u8 *msg,
size_t msgByteCnt);
int skein_256_final(struct skein_256_ctx *ctx, u8 *hashVal);
int skein_512_final(struct skein_512_ctx *ctx, u8 *hashVal);
int skein_1024_final(struct skein1024_ctx *ctx, u8 *hashVal);
/*
** Skein APIs for "extended" initialization: MAC keys, tree hashing.
** After an InitExt() call, just use Update/Final calls as with Init().
** After an init_ext() call, just use update/final calls as with init().
**
** Notes: Same parameters as _Init() calls, plus treeInfo/key/keyBytes.
** Notes: Same parameters as _init() calls, plus treeInfo/key/keyBytes.
** When keyBytes == 0 and treeInfo == SKEIN_SEQUENTIAL,
** the results of InitExt() are identical to calling Init().
** The function Init() may be called once to "precompute" the IV for
** the results of init_ext() are identical to calling init().
** The function init() may be called once to "precompute" the IV for
** a given hashBitLen value, then by saving a copy of the context
** the IV computation may be avoided in later calls.
** Similarly, the function InitExt() may be called once per MAC key
** Similarly, the function init_ext() may be called once per MAC key
** to precompute the MAC IV, then a copy of the context saved and
** reused for each new MAC computation.
**/
int Skein_256_InitExt(struct skein_256_ctx *ctx, size_t hashBitLen,
u64 treeInfo, const u8 *key, size_t keyBytes);
int Skein_512_InitExt(struct skein_512_ctx *ctx, size_t hashBitLen,
u64 treeInfo, const u8 *key, size_t keyBytes);
int Skein1024_InitExt(struct skein1024_ctx *ctx, size_t hashBitLen,
int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hashBitLen,
u64 treeInfo, const u8 *key, size_t keyBytes);
int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hashBitLen,
u64 treeInfo, const u8 *key, size_t keyBytes);
int skein_1024_init_ext(struct skein1024_ctx *ctx, size_t hashBitLen,
u64 treeInfo, const u8 *key, size_t keyBytes);
/*
** Skein APIs for MAC and tree hash:
** Final_Pad: pad, do final block, but no OUTPUT type
** Output: do just the output stage
** final_pad: pad, do final block, but no OUTPUT type
** output: do just the output stage
*/
int Skein_256_Final_Pad(struct skein_256_ctx *ctx, u8 *hashVal);
int Skein_512_Final_Pad(struct skein_512_ctx *ctx, u8 *hashVal);
int Skein1024_Final_Pad(struct skein1024_ctx *ctx, u8 *hashVal);
int skein_256_final_pad(struct skein_256_ctx *ctx, u8 *hashVal);
int skein_512_final_pad(struct skein_512_ctx *ctx, u8 *hashVal);
int skein_1024_final_pad(struct skein1024_ctx *ctx, u8 *hashVal);
#ifndef SKEIN_TREE_HASH
#define SKEIN_TREE_HASH (1)
#endif
#if SKEIN_TREE_HASH
int Skein_256_Output(struct skein_256_ctx *ctx, u8 *hashVal);
int Skein_512_Output(struct skein_512_ctx *ctx, u8 *hashVal);
int Skein1024_Output(struct skein1024_ctx *ctx, u8 *hashVal);
int skein_256_output(struct skein_256_ctx *ctx, u8 *hashVal);
int skein_512_output(struct skein_512_ctx *ctx, u8 *hashVal);
int skein_1024_output(struct skein1024_ctx *ctx, u8 *hashVal);
#endif
/*****************************************************************
......
......@@ -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);
/**
* @}
......
......@@ -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
......@@ -21,10 +21,10 @@
struct threefish_key keyCtx;
// Initialize the context
threefishSetKey(&keyCtx, Threefish512, key, tweak);
threefish_set_key(&keyCtx, Threefish512, key, tweak);
// Encrypt
threefishEncryptBlockBytes(&keyCtx, input, cipher);
threefish_encrypt_block_bytes(&keyCtx, input, cipher);
@endcode
*/
......@@ -72,9 +72,9 @@ struct threefish_key {
* @param tweak
* Pointer to the two tweak words (word has 64 bits).
*/
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);
/**
* Encrypt Threefisch block (bytes).
......@@ -91,7 +91,8 @@ void threefishSetKey(struct threefish_key *keyCtx,
* @param out
* Pointer to cipher buffer.
*/
void threefishEncryptBlockBytes(struct threefish_key *keyCtx, u8 *in, u8 *out);
void threefish_encrypt_block_bytes(struct threefish_key *keyCtx, u8 *in,
u8 *out);
/**
* Encrypt Threefisch block (words).
......@@ -110,8 +111,8 @@ void threefishEncryptBlockBytes(struct threefish_key *keyCtx, u8 *in, u8 *out);
* @param out
* Pointer to cipher buffer.
*/
void threefishEncryptBlockWords(struct threefish_key *keyCtx, u64 *in,
u64 *out);
void threefish_encrypt_block_words(struct threefish_key *keyCtx, u64 *in,
u64 *out);
/**
* Decrypt Threefisch block (bytes).
......@@ -128,7 +129,8 @@ void threefishEncryptBlockWords(struct threefish_key *keyCtx, u64 *in,
* @param out
* Pointer to plaintext buffer.
*/
void threefishDecryptBlockBytes(struct threefish_key *keyCtx, u8 *in, u8 *out);
void threefish_decrypt_block_bytes(struct threefish_key *keyCtx, u8 *in,
u8 *out);
/**
* Decrypt Threefisch block (words).
......@@ -147,17 +149,21 @@ void threefishDecryptBlockBytes(struct threefish_key *keyCtx, u8 *in, u8 *out);
* @param out
* Pointer to plaintext buffer.
*/
void threefishDecryptBlockWords(struct threefish_key *keyCtx, u64 *in,
u64 *out);
void threefish_decrypt_block_words(struct threefish_key *keyCtx, u64 *in,
u64 *out);
void threefishEncrypt256(struct threefish_key *keyCtx, u64 *input, u64 *output);
void threefishEncrypt512(struct threefish_key *keyCtx, u64 *input, u64 *output);
void threefishEncrypt1024(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefishDecrypt256(struct threefish_key *keyCtx, u64 *input, u64 *output);
void threefishDecrypt512(struct threefish_key *keyCtx, u64 *input, u64 *output);
void threefishDecrypt1024(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefish_encrypt_256(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefish_encrypt_512(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefish_encrypt_1024(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefish_decrypt_256(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefish_decrypt_512(struct threefish_key *keyCtx, u64 *input,
u64 *output);
void threefish_decrypt_1024(struct threefish_key *keyCtx, u64 *input,
u64 *output);
/**
* @}
*/
......
This diff is collapsed.
......@@ -27,7 +27,7 @@ OTHER DEALINGS IN THE SOFTWARE.
#include <linux/string.h>
#include <skeinApi.h>
int skeinCtxPrepare(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);
......@@ -37,7 +37,7 @@ int skeinCtxPrepare(struct skein_ctx *ctx, enum skein_size size)
return SKEIN_SUCCESS;
}
int skeinInit(struct skein_ctx *ctx, size_t hashBitLen)
int skein_init(struct skein_ctx *ctx, size_t hashBitLen)
{
int ret = SKEIN_FAIL;
size_t Xlen = 0;
......@@ -58,16 +58,16 @@ int skeinInit(struct skein_ctx *ctx, size_t hashBitLen)
*/
switch (ctx->skeinSize) {
case Skein256:
ret = Skein_256_InitExt(&ctx->m.s256, hashBitLen,
treeInfo, NULL, 0);
ret = skein_256_init_ext(&ctx->m.s256, hashBitLen,
treeInfo, NULL, 0);
break;
case Skein512:
ret = Skein_512_InitExt(&ctx->m.s512, hashBitLen,
treeInfo, NULL, 0);
ret = skein_512_init_ext(&ctx->m.s512, hashBitLen,
treeInfo, NULL, 0);
break;
case Skein1024:
ret = Skein1024_InitExt(&ctx->m.s1024, hashBitLen,
treeInfo, NULL, 0);
ret = skein_1024_init_ext(&ctx->m.s1024, hashBitLen,
treeInfo, NULL, 0);
break;
}
......@@ -81,8 +81,8 @@ int skeinInit(struct skein_ctx *ctx, size_t hashBitLen)
return ret;
}
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)
{
int ret = SKEIN_FAIL;
u64 *X = NULL;
......@@ -98,20 +98,20 @@ int skeinMacInit(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
switch (ctx->skeinSize) {
case Skein256:
ret = Skein_256_InitExt(&ctx->m.s256, hashBitLen,
treeInfo,
(const u8 *)key, keyLen);
ret = skein_256_init_ext(&ctx->m.s256, hashBitLen,
treeInfo,
(const u8 *)key, keyLen);
break;
case Skein512:
ret = Skein_512_InitExt(&ctx->m.s512, hashBitLen,
treeInfo,
(const u8 *)key, keyLen);
ret = skein_512_init_ext(&ctx->m.s512, hashBitLen,
treeInfo,
(const u8 *)key, keyLen);
break;
case Skein1024:
ret = Skein1024_InitExt(&ctx->m.s1024, hashBitLen,
treeInfo,
(const u8 *)key, keyLen);
ret = skein_1024_init_ext(&ctx->m.s1024, hashBitLen,
treeInfo,
(const u8 *)key, keyLen);
break;
}
......@@ -125,7 +125,7 @@ int skeinMacInit(struct skein_ctx *ctx, const u8 *key, size_t keyLen,
return ret;
}
void skeinReset(struct skein_ctx *ctx)
void skein_reset(struct skein_ctx *ctx)
{
size_t Xlen = 0;
u64 *X = NULL;
......@@ -144,23 +144,23 @@ void skeinReset(struct skein_ctx *ctx)
Skein_Start_New_Type(&ctx->m, MSG);
}
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)
{
int ret = SKEIN_FAIL;
Skein_Assert(ctx, SKEIN_FAIL);
switch (ctx->skeinSize) {
case Skein256:
ret = Skein_256_Update(&ctx->m.s256, (const u8 *)msg,
msgByteCnt);
ret = skein_256_update(&ctx->m.s256, (const u8 *)msg,
msgByteCnt);
break;
case Skein512:
ret = Skein_512_Update(&ctx->m.s512, (const u8 *)msg,
msgByteCnt);
ret = skein_512_update(&ctx->m.s512, (const u8 *)msg,
msgByteCnt);
break;
case Skein1024:
ret = Skein1024_Update(&ctx->m.s1024, (const u8 *)msg,
ret = skein_1024_update(&ctx->m.s1024, (const u8 *)msg,
msgByteCnt);
break;
}
......@@ -168,8 +168,8 @@ int skeinUpdate(struct skein_ctx *ctx, const u8 *msg,
}
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)
{
/*
* I've used the bit pad implementation from skein_test.c (see NIST CD)
......@@ -189,9 +189,9 @@ int skeinUpdateBits(struct skein_ctx *ctx, const u8 *msg,
/* if number of bits is a multiple of bytes - that's easy */
if ((msgBitCnt & 0x7) == 0)
return skeinUpdate(ctx, msg, msgBitCnt >> 3);
return skein_update(ctx, msg, msgBitCnt >> 3);
skeinUpdate(ctx, msg, (msgBitCnt >> 3) + 1);
skein_update(ctx, msg, (msgBitCnt >> 3) + 1);
/*
* The next line rely on the fact that the real Skein contexts
......@@ -201,7 +201,7 @@ int skeinUpdateBits(struct skein_ctx *ctx, const u8 *msg,
*/
up = (u8 *)ctx->m.s256.X + ctx->skeinSize / 8;
/* set tweak flag for the skeinFinal call */
/* set tweak flag for the skein_final call */
Skein_Set_Bit_Pad_Flag(ctx->m.h);
/* now "pad" the final partial byte the way NIST likes */
......@@ -217,20 +217,20 @@ int skeinUpdateBits(struct skein_ctx *ctx, const u8 *msg,
return SKEIN_SUCCESS;
}
int skeinFinal(struct skein_ctx *ctx, u8 *hash)
int skein_final(struct skein_ctx *ctx, u8 *hash)
{
int ret = SKEIN_FAIL;
Skein_Assert(ctx, SKEIN_FAIL);
switch (ctx->skeinSize) {
case Skein256:
ret = Skein_256_Final(&ctx->m.s256, (u8 *)hash);
ret = skein_256_final(&ctx->m.s256, (u8 *)hash);
break;
case Skein512:
ret = Skein_512_Final(&ctx->m.s512, (u8 *)hash);
ret = skein_512_final(&ctx->m.s512, (u8 *)hash);
break;
case Skein1024:
ret = Skein1024_Final(&ctx->m.s1024, (u8 *)hash);
ret = skein_1024_final(&ctx->m.s1024, (u8 *)hash);
break;
}
return ret;
......
......@@ -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;
......
......@@ -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;
}
......
......@@ -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],
......
......@@ -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];
......
......@@ -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],
......
......@@ -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;
}
}
......
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